aboutsummaryrefslogtreecommitdiffstats
path: root/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/src-gen/hu/bme/mit/inf/dslreasoner/parser/antlr/internal/InternalAlloyLanguageLexer.java
diff options
context:
space:
mode:
Diffstat (limited to 'Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/src-gen/hu/bme/mit/inf/dslreasoner/parser/antlr/internal/InternalAlloyLanguageLexer.java')
-rw-r--r--Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/src-gen/hu/bme/mit/inf/dslreasoner/parser/antlr/internal/InternalAlloyLanguageLexer.java2816
1 files changed, 2816 insertions, 0 deletions
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/src-gen/hu/bme/mit/inf/dslreasoner/parser/antlr/internal/InternalAlloyLanguageLexer.java b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/src-gen/hu/bme/mit/inf/dslreasoner/parser/antlr/internal/InternalAlloyLanguageLexer.java
new file mode 100644
index 00000000..27488784
--- /dev/null
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/src-gen/hu/bme/mit/inf/dslreasoner/parser/antlr/internal/InternalAlloyLanguageLexer.java
@@ -0,0 +1,2816 @@
1package hu.bme.mit.inf.dslreasoner.parser.antlr.internal;
2
3// Hack: Use our own Lexer superclass by means of import.
4// Currently there is no other way to specify the superclass for the lexer.
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 InternalAlloyLanguageLexer extends Lexer {
15 public static final int T__50=50;
16 public static final int T__19=19;
17 public static final int T__15=15;
18 public static final int T__59=59;
19 public static final int T__16=16;
20 public static final int T__17=17;
21 public static final int T__18=18;
22 public static final int T__11=11;
23 public static final int T__55=55;
24 public static final int T__12=12;
25 public static final int T__56=56;
26 public static final int T__13=13;
27 public static final int T__57=57;
28 public static final int T__14=14;
29 public static final int T__58=58;
30 public static final int T__51=51;
31 public static final int T__52=52;
32 public static final int T__53=53;
33 public static final int T__54=54;
34 public static final int T__60=60;
35 public static final int T__61=61;
36 public static final int RULE_ID=4;
37 public static final int T__26=26;
38 public static final int T__27=27;
39 public static final int T__28=28;
40 public static final int RULE_INT=5;
41 public static final int T__29=29;
42 public static final int T__22=22;
43 public static final int T__66=66;
44 public static final int RULE_ML_COMMENT=7;
45 public static final int T__23=23;
46 public static final int T__67=67;
47 public static final int T__24=24;
48 public static final int T__68=68;
49 public static final int T__25=25;
50 public static final int T__69=69;
51 public static final int T__62=62;
52 public static final int T__63=63;
53 public static final int T__20=20;
54 public static final int T__64=64;
55 public static final int T__21=21;
56 public static final int T__65=65;
57 public static final int T__70=70;
58 public static final int T__71=71;
59 public static final int T__72=72;
60 public static final int RULE_STRING=6;
61 public static final int RULE_SL_COMMENT=8;
62 public static final int T__37=37;
63 public static final int T__38=38;
64 public static final int T__39=39;
65 public static final int T__33=33;
66 public static final int T__34=34;
67 public static final int T__35=35;
68 public static final int T__36=36;
69 public static final int T__73=73;
70 public static final int EOF=-1;
71 public static final int T__30=30;
72 public static final int T__74=74;
73 public static final int T__31=31;
74 public static final int T__75=75;
75 public static final int T__32=32;
76 public static final int RULE_WS=9;
77 public static final int RULE_ANY_OTHER=10;
78 public static final int T__48=48;
79 public static final int T__49=49;
80 public static final int T__44=44;
81 public static final int T__45=45;
82 public static final int T__46=46;
83 public static final int T__47=47;
84 public static final int T__40=40;
85 public static final int T__41=41;
86 public static final int T__42=42;
87 public static final int T__43=43;
88
89 // delegates
90 // delegators
91
92 public InternalAlloyLanguageLexer() {;}
93 public InternalAlloyLanguageLexer(CharStream input) {
94 this(input, new RecognizerSharedState());
95 }
96 public InternalAlloyLanguageLexer(CharStream input, RecognizerSharedState state) {
97 super(input,state);
98
99 }
100 public String getGrammarFileName() { return "InternalAlloyLanguage.g"; }
101
102 // $ANTLR start "T__11"
103 public final void mT__11() throws RecognitionException {
104 try {
105 int _type = T__11;
106 int _channel = DEFAULT_TOKEN_CHANNEL;
107 // InternalAlloyLanguage.g:11:7: ( 'enum' )
108 // InternalAlloyLanguage.g:11:9: 'enum'
109 {
110 match("enum");
111
112
113 }
114
115 state.type = _type;
116 state.channel = _channel;
117 }
118 finally {
119 }
120 }
121 // $ANTLR end "T__11"
122
123 // $ANTLR start "T__12"
124 public final void mT__12() throws RecognitionException {
125 try {
126 int _type = T__12;
127 int _channel = DEFAULT_TOKEN_CHANNEL;
128 // InternalAlloyLanguage.g:12:7: ( '{' )
129 // InternalAlloyLanguage.g:12:9: '{'
130 {
131 match('{');
132
133 }
134
135 state.type = _type;
136 state.channel = _channel;
137 }
138 finally {
139 }
140 }
141 // $ANTLR end "T__12"
142
143 // $ANTLR start "T__13"
144 public final void mT__13() throws RecognitionException {
145 try {
146 int _type = T__13;
147 int _channel = DEFAULT_TOKEN_CHANNEL;
148 // InternalAlloyLanguage.g:13:7: ( ',' )
149 // InternalAlloyLanguage.g:13:9: ','
150 {
151 match(',');
152
153 }
154
155 state.type = _type;
156 state.channel = _channel;
157 }
158 finally {
159 }
160 }
161 // $ANTLR end "T__13"
162
163 // $ANTLR start "T__14"
164 public final void mT__14() throws RecognitionException {
165 try {
166 int _type = T__14;
167 int _channel = DEFAULT_TOKEN_CHANNEL;
168 // InternalAlloyLanguage.g:14:7: ( '}' )
169 // InternalAlloyLanguage.g:14:9: '}'
170 {
171 match('}');
172
173 }
174
175 state.type = _type;
176 state.channel = _channel;
177 }
178 finally {
179 }
180 }
181 // $ANTLR end "T__14"
182
183 // $ANTLR start "T__15"
184 public final void mT__15() throws RecognitionException {
185 try {
186 int _type = T__15;
187 int _channel = DEFAULT_TOKEN_CHANNEL;
188 // InternalAlloyLanguage.g:15:7: ( 'abstract' )
189 // InternalAlloyLanguage.g:15:9: 'abstract'
190 {
191 match("abstract");
192
193
194 }
195
196 state.type = _type;
197 state.channel = _channel;
198 }
199 finally {
200 }
201 }
202 // $ANTLR end "T__15"
203
204 // $ANTLR start "T__16"
205 public final void mT__16() throws RecognitionException {
206 try {
207 int _type = T__16;
208 int _channel = DEFAULT_TOKEN_CHANNEL;
209 // InternalAlloyLanguage.g:16:7: ( 'sig' )
210 // InternalAlloyLanguage.g:16:9: 'sig'
211 {
212 match("sig");
213
214
215 }
216
217 state.type = _type;
218 state.channel = _channel;
219 }
220 finally {
221 }
222 }
223 // $ANTLR end "T__16"
224
225 // $ANTLR start "T__17"
226 public final void mT__17() throws RecognitionException {
227 try {
228 int _type = T__17;
229 int _channel = DEFAULT_TOKEN_CHANNEL;
230 // InternalAlloyLanguage.g:17:7: ( 'extends' )
231 // InternalAlloyLanguage.g:17:9: 'extends'
232 {
233 match("extends");
234
235
236 }
237
238 state.type = _type;
239 state.channel = _channel;
240 }
241 finally {
242 }
243 }
244 // $ANTLR end "T__17"
245
246 // $ANTLR start "T__18"
247 public final void mT__18() throws RecognitionException {
248 try {
249 int _type = T__18;
250 int _channel = DEFAULT_TOKEN_CHANNEL;
251 // InternalAlloyLanguage.g:18:7: ( 'in' )
252 // InternalAlloyLanguage.g:18:9: 'in'
253 {
254 match("in");
255
256
257 }
258
259 state.type = _type;
260 state.channel = _channel;
261 }
262 finally {
263 }
264 }
265 // $ANTLR end "T__18"
266
267 // $ANTLR start "T__19"
268 public final void mT__19() throws RecognitionException {
269 try {
270 int _type = T__19;
271 int _channel = DEFAULT_TOKEN_CHANNEL;
272 // InternalAlloyLanguage.g:19:7: ( '+' )
273 // InternalAlloyLanguage.g:19:9: '+'
274 {
275 match('+');
276
277 }
278
279 state.type = _type;
280 state.channel = _channel;
281 }
282 finally {
283 }
284 }
285 // $ANTLR end "T__19"
286
287 // $ANTLR start "T__20"
288 public final void mT__20() throws RecognitionException {
289 try {
290 int _type = T__20;
291 int _channel = DEFAULT_TOKEN_CHANNEL;
292 // InternalAlloyLanguage.g:20:7: ( ':' )
293 // InternalAlloyLanguage.g:20:9: ':'
294 {
295 match(':');
296
297 }
298
299 state.type = _type;
300 state.channel = _channel;
301 }
302 finally {
303 }
304 }
305 // $ANTLR end "T__20"
306
307 // $ANTLR start "T__21"
308 public final void mT__21() throws RecognitionException {
309 try {
310 int _type = T__21;
311 int _channel = DEFAULT_TOKEN_CHANNEL;
312 // InternalAlloyLanguage.g:21:7: ( 'fun' )
313 // InternalAlloyLanguage.g:21:9: 'fun'
314 {
315 match("fun");
316
317
318 }
319
320 state.type = _type;
321 state.channel = _channel;
322 }
323 finally {
324 }
325 }
326 // $ANTLR end "T__21"
327
328 // $ANTLR start "T__22"
329 public final void mT__22() throws RecognitionException {
330 try {
331 int _type = T__22;
332 int _channel = DEFAULT_TOKEN_CHANNEL;
333 // InternalAlloyLanguage.g:22:7: ( '[' )
334 // InternalAlloyLanguage.g:22:9: '['
335 {
336 match('[');
337
338 }
339
340 state.type = _type;
341 state.channel = _channel;
342 }
343 finally {
344 }
345 }
346 // $ANTLR end "T__22"
347
348 // $ANTLR start "T__23"
349 public final void mT__23() throws RecognitionException {
350 try {
351 int _type = T__23;
352 int _channel = DEFAULT_TOKEN_CHANNEL;
353 // InternalAlloyLanguage.g:23:7: ( ']' )
354 // InternalAlloyLanguage.g:23:9: ']'
355 {
356 match(']');
357
358 }
359
360 state.type = _type;
361 state.channel = _channel;
362 }
363 finally {
364 }
365 }
366 // $ANTLR end "T__23"
367
368 // $ANTLR start "T__24"
369 public final void mT__24() throws RecognitionException {
370 try {
371 int _type = T__24;
372 int _channel = DEFAULT_TOKEN_CHANNEL;
373 // InternalAlloyLanguage.g:24:7: ( 'pred' )
374 // InternalAlloyLanguage.g:24:9: 'pred'
375 {
376 match("pred");
377
378
379 }
380
381 state.type = _type;
382 state.channel = _channel;
383 }
384 finally {
385 }
386 }
387 // $ANTLR end "T__24"
388
389 // $ANTLR start "T__25"
390 public final void mT__25() throws RecognitionException {
391 try {
392 int _type = T__25;
393 int _channel = DEFAULT_TOKEN_CHANNEL;
394 // InternalAlloyLanguage.g:25:7: ( 'fact' )
395 // InternalAlloyLanguage.g:25:9: 'fact'
396 {
397 match("fact");
398
399
400 }
401
402 state.type = _type;
403 state.channel = _channel;
404 }
405 finally {
406 }
407 }
408 // $ANTLR end "T__25"
409
410 // $ANTLR start "T__26"
411 public final void mT__26() throws RecognitionException {
412 try {
413 int _type = T__26;
414 int _channel = DEFAULT_TOKEN_CHANNEL;
415 // InternalAlloyLanguage.g:26:7: ( 'disj' )
416 // InternalAlloyLanguage.g:26:9: 'disj'
417 {
418 match("disj");
419
420
421 }
422
423 state.type = _type;
424 state.channel = _channel;
425 }
426 finally {
427 }
428 }
429 // $ANTLR end "T__26"
430
431 // $ANTLR start "T__27"
432 public final void mT__27() throws RecognitionException {
433 try {
434 int _type = T__27;
435 int _channel = DEFAULT_TOKEN_CHANNEL;
436 // InternalAlloyLanguage.g:27:7: ( '||' )
437 // InternalAlloyLanguage.g:27:9: '||'
438 {
439 match("||");
440
441
442 }
443
444 state.type = _type;
445 state.channel = _channel;
446 }
447 finally {
448 }
449 }
450 // $ANTLR end "T__27"
451
452 // $ANTLR start "T__28"
453 public final void mT__28() throws RecognitionException {
454 try {
455 int _type = T__28;
456 int _channel = DEFAULT_TOKEN_CHANNEL;
457 // InternalAlloyLanguage.g:28:7: ( 'or' )
458 // InternalAlloyLanguage.g:28:9: 'or'
459 {
460 match("or");
461
462
463 }
464
465 state.type = _type;
466 state.channel = _channel;
467 }
468 finally {
469 }
470 }
471 // $ANTLR end "T__28"
472
473 // $ANTLR start "T__29"
474 public final void mT__29() throws RecognitionException {
475 try {
476 int _type = T__29;
477 int _channel = DEFAULT_TOKEN_CHANNEL;
478 // InternalAlloyLanguage.g:29:7: ( '<=>' )
479 // InternalAlloyLanguage.g:29:9: '<=>'
480 {
481 match("<=>");
482
483
484 }
485
486 state.type = _type;
487 state.channel = _channel;
488 }
489 finally {
490 }
491 }
492 // $ANTLR end "T__29"
493
494 // $ANTLR start "T__30"
495 public final void mT__30() throws RecognitionException {
496 try {
497 int _type = T__30;
498 int _channel = DEFAULT_TOKEN_CHANNEL;
499 // InternalAlloyLanguage.g:30:7: ( 'iff' )
500 // InternalAlloyLanguage.g:30:9: 'iff'
501 {
502 match("iff");
503
504
505 }
506
507 state.type = _type;
508 state.channel = _channel;
509 }
510 finally {
511 }
512 }
513 // $ANTLR end "T__30"
514
515 // $ANTLR start "T__31"
516 public final void mT__31() throws RecognitionException {
517 try {
518 int _type = T__31;
519 int _channel = DEFAULT_TOKEN_CHANNEL;
520 // InternalAlloyLanguage.g:31:7: ( '=>' )
521 // InternalAlloyLanguage.g:31:9: '=>'
522 {
523 match("=>");
524
525
526 }
527
528 state.type = _type;
529 state.channel = _channel;
530 }
531 finally {
532 }
533 }
534 // $ANTLR end "T__31"
535
536 // $ANTLR start "T__32"
537 public final void mT__32() throws RecognitionException {
538 try {
539 int _type = T__32;
540 int _channel = DEFAULT_TOKEN_CHANNEL;
541 // InternalAlloyLanguage.g:32:7: ( 'implies' )
542 // InternalAlloyLanguage.g:32:9: 'implies'
543 {
544 match("implies");
545
546
547 }
548
549 state.type = _type;
550 state.channel = _channel;
551 }
552 finally {
553 }
554 }
555 // $ANTLR end "T__32"
556
557 // $ANTLR start "T__33"
558 public final void mT__33() throws RecognitionException {
559 try {
560 int _type = T__33;
561 int _channel = DEFAULT_TOKEN_CHANNEL;
562 // InternalAlloyLanguage.g:33:7: ( 'else' )
563 // InternalAlloyLanguage.g:33:9: 'else'
564 {
565 match("else");
566
567
568 }
569
570 state.type = _type;
571 state.channel = _channel;
572 }
573 finally {
574 }
575 }
576 // $ANTLR end "T__33"
577
578 // $ANTLR start "T__34"
579 public final void mT__34() throws RecognitionException {
580 try {
581 int _type = T__34;
582 int _channel = DEFAULT_TOKEN_CHANNEL;
583 // InternalAlloyLanguage.g:34:7: ( '&&' )
584 // InternalAlloyLanguage.g:34:9: '&&'
585 {
586 match("&&");
587
588
589 }
590
591 state.type = _type;
592 state.channel = _channel;
593 }
594 finally {
595 }
596 }
597 // $ANTLR end "T__34"
598
599 // $ANTLR start "T__35"
600 public final void mT__35() throws RecognitionException {
601 try {
602 int _type = T__35;
603 int _channel = DEFAULT_TOKEN_CHANNEL;
604 // InternalAlloyLanguage.g:35:7: ( 'and' )
605 // InternalAlloyLanguage.g:35:9: 'and'
606 {
607 match("and");
608
609
610 }
611
612 state.type = _type;
613 state.channel = _channel;
614 }
615 finally {
616 }
617 }
618 // $ANTLR end "T__35"
619
620 // $ANTLR start "T__36"
621 public final void mT__36() throws RecognitionException {
622 try {
623 int _type = T__36;
624 int _channel = DEFAULT_TOKEN_CHANNEL;
625 // InternalAlloyLanguage.g:36:7: ( '=' )
626 // InternalAlloyLanguage.g:36:9: '='
627 {
628 match('=');
629
630 }
631
632 state.type = _type;
633 state.channel = _channel;
634 }
635 finally {
636 }
637 }
638 // $ANTLR end "T__36"
639
640 // $ANTLR start "T__37"
641 public final void mT__37() throws RecognitionException {
642 try {
643 int _type = T__37;
644 int _channel = DEFAULT_TOKEN_CHANNEL;
645 // InternalAlloyLanguage.g:37:7: ( '!=' )
646 // InternalAlloyLanguage.g:37:9: '!='
647 {
648 match("!=");
649
650
651 }
652
653 state.type = _type;
654 state.channel = _channel;
655 }
656 finally {
657 }
658 }
659 // $ANTLR end "T__37"
660
661 // $ANTLR start "T__38"
662 public final void mT__38() throws RecognitionException {
663 try {
664 int _type = T__38;
665 int _channel = DEFAULT_TOKEN_CHANNEL;
666 // InternalAlloyLanguage.g:38:7: ( '>' )
667 // InternalAlloyLanguage.g:38:9: '>'
668 {
669 match('>');
670
671 }
672
673 state.type = _type;
674 state.channel = _channel;
675 }
676 finally {
677 }
678 }
679 // $ANTLR end "T__38"
680
681 // $ANTLR start "T__39"
682 public final void mT__39() throws RecognitionException {
683 try {
684 int _type = T__39;
685 int _channel = DEFAULT_TOKEN_CHANNEL;
686 // InternalAlloyLanguage.g:39:7: ( '>=' )
687 // InternalAlloyLanguage.g:39:9: '>='
688 {
689 match(">=");
690
691
692 }
693
694 state.type = _type;
695 state.channel = _channel;
696 }
697 finally {
698 }
699 }
700 // $ANTLR end "T__39"
701
702 // $ANTLR start "T__40"
703 public final void mT__40() throws RecognitionException {
704 try {
705 int _type = T__40;
706 int _channel = DEFAULT_TOKEN_CHANNEL;
707 // InternalAlloyLanguage.g:40:7: ( '<' )
708 // InternalAlloyLanguage.g:40:9: '<'
709 {
710 match('<');
711
712 }
713
714 state.type = _type;
715 state.channel = _channel;
716 }
717 finally {
718 }
719 }
720 // $ANTLR end "T__40"
721
722 // $ANTLR start "T__41"
723 public final void mT__41() throws RecognitionException {
724 try {
725 int _type = T__41;
726 int _channel = DEFAULT_TOKEN_CHANNEL;
727 // InternalAlloyLanguage.g:41:7: ( '<=' )
728 // InternalAlloyLanguage.g:41:9: '<='
729 {
730 match("<=");
731
732
733 }
734
735 state.type = _type;
736 state.channel = _channel;
737 }
738 finally {
739 }
740 }
741 // $ANTLR end "T__41"
742
743 // $ANTLR start "T__42"
744 public final void mT__42() throws RecognitionException {
745 try {
746 int _type = T__42;
747 int _channel = DEFAULT_TOKEN_CHANNEL;
748 // InternalAlloyLanguage.g:42:7: ( '++' )
749 // InternalAlloyLanguage.g:42:9: '++'
750 {
751 match("++");
752
753
754 }
755
756 state.type = _type;
757 state.channel = _channel;
758 }
759 finally {
760 }
761 }
762 // $ANTLR end "T__42"
763
764 // $ANTLR start "T__43"
765 public final void mT__43() throws RecognitionException {
766 try {
767 int _type = T__43;
768 int _channel = DEFAULT_TOKEN_CHANNEL;
769 // InternalAlloyLanguage.g:43:7: ( ':>' )
770 // InternalAlloyLanguage.g:43:9: ':>'
771 {
772 match(":>");
773
774
775 }
776
777 state.type = _type;
778 state.channel = _channel;
779 }
780 finally {
781 }
782 }
783 // $ANTLR end "T__43"
784
785 // $ANTLR start "T__44"
786 public final void mT__44() throws RecognitionException {
787 try {
788 int _type = T__44;
789 int _channel = DEFAULT_TOKEN_CHANNEL;
790 // InternalAlloyLanguage.g:44:7: ( '<:' )
791 // InternalAlloyLanguage.g:44:9: '<:'
792 {
793 match("<:");
794
795
796 }
797
798 state.type = _type;
799 state.channel = _channel;
800 }
801 finally {
802 }
803 }
804 // $ANTLR end "T__44"
805
806 // $ANTLR start "T__45"
807 public final void mT__45() throws RecognitionException {
808 try {
809 int _type = T__45;
810 int _channel = DEFAULT_TOKEN_CHANNEL;
811 // InternalAlloyLanguage.g:45:7: ( '.' )
812 // InternalAlloyLanguage.g:45:9: '.'
813 {
814 match('.');
815
816 }
817
818 state.type = _type;
819 state.channel = _channel;
820 }
821 finally {
822 }
823 }
824 // $ANTLR end "T__45"
825
826 // $ANTLR start "T__46"
827 public final void mT__46() throws RecognitionException {
828 try {
829 int _type = T__46;
830 int _channel = DEFAULT_TOKEN_CHANNEL;
831 // InternalAlloyLanguage.g:46:7: ( '-' )
832 // InternalAlloyLanguage.g:46:9: '-'
833 {
834 match('-');
835
836 }
837
838 state.type = _type;
839 state.channel = _channel;
840 }
841 finally {
842 }
843 }
844 // $ANTLR end "T__46"
845
846 // $ANTLR start "T__47"
847 public final void mT__47() throws RecognitionException {
848 try {
849 int _type = T__47;
850 int _channel = DEFAULT_TOKEN_CHANNEL;
851 // InternalAlloyLanguage.g:47:7: ( '&' )
852 // InternalAlloyLanguage.g:47:9: '&'
853 {
854 match('&');
855
856 }
857
858 state.type = _type;
859 state.channel = _channel;
860 }
861 finally {
862 }
863 }
864 // $ANTLR end "T__47"
865
866 // $ANTLR start "T__48"
867 public final void mT__48() throws RecognitionException {
868 try {
869 int _type = T__48;
870 int _channel = DEFAULT_TOKEN_CHANNEL;
871 // InternalAlloyLanguage.g:48:7: ( '->' )
872 // InternalAlloyLanguage.g:48:9: '->'
873 {
874 match("->");
875
876
877 }
878
879 state.type = _type;
880 state.channel = _channel;
881 }
882 finally {
883 }
884 }
885 // $ANTLR end "T__48"
886
887 // $ANTLR start "T__49"
888 public final void mT__49() throws RecognitionException {
889 try {
890 int _type = T__49;
891 int _channel = DEFAULT_TOKEN_CHANNEL;
892 // InternalAlloyLanguage.g:49:7: ( '!' )
893 // InternalAlloyLanguage.g:49:9: '!'
894 {
895 match('!');
896
897 }
898
899 state.type = _type;
900 state.channel = _channel;
901 }
902 finally {
903 }
904 }
905 // $ANTLR end "T__49"
906
907 // $ANTLR start "T__50"
908 public final void mT__50() throws RecognitionException {
909 try {
910 int _type = T__50;
911 int _channel = DEFAULT_TOKEN_CHANNEL;
912 // InternalAlloyLanguage.g:50:7: ( 'not' )
913 // InternalAlloyLanguage.g:50:9: 'not'
914 {
915 match("not");
916
917
918 }
919
920 state.type = _type;
921 state.channel = _channel;
922 }
923 finally {
924 }
925 }
926 // $ANTLR end "T__50"
927
928 // $ANTLR start "T__51"
929 public final void mT__51() throws RecognitionException {
930 try {
931 int _type = T__51;
932 int _channel = DEFAULT_TOKEN_CHANNEL;
933 // InternalAlloyLanguage.g:51:7: ( '~' )
934 // InternalAlloyLanguage.g:51:9: '~'
935 {
936 match('~');
937
938 }
939
940 state.type = _type;
941 state.channel = _channel;
942 }
943 finally {
944 }
945 }
946 // $ANTLR end "T__51"
947
948 // $ANTLR start "T__52"
949 public final void mT__52() throws RecognitionException {
950 try {
951 int _type = T__52;
952 int _channel = DEFAULT_TOKEN_CHANNEL;
953 // InternalAlloyLanguage.g:52:7: ( '^' )
954 // InternalAlloyLanguage.g:52:9: '^'
955 {
956 match('^');
957
958 }
959
960 state.type = _type;
961 state.channel = _channel;
962 }
963 finally {
964 }
965 }
966 // $ANTLR end "T__52"
967
968 // $ANTLR start "T__53"
969 public final void mT__53() throws RecognitionException {
970 try {
971 int _type = T__53;
972 int _channel = DEFAULT_TOKEN_CHANNEL;
973 // InternalAlloyLanguage.g:53:7: ( '*' )
974 // InternalAlloyLanguage.g:53:9: '*'
975 {
976 match('*');
977
978 }
979
980 state.type = _type;
981 state.channel = _channel;
982 }
983 finally {
984 }
985 }
986 // $ANTLR end "T__53"
987
988 // $ANTLR start "T__54"
989 public final void mT__54() throws RecognitionException {
990 try {
991 int _type = T__54;
992 int _channel = DEFAULT_TOKEN_CHANNEL;
993 // InternalAlloyLanguage.g:54:7: ( '#' )
994 // InternalAlloyLanguage.g:54:9: '#'
995 {
996 match('#');
997
998 }
999
1000 state.type = _type;
1001 state.channel = _channel;
1002 }
1003 finally {
1004 }
1005 }
1006 // $ANTLR end "T__54"
1007
1008 // $ANTLR start "T__55"
1009 public final void mT__55() throws RecognitionException {
1010 try {
1011 int _type = T__55;
1012 int _channel = DEFAULT_TOKEN_CHANNEL;
1013 // InternalAlloyLanguage.g:55:7: ( 'sum' )
1014 // InternalAlloyLanguage.g:55:9: 'sum'
1015 {
1016 match("sum");
1017
1018
1019 }
1020
1021 state.type = _type;
1022 state.channel = _channel;
1023 }
1024 finally {
1025 }
1026 }
1027 // $ANTLR end "T__55"
1028
1029 // $ANTLR start "T__56"
1030 public final void mT__56() throws RecognitionException {
1031 try {
1032 int _type = T__56;
1033 int _channel = DEFAULT_TOKEN_CHANNEL;
1034 // InternalAlloyLanguage.g:56:7: ( 'none' )
1035 // InternalAlloyLanguage.g:56:9: 'none'
1036 {
1037 match("none");
1038
1039
1040 }
1041
1042 state.type = _type;
1043 state.channel = _channel;
1044 }
1045 finally {
1046 }
1047 }
1048 // $ANTLR end "T__56"
1049
1050 // $ANTLR start "T__57"
1051 public final void mT__57() throws RecognitionException {
1052 try {
1053 int _type = T__57;
1054 int _channel = DEFAULT_TOKEN_CHANNEL;
1055 // InternalAlloyLanguage.g:57:7: ( 'iden' )
1056 // InternalAlloyLanguage.g:57:9: 'iden'
1057 {
1058 match("iden");
1059
1060
1061 }
1062
1063 state.type = _type;
1064 state.channel = _channel;
1065 }
1066 finally {
1067 }
1068 }
1069 // $ANTLR end "T__57"
1070
1071 // $ANTLR start "T__58"
1072 public final void mT__58() throws RecognitionException {
1073 try {
1074 int _type = T__58;
1075 int _channel = DEFAULT_TOKEN_CHANNEL;
1076 // InternalAlloyLanguage.g:58:7: ( 'univ' )
1077 // InternalAlloyLanguage.g:58:9: 'univ'
1078 {
1079 match("univ");
1080
1081
1082 }
1083
1084 state.type = _type;
1085 state.channel = _channel;
1086 }
1087 finally {
1088 }
1089 }
1090 // $ANTLR end "T__58"
1091
1092 // $ANTLR start "T__59"
1093 public final void mT__59() throws RecognitionException {
1094 try {
1095 int _type = T__59;
1096 int _channel = DEFAULT_TOKEN_CHANNEL;
1097 // InternalAlloyLanguage.g:59:7: ( 'Int' )
1098 // InternalAlloyLanguage.g:59:9: 'Int'
1099 {
1100 match("Int");
1101
1102
1103 }
1104
1105 state.type = _type;
1106 state.channel = _channel;
1107 }
1108 finally {
1109 }
1110 }
1111 // $ANTLR end "T__59"
1112
1113 // $ANTLR start "T__60"
1114 public final void mT__60() throws RecognitionException {
1115 try {
1116 int _type = T__60;
1117 int _channel = DEFAULT_TOKEN_CHANNEL;
1118 // InternalAlloyLanguage.g:60:7: ( '(' )
1119 // InternalAlloyLanguage.g:60:9: '('
1120 {
1121 match('(');
1122
1123 }
1124
1125 state.type = _type;
1126 state.channel = _channel;
1127 }
1128 finally {
1129 }
1130 }
1131 // $ANTLR end "T__60"
1132
1133 // $ANTLR start "T__61"
1134 public final void mT__61() throws RecognitionException {
1135 try {
1136 int _type = T__61;
1137 int _channel = DEFAULT_TOKEN_CHANNEL;
1138 // InternalAlloyLanguage.g:61:7: ( ')' )
1139 // InternalAlloyLanguage.g:61:9: ')'
1140 {
1141 match(')');
1142
1143 }
1144
1145 state.type = _type;
1146 state.channel = _channel;
1147 }
1148 finally {
1149 }
1150 }
1151 // $ANTLR end "T__61"
1152
1153 // $ANTLR start "T__62"
1154 public final void mT__62() throws RecognitionException {
1155 try {
1156 int _type = T__62;
1157 int _channel = DEFAULT_TOKEN_CHANNEL;
1158 // InternalAlloyLanguage.g:62:7: ( 'run' )
1159 // InternalAlloyLanguage.g:62:9: 'run'
1160 {
1161 match("run");
1162
1163
1164 }
1165
1166 state.type = _type;
1167 state.channel = _channel;
1168 }
1169 finally {
1170 }
1171 }
1172 // $ANTLR end "T__62"
1173
1174 // $ANTLR start "T__63"
1175 public final void mT__63() throws RecognitionException {
1176 try {
1177 int _type = T__63;
1178 int _channel = DEFAULT_TOKEN_CHANNEL;
1179 // InternalAlloyLanguage.g:63:7: ( 'for' )
1180 // InternalAlloyLanguage.g:63:9: 'for'
1181 {
1182 match("for");
1183
1184
1185 }
1186
1187 state.type = _type;
1188 state.channel = _channel;
1189 }
1190 finally {
1191 }
1192 }
1193 // $ANTLR end "T__63"
1194
1195 // $ANTLR start "T__64"
1196 public final void mT__64() throws RecognitionException {
1197 try {
1198 int _type = T__64;
1199 int _channel = DEFAULT_TOKEN_CHANNEL;
1200 // InternalAlloyLanguage.g:64:7: ( 'exactly' )
1201 // InternalAlloyLanguage.g:64:9: 'exactly'
1202 {
1203 match("exactly");
1204
1205
1206 }
1207
1208 state.type = _type;
1209 state.channel = _channel;
1210 }
1211 finally {
1212 }
1213 }
1214 // $ANTLR end "T__64"
1215
1216 // $ANTLR start "T__65"
1217 public final void mT__65() throws RecognitionException {
1218 try {
1219 int _type = T__65;
1220 int _channel = DEFAULT_TOKEN_CHANNEL;
1221 // InternalAlloyLanguage.g:65:7: ( 'all' )
1222 // InternalAlloyLanguage.g:65:9: 'all'
1223 {
1224 match("all");
1225
1226
1227 }
1228
1229 state.type = _type;
1230 state.channel = _channel;
1231 }
1232 finally {
1233 }
1234 }
1235 // $ANTLR end "T__65"
1236
1237 // $ANTLR start "T__66"
1238 public final void mT__66() throws RecognitionException {
1239 try {
1240 int _type = T__66;
1241 int _channel = DEFAULT_TOKEN_CHANNEL;
1242 // InternalAlloyLanguage.g:66:7: ( 'no' )
1243 // InternalAlloyLanguage.g:66:9: 'no'
1244 {
1245 match("no");
1246
1247
1248 }
1249
1250 state.type = _type;
1251 state.channel = _channel;
1252 }
1253 finally {
1254 }
1255 }
1256 // $ANTLR end "T__66"
1257
1258 // $ANTLR start "T__67"
1259 public final void mT__67() throws RecognitionException {
1260 try {
1261 int _type = T__67;
1262 int _channel = DEFAULT_TOKEN_CHANNEL;
1263 // InternalAlloyLanguage.g:67:7: ( 'some' )
1264 // InternalAlloyLanguage.g:67:9: 'some'
1265 {
1266 match("some");
1267
1268
1269 }
1270
1271 state.type = _type;
1272 state.channel = _channel;
1273 }
1274 finally {
1275 }
1276 }
1277 // $ANTLR end "T__67"
1278
1279 // $ANTLR start "T__68"
1280 public final void mT__68() throws RecognitionException {
1281 try {
1282 int _type = T__68;
1283 int _channel = DEFAULT_TOKEN_CHANNEL;
1284 // InternalAlloyLanguage.g:68:7: ( 'lone' )
1285 // InternalAlloyLanguage.g:68:9: 'lone'
1286 {
1287 match("lone");
1288
1289
1290 }
1291
1292 state.type = _type;
1293 state.channel = _channel;
1294 }
1295 finally {
1296 }
1297 }
1298 // $ANTLR end "T__68"
1299
1300 // $ANTLR start "T__69"
1301 public final void mT__69() throws RecognitionException {
1302 try {
1303 int _type = T__69;
1304 int _channel = DEFAULT_TOKEN_CHANNEL;
1305 // InternalAlloyLanguage.g:69:7: ( 'one' )
1306 // InternalAlloyLanguage.g:69:9: 'one'
1307 {
1308 match("one");
1309
1310
1311 }
1312
1313 state.type = _type;
1314 state.channel = _channel;
1315 }
1316 finally {
1317 }
1318 }
1319 // $ANTLR end "T__69"
1320
1321 // $ANTLR start "T__70"
1322 public final void mT__70() throws RecognitionException {
1323 try {
1324 int _type = T__70;
1325 int _channel = DEFAULT_TOKEN_CHANNEL;
1326 // InternalAlloyLanguage.g:70:7: ( 'set' )
1327 // InternalAlloyLanguage.g:70:9: 'set'
1328 {
1329 match("set");
1330
1331
1332 }
1333
1334 state.type = _type;
1335 state.channel = _channel;
1336 }
1337 finally {
1338 }
1339 }
1340 // $ANTLR end "T__70"
1341
1342 // $ANTLR start "T__71"
1343 public final void mT__71() throws RecognitionException {
1344 try {
1345 int _type = T__71;
1346 int _channel = DEFAULT_TOKEN_CHANNEL;
1347 // InternalAlloyLanguage.g:71:7: ( 'plus' )
1348 // InternalAlloyLanguage.g:71:9: 'plus'
1349 {
1350 match("plus");
1351
1352
1353 }
1354
1355 state.type = _type;
1356 state.channel = _channel;
1357 }
1358 finally {
1359 }
1360 }
1361 // $ANTLR end "T__71"
1362
1363 // $ANTLR start "T__72"
1364 public final void mT__72() throws RecognitionException {
1365 try {
1366 int _type = T__72;
1367 int _channel = DEFAULT_TOKEN_CHANNEL;
1368 // InternalAlloyLanguage.g:72:7: ( 'sub' )
1369 // InternalAlloyLanguage.g:72:9: 'sub'
1370 {
1371 match("sub");
1372
1373
1374 }
1375
1376 state.type = _type;
1377 state.channel = _channel;
1378 }
1379 finally {
1380 }
1381 }
1382 // $ANTLR end "T__72"
1383
1384 // $ANTLR start "T__73"
1385 public final void mT__73() throws RecognitionException {
1386 try {
1387 int _type = T__73;
1388 int _channel = DEFAULT_TOKEN_CHANNEL;
1389 // InternalAlloyLanguage.g:73:7: ( 'mul' )
1390 // InternalAlloyLanguage.g:73:9: 'mul'
1391 {
1392 match("mul");
1393
1394
1395 }
1396
1397 state.type = _type;
1398 state.channel = _channel;
1399 }
1400 finally {
1401 }
1402 }
1403 // $ANTLR end "T__73"
1404
1405 // $ANTLR start "T__74"
1406 public final void mT__74() throws RecognitionException {
1407 try {
1408 int _type = T__74;
1409 int _channel = DEFAULT_TOKEN_CHANNEL;
1410 // InternalAlloyLanguage.g:74:7: ( 'rem' )
1411 // InternalAlloyLanguage.g:74:9: 'rem'
1412 {
1413 match("rem");
1414
1415
1416 }
1417
1418 state.type = _type;
1419 state.channel = _channel;
1420 }
1421 finally {
1422 }
1423 }
1424 // $ANTLR end "T__74"
1425
1426 // $ANTLR start "T__75"
1427 public final void mT__75() throws RecognitionException {
1428 try {
1429 int _type = T__75;
1430 int _channel = DEFAULT_TOKEN_CHANNEL;
1431 // InternalAlloyLanguage.g:75:7: ( 'div' )
1432 // InternalAlloyLanguage.g:75:9: 'div'
1433 {
1434 match("div");
1435
1436
1437 }
1438
1439 state.type = _type;
1440 state.channel = _channel;
1441 }
1442 finally {
1443 }
1444 }
1445 // $ANTLR end "T__75"
1446
1447 // $ANTLR start "RULE_ID"
1448 public final void mRULE_ID() throws RecognitionException {
1449 try {
1450 int _type = RULE_ID;
1451 int _channel = DEFAULT_TOKEN_CHANNEL;
1452 // InternalAlloyLanguage.g:3032:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* )
1453 // InternalAlloyLanguage.g:3032:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )*
1454 {
1455 if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
1456 input.consume();
1457
1458 }
1459 else {
1460 MismatchedSetException mse = new MismatchedSetException(null,input);
1461 recover(mse);
1462 throw mse;}
1463
1464 // InternalAlloyLanguage.g:3032:35: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )*
1465 loop1:
1466 do {
1467 int alt1=2;
1468 int LA1_0 = input.LA(1);
1469
1470 if ( (LA1_0=='\"'||LA1_0=='\''||(LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) {
1471 alt1=1;
1472 }
1473
1474
1475 switch (alt1) {
1476 case 1 :
1477 // InternalAlloyLanguage.g:
1478 {
1479 if ( input.LA(1)=='\"'||input.LA(1)=='\''||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
1480 input.consume();
1481
1482 }
1483 else {
1484 MismatchedSetException mse = new MismatchedSetException(null,input);
1485 recover(mse);
1486 throw mse;}
1487
1488
1489 }
1490 break;
1491
1492 default :
1493 break loop1;
1494 }
1495 } while (true);
1496
1497
1498 }
1499
1500 state.type = _type;
1501 state.channel = _channel;
1502 }
1503 finally {
1504 }
1505 }
1506 // $ANTLR end "RULE_ID"
1507
1508 // $ANTLR start "RULE_INT"
1509 public final void mRULE_INT() throws RecognitionException {
1510 try {
1511 int _type = RULE_INT;
1512 int _channel = DEFAULT_TOKEN_CHANNEL;
1513 // InternalAlloyLanguage.g:3034:10: ( ( '0' .. '9' )+ )
1514 // InternalAlloyLanguage.g:3034:12: ( '0' .. '9' )+
1515 {
1516 // InternalAlloyLanguage.g:3034:12: ( '0' .. '9' )+
1517 int cnt2=0;
1518 loop2:
1519 do {
1520 int alt2=2;
1521 int LA2_0 = input.LA(1);
1522
1523 if ( ((LA2_0>='0' && LA2_0<='9')) ) {
1524 alt2=1;
1525 }
1526
1527
1528 switch (alt2) {
1529 case 1 :
1530 // InternalAlloyLanguage.g:3034:13: '0' .. '9'
1531 {
1532 matchRange('0','9');
1533
1534 }
1535 break;
1536
1537 default :
1538 if ( cnt2 >= 1 ) break loop2;
1539 EarlyExitException eee =
1540 new EarlyExitException(2, input);
1541 throw eee;
1542 }
1543 cnt2++;
1544 } while (true);
1545
1546
1547 }
1548
1549 state.type = _type;
1550 state.channel = _channel;
1551 }
1552 finally {
1553 }
1554 }
1555 // $ANTLR end "RULE_INT"
1556
1557 // $ANTLR start "RULE_STRING"
1558 public final void mRULE_STRING() throws RecognitionException {
1559 try {
1560 int _type = RULE_STRING;
1561 int _channel = DEFAULT_TOKEN_CHANNEL;
1562 // InternalAlloyLanguage.g:3036:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
1563 // InternalAlloyLanguage.g:3036:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
1564 {
1565 // InternalAlloyLanguage.g:3036:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
1566 int alt5=2;
1567 int LA5_0 = input.LA(1);
1568
1569 if ( (LA5_0=='\"') ) {
1570 alt5=1;
1571 }
1572 else if ( (LA5_0=='\'') ) {
1573 alt5=2;
1574 }
1575 else {
1576 NoViableAltException nvae =
1577 new NoViableAltException("", 5, 0, input);
1578
1579 throw nvae;
1580 }
1581 switch (alt5) {
1582 case 1 :
1583 // InternalAlloyLanguage.g:3036:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
1584 {
1585 match('\"');
1586 // InternalAlloyLanguage.g:3036:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
1587 loop3:
1588 do {
1589 int alt3=3;
1590 int LA3_0 = input.LA(1);
1591
1592 if ( (LA3_0=='\\') ) {
1593 alt3=1;
1594 }
1595 else if ( ((LA3_0>='\u0000' && LA3_0<='!')||(LA3_0>='#' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) {
1596 alt3=2;
1597 }
1598
1599
1600 switch (alt3) {
1601 case 1 :
1602 // InternalAlloyLanguage.g:3036:21: '\\\\' .
1603 {
1604 match('\\');
1605 matchAny();
1606
1607 }
1608 break;
1609 case 2 :
1610 // InternalAlloyLanguage.g:3036:28: ~ ( ( '\\\\' | '\"' ) )
1611 {
1612 if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1613 input.consume();
1614
1615 }
1616 else {
1617 MismatchedSetException mse = new MismatchedSetException(null,input);
1618 recover(mse);
1619 throw mse;}
1620
1621
1622 }
1623 break;
1624
1625 default :
1626 break loop3;
1627 }
1628 } while (true);
1629
1630 match('\"');
1631
1632 }
1633 break;
1634 case 2 :
1635 // InternalAlloyLanguage.g:3036:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
1636 {
1637 match('\'');
1638 // InternalAlloyLanguage.g:3036:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
1639 loop4:
1640 do {
1641 int alt4=3;
1642 int LA4_0 = input.LA(1);
1643
1644 if ( (LA4_0=='\\') ) {
1645 alt4=1;
1646 }
1647 else if ( ((LA4_0>='\u0000' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='[')||(LA4_0>=']' && LA4_0<='\uFFFF')) ) {
1648 alt4=2;
1649 }
1650
1651
1652 switch (alt4) {
1653 case 1 :
1654 // InternalAlloyLanguage.g:3036:54: '\\\\' .
1655 {
1656 match('\\');
1657 matchAny();
1658
1659 }
1660 break;
1661 case 2 :
1662 // InternalAlloyLanguage.g:3036:61: ~ ( ( '\\\\' | '\\'' ) )
1663 {
1664 if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1665 input.consume();
1666
1667 }
1668 else {
1669 MismatchedSetException mse = new MismatchedSetException(null,input);
1670 recover(mse);
1671 throw mse;}
1672
1673
1674 }
1675 break;
1676
1677 default :
1678 break loop4;
1679 }
1680 } while (true);
1681
1682 match('\'');
1683
1684 }
1685 break;
1686
1687 }
1688
1689
1690 }
1691
1692 state.type = _type;
1693 state.channel = _channel;
1694 }
1695 finally {
1696 }
1697 }
1698 // $ANTLR end "RULE_STRING"
1699
1700 // $ANTLR start "RULE_ML_COMMENT"
1701 public final void mRULE_ML_COMMENT() throws RecognitionException {
1702 try {
1703 int _type = RULE_ML_COMMENT;
1704 int _channel = DEFAULT_TOKEN_CHANNEL;
1705 // InternalAlloyLanguage.g:3038:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
1706 // InternalAlloyLanguage.g:3038:19: '/*' ( options {greedy=false; } : . )* '*/'
1707 {
1708 match("/*");
1709
1710 // InternalAlloyLanguage.g:3038:24: ( options {greedy=false; } : . )*
1711 loop6:
1712 do {
1713 int alt6=2;
1714 int LA6_0 = input.LA(1);
1715
1716 if ( (LA6_0=='*') ) {
1717 int LA6_1 = input.LA(2);
1718
1719 if ( (LA6_1=='/') ) {
1720 alt6=2;
1721 }
1722 else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) {
1723 alt6=1;
1724 }
1725
1726
1727 }
1728 else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) {
1729 alt6=1;
1730 }
1731
1732
1733 switch (alt6) {
1734 case 1 :
1735 // InternalAlloyLanguage.g:3038:52: .
1736 {
1737 matchAny();
1738
1739 }
1740 break;
1741
1742 default :
1743 break loop6;
1744 }
1745 } while (true);
1746
1747 match("*/");
1748
1749
1750 }
1751
1752 state.type = _type;
1753 state.channel = _channel;
1754 }
1755 finally {
1756 }
1757 }
1758 // $ANTLR end "RULE_ML_COMMENT"
1759
1760 // $ANTLR start "RULE_SL_COMMENT"
1761 public final void mRULE_SL_COMMENT() throws RecognitionException {
1762 try {
1763 int _type = RULE_SL_COMMENT;
1764 int _channel = DEFAULT_TOKEN_CHANNEL;
1765 // InternalAlloyLanguage.g:3040:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
1766 // InternalAlloyLanguage.g:3040:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
1767 {
1768 match("//");
1769
1770 // InternalAlloyLanguage.g:3040:24: (~ ( ( '\\n' | '\\r' ) ) )*
1771 loop7:
1772 do {
1773 int alt7=2;
1774 int LA7_0 = input.LA(1);
1775
1776 if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) {
1777 alt7=1;
1778 }
1779
1780
1781 switch (alt7) {
1782 case 1 :
1783 // InternalAlloyLanguage.g:3040:24: ~ ( ( '\\n' | '\\r' ) )
1784 {
1785 if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
1786 input.consume();
1787
1788 }
1789 else {
1790 MismatchedSetException mse = new MismatchedSetException(null,input);
1791 recover(mse);
1792 throw mse;}
1793
1794
1795 }
1796 break;
1797
1798 default :
1799 break loop7;
1800 }
1801 } while (true);
1802
1803 // InternalAlloyLanguage.g:3040:40: ( ( '\\r' )? '\\n' )?
1804 int alt9=2;
1805 int LA9_0 = input.LA(1);
1806
1807 if ( (LA9_0=='\n'||LA9_0=='\r') ) {
1808 alt9=1;
1809 }
1810 switch (alt9) {
1811 case 1 :
1812 // InternalAlloyLanguage.g:3040:41: ( '\\r' )? '\\n'
1813 {
1814 // InternalAlloyLanguage.g:3040:41: ( '\\r' )?
1815 int alt8=2;
1816 int LA8_0 = input.LA(1);
1817
1818 if ( (LA8_0=='\r') ) {
1819 alt8=1;
1820 }
1821 switch (alt8) {
1822 case 1 :
1823 // InternalAlloyLanguage.g:3040:41: '\\r'
1824 {
1825 match('\r');
1826
1827 }
1828 break;
1829
1830 }
1831
1832 match('\n');
1833
1834 }
1835 break;
1836
1837 }
1838
1839
1840 }
1841
1842 state.type = _type;
1843 state.channel = _channel;
1844 }
1845 finally {
1846 }
1847 }
1848 // $ANTLR end "RULE_SL_COMMENT"
1849
1850 // $ANTLR start "RULE_WS"
1851 public final void mRULE_WS() throws RecognitionException {
1852 try {
1853 int _type = RULE_WS;
1854 int _channel = DEFAULT_TOKEN_CHANNEL;
1855 // InternalAlloyLanguage.g:3042:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
1856 // InternalAlloyLanguage.g:3042:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
1857 {
1858 // InternalAlloyLanguage.g:3042:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
1859 int cnt10=0;
1860 loop10:
1861 do {
1862 int alt10=2;
1863 int LA10_0 = input.LA(1);
1864
1865 if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {
1866 alt10=1;
1867 }
1868
1869
1870 switch (alt10) {
1871 case 1 :
1872 // InternalAlloyLanguage.g:
1873 {
1874 if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
1875 input.consume();
1876
1877 }
1878 else {
1879 MismatchedSetException mse = new MismatchedSetException(null,input);
1880 recover(mse);
1881 throw mse;}
1882
1883
1884 }
1885 break;
1886
1887 default :
1888 if ( cnt10 >= 1 ) break loop10;
1889 EarlyExitException eee =
1890 new EarlyExitException(10, input);
1891 throw eee;
1892 }
1893 cnt10++;
1894 } while (true);
1895
1896
1897 }
1898
1899 state.type = _type;
1900 state.channel = _channel;
1901 }
1902 finally {
1903 }
1904 }
1905 // $ANTLR end "RULE_WS"
1906
1907 // $ANTLR start "RULE_ANY_OTHER"
1908 public final void mRULE_ANY_OTHER() throws RecognitionException {
1909 try {
1910 int _type = RULE_ANY_OTHER;
1911 int _channel = DEFAULT_TOKEN_CHANNEL;
1912 // InternalAlloyLanguage.g:3044:16: ( . )
1913 // InternalAlloyLanguage.g:3044:18: .
1914 {
1915 matchAny();
1916
1917 }
1918
1919 state.type = _type;
1920 state.channel = _channel;
1921 }
1922 finally {
1923 }
1924 }
1925 // $ANTLR end "RULE_ANY_OTHER"
1926
1927 public void mTokens() throws RecognitionException {
1928 // InternalAlloyLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
1929 int alt11=72;
1930 alt11 = dfa11.predict(input);
1931 switch (alt11) {
1932 case 1 :
1933 // InternalAlloyLanguage.g:1:10: T__11
1934 {
1935 mT__11();
1936
1937 }
1938 break;
1939 case 2 :
1940 // InternalAlloyLanguage.g:1:16: T__12
1941 {
1942 mT__12();
1943
1944 }
1945 break;
1946 case 3 :
1947 // InternalAlloyLanguage.g:1:22: T__13
1948 {
1949 mT__13();
1950
1951 }
1952 break;
1953 case 4 :
1954 // InternalAlloyLanguage.g:1:28: T__14
1955 {
1956 mT__14();
1957
1958 }
1959 break;
1960 case 5 :
1961 // InternalAlloyLanguage.g:1:34: T__15
1962 {
1963 mT__15();
1964
1965 }
1966 break;
1967 case 6 :
1968 // InternalAlloyLanguage.g:1:40: T__16
1969 {
1970 mT__16();
1971
1972 }
1973 break;
1974 case 7 :
1975 // InternalAlloyLanguage.g:1:46: T__17
1976 {
1977 mT__17();
1978
1979 }
1980 break;
1981 case 8 :
1982 // InternalAlloyLanguage.g:1:52: T__18
1983 {
1984 mT__18();
1985
1986 }
1987 break;
1988 case 9 :
1989 // InternalAlloyLanguage.g:1:58: T__19
1990 {
1991 mT__19();
1992
1993 }
1994 break;
1995 case 10 :
1996 // InternalAlloyLanguage.g:1:64: T__20
1997 {
1998 mT__20();
1999
2000 }
2001 break;
2002 case 11 :
2003 // InternalAlloyLanguage.g:1:70: T__21
2004 {
2005 mT__21();
2006
2007 }
2008 break;
2009 case 12 :
2010 // InternalAlloyLanguage.g:1:76: T__22
2011 {
2012 mT__22();
2013
2014 }
2015 break;
2016 case 13 :
2017 // InternalAlloyLanguage.g:1:82: T__23
2018 {
2019 mT__23();
2020
2021 }
2022 break;
2023 case 14 :
2024 // InternalAlloyLanguage.g:1:88: T__24
2025 {
2026 mT__24();
2027
2028 }
2029 break;
2030 case 15 :
2031 // InternalAlloyLanguage.g:1:94: T__25
2032 {
2033 mT__25();
2034
2035 }
2036 break;
2037 case 16 :
2038 // InternalAlloyLanguage.g:1:100: T__26
2039 {
2040 mT__26();
2041
2042 }
2043 break;
2044 case 17 :
2045 // InternalAlloyLanguage.g:1:106: T__27
2046 {
2047 mT__27();
2048
2049 }
2050 break;
2051 case 18 :
2052 // InternalAlloyLanguage.g:1:112: T__28
2053 {
2054 mT__28();
2055
2056 }
2057 break;
2058 case 19 :
2059 // InternalAlloyLanguage.g:1:118: T__29
2060 {
2061 mT__29();
2062
2063 }
2064 break;
2065 case 20 :
2066 // InternalAlloyLanguage.g:1:124: T__30
2067 {
2068 mT__30();
2069
2070 }
2071 break;
2072 case 21 :
2073 // InternalAlloyLanguage.g:1:130: T__31
2074 {
2075 mT__31();
2076
2077 }
2078 break;
2079 case 22 :
2080 // InternalAlloyLanguage.g:1:136: T__32
2081 {
2082 mT__32();
2083
2084 }
2085 break;
2086 case 23 :
2087 // InternalAlloyLanguage.g:1:142: T__33
2088 {
2089 mT__33();
2090
2091 }
2092 break;
2093 case 24 :
2094 // InternalAlloyLanguage.g:1:148: T__34
2095 {
2096 mT__34();
2097
2098 }
2099 break;
2100 case 25 :
2101 // InternalAlloyLanguage.g:1:154: T__35
2102 {
2103 mT__35();
2104
2105 }
2106 break;
2107 case 26 :
2108 // InternalAlloyLanguage.g:1:160: T__36
2109 {
2110 mT__36();
2111
2112 }
2113 break;
2114 case 27 :
2115 // InternalAlloyLanguage.g:1:166: T__37
2116 {
2117 mT__37();
2118
2119 }
2120 break;
2121 case 28 :
2122 // InternalAlloyLanguage.g:1:172: T__38
2123 {
2124 mT__38();
2125
2126 }
2127 break;
2128 case 29 :
2129 // InternalAlloyLanguage.g:1:178: T__39
2130 {
2131 mT__39();
2132
2133 }
2134 break;
2135 case 30 :
2136 // InternalAlloyLanguage.g:1:184: T__40
2137 {
2138 mT__40();
2139
2140 }
2141 break;
2142 case 31 :
2143 // InternalAlloyLanguage.g:1:190: T__41
2144 {
2145 mT__41();
2146
2147 }
2148 break;
2149 case 32 :
2150 // InternalAlloyLanguage.g:1:196: T__42
2151 {
2152 mT__42();
2153
2154 }
2155 break;
2156 case 33 :
2157 // InternalAlloyLanguage.g:1:202: T__43
2158 {
2159 mT__43();
2160
2161 }
2162 break;
2163 case 34 :
2164 // InternalAlloyLanguage.g:1:208: T__44
2165 {
2166 mT__44();
2167
2168 }
2169 break;
2170 case 35 :
2171 // InternalAlloyLanguage.g:1:214: T__45
2172 {
2173 mT__45();
2174
2175 }
2176 break;
2177 case 36 :
2178 // InternalAlloyLanguage.g:1:220: T__46
2179 {
2180 mT__46();
2181
2182 }
2183 break;
2184 case 37 :
2185 // InternalAlloyLanguage.g:1:226: T__47
2186 {
2187 mT__47();
2188
2189 }
2190 break;
2191 case 38 :
2192 // InternalAlloyLanguage.g:1:232: T__48
2193 {
2194 mT__48();
2195
2196 }
2197 break;
2198 case 39 :
2199 // InternalAlloyLanguage.g:1:238: T__49
2200 {
2201 mT__49();
2202
2203 }
2204 break;
2205 case 40 :
2206 // InternalAlloyLanguage.g:1:244: T__50
2207 {
2208 mT__50();
2209
2210 }
2211 break;
2212 case 41 :
2213 // InternalAlloyLanguage.g:1:250: T__51
2214 {
2215 mT__51();
2216
2217 }
2218 break;
2219 case 42 :
2220 // InternalAlloyLanguage.g:1:256: T__52
2221 {
2222 mT__52();
2223
2224 }
2225 break;
2226 case 43 :
2227 // InternalAlloyLanguage.g:1:262: T__53
2228 {
2229 mT__53();
2230
2231 }
2232 break;
2233 case 44 :
2234 // InternalAlloyLanguage.g:1:268: T__54
2235 {
2236 mT__54();
2237
2238 }
2239 break;
2240 case 45 :
2241 // InternalAlloyLanguage.g:1:274: T__55
2242 {
2243 mT__55();
2244
2245 }
2246 break;
2247 case 46 :
2248 // InternalAlloyLanguage.g:1:280: T__56
2249 {
2250 mT__56();
2251
2252 }
2253 break;
2254 case 47 :
2255 // InternalAlloyLanguage.g:1:286: T__57
2256 {
2257 mT__57();
2258
2259 }
2260 break;
2261 case 48 :
2262 // InternalAlloyLanguage.g:1:292: T__58
2263 {
2264 mT__58();
2265
2266 }
2267 break;
2268 case 49 :
2269 // InternalAlloyLanguage.g:1:298: T__59
2270 {
2271 mT__59();
2272
2273 }
2274 break;
2275 case 50 :
2276 // InternalAlloyLanguage.g:1:304: T__60
2277 {
2278 mT__60();
2279
2280 }
2281 break;
2282 case 51 :
2283 // InternalAlloyLanguage.g:1:310: T__61
2284 {
2285 mT__61();
2286
2287 }
2288 break;
2289 case 52 :
2290 // InternalAlloyLanguage.g:1:316: T__62
2291 {
2292 mT__62();
2293
2294 }
2295 break;
2296 case 53 :
2297 // InternalAlloyLanguage.g:1:322: T__63
2298 {
2299 mT__63();
2300
2301 }
2302 break;
2303 case 54 :
2304 // InternalAlloyLanguage.g:1:328: T__64
2305 {
2306 mT__64();
2307
2308 }
2309 break;
2310 case 55 :
2311 // InternalAlloyLanguage.g:1:334: T__65
2312 {
2313 mT__65();
2314
2315 }
2316 break;
2317 case 56 :
2318 // InternalAlloyLanguage.g:1:340: T__66
2319 {
2320 mT__66();
2321
2322 }
2323 break;
2324 case 57 :
2325 // InternalAlloyLanguage.g:1:346: T__67
2326 {
2327 mT__67();
2328
2329 }
2330 break;
2331 case 58 :
2332 // InternalAlloyLanguage.g:1:352: T__68
2333 {
2334 mT__68();
2335
2336 }
2337 break;
2338 case 59 :
2339 // InternalAlloyLanguage.g:1:358: T__69
2340 {
2341 mT__69();
2342
2343 }
2344 break;
2345 case 60 :
2346 // InternalAlloyLanguage.g:1:364: T__70
2347 {
2348 mT__70();
2349
2350 }
2351 break;
2352 case 61 :
2353 // InternalAlloyLanguage.g:1:370: T__71
2354 {
2355 mT__71();
2356
2357 }
2358 break;
2359 case 62 :
2360 // InternalAlloyLanguage.g:1:376: T__72
2361 {
2362 mT__72();
2363
2364 }
2365 break;
2366 case 63 :
2367 // InternalAlloyLanguage.g:1:382: T__73
2368 {
2369 mT__73();
2370
2371 }
2372 break;
2373 case 64 :
2374 // InternalAlloyLanguage.g:1:388: T__74
2375 {
2376 mT__74();
2377
2378 }
2379 break;
2380 case 65 :
2381 // InternalAlloyLanguage.g:1:394: T__75
2382 {
2383 mT__75();
2384
2385 }
2386 break;
2387 case 66 :
2388 // InternalAlloyLanguage.g:1:400: RULE_ID
2389 {
2390 mRULE_ID();
2391
2392 }
2393 break;
2394 case 67 :
2395 // InternalAlloyLanguage.g:1:408: RULE_INT
2396 {
2397 mRULE_INT();
2398
2399 }
2400 break;
2401 case 68 :
2402 // InternalAlloyLanguage.g:1:417: RULE_STRING
2403 {
2404 mRULE_STRING();
2405
2406 }
2407 break;
2408 case 69 :
2409 // InternalAlloyLanguage.g:1:429: RULE_ML_COMMENT
2410 {
2411 mRULE_ML_COMMENT();
2412
2413 }
2414 break;
2415 case 70 :
2416 // InternalAlloyLanguage.g:1:445: RULE_SL_COMMENT
2417 {
2418 mRULE_SL_COMMENT();
2419
2420 }
2421 break;
2422 case 71 :
2423 // InternalAlloyLanguage.g:1:461: RULE_WS
2424 {
2425 mRULE_WS();
2426
2427 }
2428 break;
2429 case 72 :
2430 // InternalAlloyLanguage.g:1:469: RULE_ANY_OTHER
2431 {
2432 mRULE_ANY_OTHER();
2433
2434 }
2435 break;
2436
2437 }
2438
2439 }
2440
2441
2442 protected DFA11 dfa11 = new DFA11(this);
2443 static final String DFA11_eotS =
2444 "\1\uffff\1\56\3\uffff\3\56\1\76\1\100\1\56\2\uffff\2\56\1\52\1\56\1\116\1\120\1\122\1\124\1\126\1\uffff\1\131\1\56\4\uffff\2\56\2\uffff\3\56\2\uffff\3\52\2\uffff\3\56\4\uffff\7\56\1\170\3\56\4\uffff\3\56\2\uffff\3\56\1\uffff\1\u0083\1\56\1\u0086\15\uffff\1\u0089\4\uffff\2\56\2\uffff\4\56\5\uffff\5\56\1\u0095\1\u0096\1\u0097\1\u0098\1\u0099\1\56\1\u009b\1\uffff\1\u009c\2\56\1\u009f\1\56\1\u00a1\3\56\1\u00a5\1\uffff\1\u00a6\2\uffff\1\u00a7\1\56\1\uffff\1\56\1\u00aa\1\u00ab\1\u00ac\1\56\1\u00ae\1\u00af\2\56\1\u00b2\1\56\5\uffff\1\u00b4\2\uffff\1\56\1\u00b6\1\uffff\1\u00b7\1\uffff\1\u00b8\1\u00b9\1\u00ba\3\uffff\1\u00bb\1\u00bc\3\uffff\1\u00bd\2\uffff\2\56\1\uffff\1\56\1\uffff\1\56\10\uffff\4\56\1\u00c6\1\u00c7\1\56\1\u00c9\2\uffff\1\u00ca\2\uffff";
2445 static final String DFA11_eofS =
2446 "\u00cb\uffff";
2447 static final String DFA11_minS =
2448 "\1\0\1\154\3\uffff\1\142\1\145\1\144\1\53\1\76\1\141\2\uffff\1\154\1\151\1\174\1\156\1\72\1\76\1\46\2\75\1\uffff\1\76\1\157\4\uffff\2\156\2\uffff\1\145\1\157\1\165\2\uffff\2\0\1\52\2\uffff\1\165\1\141\1\163\4\uffff\1\163\1\144\1\154\1\147\1\142\1\155\1\164\1\42\1\146\1\160\1\145\4\uffff\1\156\1\143\1\162\2\uffff\1\145\1\165\1\163\1\uffff\1\42\1\145\1\76\15\uffff\1\42\4\uffff\1\151\1\164\2\uffff\1\156\1\155\1\156\1\154\5\uffff\1\155\1\145\1\143\1\145\1\164\5\42\1\145\1\42\1\uffff\1\42\1\154\1\156\1\42\1\164\1\42\1\144\1\163\1\152\1\42\1\uffff\1\42\2\uffff\1\42\1\145\1\uffff\1\166\3\42\1\145\2\42\1\156\1\164\1\42\1\162\5\uffff\1\42\2\uffff\1\151\1\42\1\uffff\1\42\1\uffff\3\42\3\uffff\2\42\3\uffff\1\42\2\uffff\1\144\1\154\1\uffff\1\141\1\uffff\1\145\10\uffff\1\163\1\171\1\143\1\163\2\42\1\164\1\42\2\uffff\1\42\2\uffff";
2449 static final String DFA11_maxS =
2450 "\1\uffff\1\170\3\uffff\1\156\1\165\1\156\1\53\1\76\1\165\2\uffff\1\162\1\151\1\174\1\162\1\75\1\76\1\46\2\75\1\uffff\1\76\1\157\4\uffff\2\156\2\uffff\1\165\1\157\1\165\2\uffff\2\uffff\1\57\2\uffff\1\165\1\164\1\163\4\uffff\1\163\1\144\1\154\1\147\2\155\1\164\1\172\1\146\1\160\1\145\4\uffff\1\156\1\143\1\162\2\uffff\1\145\1\165\1\166\1\uffff\1\172\1\145\1\76\15\uffff\1\172\4\uffff\1\151\1\164\2\uffff\1\156\1\155\1\156\1\154\5\uffff\1\155\1\145\1\143\1\145\1\164\5\172\1\145\1\172\1\uffff\1\172\1\154\1\156\1\172\1\164\1\172\1\144\1\163\1\152\1\172\1\uffff\1\172\2\uffff\1\172\1\145\1\uffff\1\166\3\172\1\145\2\172\1\156\1\164\1\172\1\162\5\uffff\1\172\2\uffff\1\151\1\172\1\uffff\1\172\1\uffff\3\172\3\uffff\2\172\3\uffff\1\172\2\uffff\1\144\1\154\1\uffff\1\141\1\uffff\1\145\10\uffff\1\163\1\171\1\143\1\163\2\172\1\164\1\172\2\uffff\1\172\2\uffff";
2451 static final String DFA11_acceptS =
2452 "\2\uffff\1\2\1\3\1\4\6\uffff\1\14\1\15\11\uffff\1\43\2\uffff\1\51\1\52\1\53\1\54\2\uffff\1\62\1\63\3\uffff\1\102\1\103\3\uffff\1\107\1\110\3\uffff\1\102\1\2\1\3\1\4\13\uffff\1\40\1\11\1\41\1\12\3\uffff\1\14\1\15\3\uffff\1\21\3\uffff\1\42\1\36\1\25\1\32\1\30\1\45\1\33\1\47\1\35\1\34\1\43\1\46\1\44\1\uffff\1\51\1\52\1\53\1\54\2\uffff\1\62\1\63\4\uffff\1\103\1\104\1\105\1\106\1\107\14\uffff\1\10\12\uffff\1\22\1\uffff\1\23\1\37\2\uffff\1\70\13\uffff\1\31\1\67\1\6\1\55\1\76\1\uffff\1\74\1\24\2\uffff\1\13\1\uffff\1\65\3\uffff\1\101\1\73\1\50\2\uffff\1\61\1\64\1\100\1\uffff\1\77\1\1\2\uffff\1\27\1\uffff\1\71\1\uffff\1\57\1\17\1\16\1\75\1\20\1\56\1\60\1\72\10\uffff\1\7\1\66\1\uffff\1\26\1\5";
2453 static final String DFA11_specialS =
2454 "\1\0\45\uffff\1\1\1\2\u00a3\uffff}>";
2455 static final String[] DFA11_transitionS = {
2456 "\11\52\2\51\2\52\1\51\22\52\1\51\1\24\1\46\1\34\2\52\1\23\1\47\1\37\1\40\1\33\1\10\1\3\1\27\1\26\1\50\12\45\1\11\1\52\1\21\1\22\1\25\2\52\10\44\1\36\21\44\1\13\1\52\1\14\1\32\1\44\1\52\1\5\2\44\1\16\1\1\1\12\2\44\1\7\2\44\1\42\1\43\1\30\1\20\1\15\1\44\1\41\1\6\1\44\1\35\5\44\1\2\1\17\1\4\1\31\uff81\52",
2457 "\1\55\1\uffff\1\53\11\uffff\1\54",
2458 "",
2459 "",
2460 "",
2461 "\1\62\11\uffff\1\64\1\uffff\1\63",
2462 "\1\70\3\uffff\1\65\5\uffff\1\67\5\uffff\1\66",
2463 "\1\74\1\uffff\1\72\6\uffff\1\73\1\71",
2464 "\1\75",
2465 "\1\77",
2466 "\1\102\15\uffff\1\103\5\uffff\1\101",
2467 "",
2468 "",
2469 "\1\107\5\uffff\1\106",
2470 "\1\110",
2471 "\1\111",
2472 "\1\113\3\uffff\1\112",
2473 "\1\115\2\uffff\1\114",
2474 "\1\117",
2475 "\1\121",
2476 "\1\123",
2477 "\1\125",
2478 "",
2479 "\1\130",
2480 "\1\132",
2481 "",
2482 "",
2483 "",
2484 "",
2485 "\1\137",
2486 "\1\140",
2487 "",
2488 "",
2489 "\1\144\17\uffff\1\143",
2490 "\1\145",
2491 "\1\146",
2492 "",
2493 "",
2494 "\0\150",
2495 "\0\150",
2496 "\1\151\4\uffff\1\152",
2497 "",
2498 "",
2499 "\1\154",
2500 "\1\156\22\uffff\1\155",
2501 "\1\157",
2502 "",
2503 "",
2504 "",
2505 "",
2506 "\1\160",
2507 "\1\161",
2508 "\1\162",
2509 "\1\163",
2510 "\1\165\12\uffff\1\164",
2511 "\1\166",
2512 "\1\167",
2513 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2514 "\1\171",
2515 "\1\172",
2516 "\1\173",
2517 "",
2518 "",
2519 "",
2520 "",
2521 "\1\174",
2522 "\1\175",
2523 "\1\176",
2524 "",
2525 "",
2526 "\1\177",
2527 "\1\u0080",
2528 "\1\u0081\2\uffff\1\u0082",
2529 "",
2530 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2531 "\1\u0084",
2532 "\1\u0085",
2533 "",
2534 "",
2535 "",
2536 "",
2537 "",
2538 "",
2539 "",
2540 "",
2541 "",
2542 "",
2543 "",
2544 "",
2545 "",
2546 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\15\56\1\u0088\5\56\1\u0087\6\56",
2547 "",
2548 "",
2549 "",
2550 "",
2551 "\1\u008a",
2552 "\1\u008b",
2553 "",
2554 "",
2555 "\1\u008c",
2556 "\1\u008d",
2557 "\1\u008e",
2558 "\1\u008f",
2559 "",
2560 "",
2561 "",
2562 "",
2563 "",
2564 "\1\u0090",
2565 "\1\u0091",
2566 "\1\u0092",
2567 "\1\u0093",
2568 "\1\u0094",
2569 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2570 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2571 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2572 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2573 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2574 "\1\u009a",
2575 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2576 "",
2577 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2578 "\1\u009d",
2579 "\1\u009e",
2580 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2581 "\1\u00a0",
2582 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2583 "\1\u00a2",
2584 "\1\u00a3",
2585 "\1\u00a4",
2586 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2587 "",
2588 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2589 "",
2590 "",
2591 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2592 "\1\u00a8",
2593 "",
2594 "\1\u00a9",
2595 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2596 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2597 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2598 "\1\u00ad",
2599 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2600 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2601 "\1\u00b0",
2602 "\1\u00b1",
2603 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2604 "\1\u00b3",
2605 "",
2606 "",
2607 "",
2608 "",
2609 "",
2610 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2611 "",
2612 "",
2613 "\1\u00b5",
2614 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2615 "",
2616 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2617 "",
2618 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2619 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2620 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2621 "",
2622 "",
2623 "",
2624 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2625 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2626 "",
2627 "",
2628 "",
2629 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2630 "",
2631 "",
2632 "\1\u00be",
2633 "\1\u00bf",
2634 "",
2635 "\1\u00c0",
2636 "",
2637 "\1\u00c1",
2638 "",
2639 "",
2640 "",
2641 "",
2642 "",
2643 "",
2644 "",
2645 "",
2646 "\1\u00c2",
2647 "\1\u00c3",
2648 "\1\u00c4",
2649 "\1\u00c5",
2650 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2651 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2652 "\1\u00c8",
2653 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2654 "",
2655 "",
2656 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2657 "",
2658 ""
2659 };
2660
2661 static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS);
2662 static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS);
2663 static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS);
2664 static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS);
2665 static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS);
2666 static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS);
2667 static final short[][] DFA11_transition;
2668
2669 static {
2670 int numStates = DFA11_transitionS.length;
2671 DFA11_transition = new short[numStates][];
2672 for (int i=0; i<numStates; i++) {
2673 DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]);
2674 }
2675 }
2676
2677 class DFA11 extends DFA {
2678
2679 public DFA11(BaseRecognizer recognizer) {
2680 this.recognizer = recognizer;
2681 this.decisionNumber = 11;
2682 this.eot = DFA11_eot;
2683 this.eof = DFA11_eof;
2684 this.min = DFA11_min;
2685 this.max = DFA11_max;
2686 this.accept = DFA11_accept;
2687 this.special = DFA11_special;
2688 this.transition = DFA11_transition;
2689 }
2690 public String getDescription() {
2691 return "1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );";
2692 }
2693 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
2694 IntStream input = _input;
2695 int _s = s;
2696 switch ( s ) {
2697 case 0 :
2698 int LA11_0 = input.LA(1);
2699
2700 s = -1;
2701 if ( (LA11_0=='e') ) {s = 1;}
2702
2703 else if ( (LA11_0=='{') ) {s = 2;}
2704
2705 else if ( (LA11_0==',') ) {s = 3;}
2706
2707 else if ( (LA11_0=='}') ) {s = 4;}
2708
2709 else if ( (LA11_0=='a') ) {s = 5;}
2710
2711 else if ( (LA11_0=='s') ) {s = 6;}
2712
2713 else if ( (LA11_0=='i') ) {s = 7;}
2714
2715 else if ( (LA11_0=='+') ) {s = 8;}
2716
2717 else if ( (LA11_0==':') ) {s = 9;}
2718
2719 else if ( (LA11_0=='f') ) {s = 10;}
2720
2721 else if ( (LA11_0=='[') ) {s = 11;}
2722
2723 else if ( (LA11_0==']') ) {s = 12;}
2724
2725 else if ( (LA11_0=='p') ) {s = 13;}
2726
2727 else if ( (LA11_0=='d') ) {s = 14;}
2728
2729 else if ( (LA11_0=='|') ) {s = 15;}
2730
2731 else if ( (LA11_0=='o') ) {s = 16;}
2732
2733 else if ( (LA11_0=='<') ) {s = 17;}
2734
2735 else if ( (LA11_0=='=') ) {s = 18;}
2736
2737 else if ( (LA11_0=='&') ) {s = 19;}
2738
2739 else if ( (LA11_0=='!') ) {s = 20;}
2740
2741 else if ( (LA11_0=='>') ) {s = 21;}
2742
2743 else if ( (LA11_0=='.') ) {s = 22;}
2744
2745 else if ( (LA11_0=='-') ) {s = 23;}
2746
2747 else if ( (LA11_0=='n') ) {s = 24;}
2748
2749 else if ( (LA11_0=='~') ) {s = 25;}
2750
2751 else if ( (LA11_0=='^') ) {s = 26;}
2752
2753 else if ( (LA11_0=='*') ) {s = 27;}
2754
2755 else if ( (LA11_0=='#') ) {s = 28;}
2756
2757 else if ( (LA11_0=='u') ) {s = 29;}
2758
2759 else if ( (LA11_0=='I') ) {s = 30;}
2760
2761 else if ( (LA11_0=='(') ) {s = 31;}
2762
2763 else if ( (LA11_0==')') ) {s = 32;}
2764
2765 else if ( (LA11_0=='r') ) {s = 33;}
2766
2767 else if ( (LA11_0=='l') ) {s = 34;}
2768
2769 else if ( (LA11_0=='m') ) {s = 35;}
2770
2771 else if ( ((LA11_0>='A' && LA11_0<='H')||(LA11_0>='J' && LA11_0<='Z')||LA11_0=='_'||(LA11_0>='b' && LA11_0<='c')||(LA11_0>='g' && LA11_0<='h')||(LA11_0>='j' && LA11_0<='k')||LA11_0=='q'||LA11_0=='t'||(LA11_0>='v' && LA11_0<='z')) ) {s = 36;}
2772
2773 else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 37;}
2774
2775 else if ( (LA11_0=='\"') ) {s = 38;}
2776
2777 else if ( (LA11_0=='\'') ) {s = 39;}
2778
2779 else if ( (LA11_0=='/') ) {s = 40;}
2780
2781 else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 41;}
2782
2783 else if ( ((LA11_0>='\u0000' && LA11_0<='\b')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\u001F')||(LA11_0>='$' && LA11_0<='%')||LA11_0==';'||(LA11_0>='?' && LA11_0<='@')||LA11_0=='\\'||LA11_0=='`'||(LA11_0>='\u007F' && LA11_0<='\uFFFF')) ) {s = 42;}
2784
2785 if ( s>=0 ) return s;
2786 break;
2787 case 1 :
2788 int LA11_38 = input.LA(1);
2789
2790 s = -1;
2791 if ( ((LA11_38>='\u0000' && LA11_38<='\uFFFF')) ) {s = 104;}
2792
2793 else s = 42;
2794
2795 if ( s>=0 ) return s;
2796 break;
2797 case 2 :
2798 int LA11_39 = input.LA(1);
2799
2800 s = -1;
2801 if ( ((LA11_39>='\u0000' && LA11_39<='\uFFFF')) ) {s = 104;}
2802
2803 else s = 42;
2804
2805 if ( s>=0 ) return s;
2806 break;
2807 }
2808 NoViableAltException nvae =
2809 new NoViableAltException(getDescription(), 11, _s, input);
2810 error(nvae);
2811 throw nvae;
2812 }
2813 }
2814
2815
2816} \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-20 18:49:12 +0000