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