aboutsummaryrefslogtreecommitdiffstats
path: root/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java
diff options
context:
space:
mode:
Diffstat (limited to 'Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java')
-rw-r--r--Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java2816
1 files changed, 2816 insertions, 0 deletions
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java
new file mode 100644
index 00000000..3009516a
--- /dev/null
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java
@@ -0,0 +1,2816 @@
1package hu.bme.mit.inf.dslreasoner.ui.contentassist.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.ui.editor.contentassist.antlr.internal.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: ( '||' )
108 // InternalAlloyLanguage.g:11:9: '||'
109 {
110 match("||");
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: ( 'or' )
129 // InternalAlloyLanguage.g:12:9: 'or'
130 {
131 match("or");
132
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
157 state.type = _type;
158 state.channel = _channel;
159 }
160 finally {
161 }
162 }
163 // $ANTLR end "T__13"
164
165 // $ANTLR start "T__14"
166 public final void mT__14() throws RecognitionException {
167 try {
168 int _type = T__14;
169 int _channel = DEFAULT_TOKEN_CHANNEL;
170 // InternalAlloyLanguage.g:14:7: ( 'iff' )
171 // InternalAlloyLanguage.g:14:9: 'iff'
172 {
173 match("iff");
174
175
176 }
177
178 state.type = _type;
179 state.channel = _channel;
180 }
181 finally {
182 }
183 }
184 // $ANTLR end "T__14"
185
186 // $ANTLR start "T__15"
187 public final void mT__15() throws RecognitionException {
188 try {
189 int _type = T__15;
190 int _channel = DEFAULT_TOKEN_CHANNEL;
191 // InternalAlloyLanguage.g:15:7: ( '=>' )
192 // InternalAlloyLanguage.g:15:9: '=>'
193 {
194 match("=>");
195
196
197 }
198
199 state.type = _type;
200 state.channel = _channel;
201 }
202 finally {
203 }
204 }
205 // $ANTLR end "T__15"
206
207 // $ANTLR start "T__16"
208 public final void mT__16() throws RecognitionException {
209 try {
210 int _type = T__16;
211 int _channel = DEFAULT_TOKEN_CHANNEL;
212 // InternalAlloyLanguage.g:16:7: ( 'implies' )
213 // InternalAlloyLanguage.g:16:9: 'implies'
214 {
215 match("implies");
216
217
218 }
219
220 state.type = _type;
221 state.channel = _channel;
222 }
223 finally {
224 }
225 }
226 // $ANTLR end "T__16"
227
228 // $ANTLR start "T__17"
229 public final void mT__17() throws RecognitionException {
230 try {
231 int _type = T__17;
232 int _channel = DEFAULT_TOKEN_CHANNEL;
233 // InternalAlloyLanguage.g:17:7: ( '&&' )
234 // InternalAlloyLanguage.g:17:9: '&&'
235 {
236 match("&&");
237
238
239 }
240
241 state.type = _type;
242 state.channel = _channel;
243 }
244 finally {
245 }
246 }
247 // $ANTLR end "T__17"
248
249 // $ANTLR start "T__18"
250 public final void mT__18() throws RecognitionException {
251 try {
252 int _type = T__18;
253 int _channel = DEFAULT_TOKEN_CHANNEL;
254 // InternalAlloyLanguage.g:18:7: ( 'and' )
255 // InternalAlloyLanguage.g:18:9: 'and'
256 {
257 match("and");
258
259
260 }
261
262 state.type = _type;
263 state.channel = _channel;
264 }
265 finally {
266 }
267 }
268 // $ANTLR end "T__18"
269
270 // $ANTLR start "T__19"
271 public final void mT__19() throws RecognitionException {
272 try {
273 int _type = T__19;
274 int _channel = DEFAULT_TOKEN_CHANNEL;
275 // InternalAlloyLanguage.g:19:7: ( '!' )
276 // InternalAlloyLanguage.g:19:9: '!'
277 {
278 match('!');
279
280 }
281
282 state.type = _type;
283 state.channel = _channel;
284 }
285 finally {
286 }
287 }
288 // $ANTLR end "T__19"
289
290 // $ANTLR start "T__20"
291 public final void mT__20() throws RecognitionException {
292 try {
293 int _type = T__20;
294 int _channel = DEFAULT_TOKEN_CHANNEL;
295 // InternalAlloyLanguage.g:20:7: ( 'not' )
296 // InternalAlloyLanguage.g:20:9: 'not'
297 {
298 match("not");
299
300
301 }
302
303 state.type = _type;
304 state.channel = _channel;
305 }
306 finally {
307 }
308 }
309 // $ANTLR end "T__20"
310
311 // $ANTLR start "T__21"
312 public final void mT__21() throws RecognitionException {
313 try {
314 int _type = T__21;
315 int _channel = DEFAULT_TOKEN_CHANNEL;
316 // InternalAlloyLanguage.g:21:7: ( 'all' )
317 // InternalAlloyLanguage.g:21:9: 'all'
318 {
319 match("all");
320
321
322 }
323
324 state.type = _type;
325 state.channel = _channel;
326 }
327 finally {
328 }
329 }
330 // $ANTLR end "T__21"
331
332 // $ANTLR start "T__22"
333 public final void mT__22() throws RecognitionException {
334 try {
335 int _type = T__22;
336 int _channel = DEFAULT_TOKEN_CHANNEL;
337 // InternalAlloyLanguage.g:22:7: ( 'no' )
338 // InternalAlloyLanguage.g:22:9: 'no'
339 {
340 match("no");
341
342
343 }
344
345 state.type = _type;
346 state.channel = _channel;
347 }
348 finally {
349 }
350 }
351 // $ANTLR end "T__22"
352
353 // $ANTLR start "T__23"
354 public final void mT__23() throws RecognitionException {
355 try {
356 int _type = T__23;
357 int _channel = DEFAULT_TOKEN_CHANNEL;
358 // InternalAlloyLanguage.g:23:7: ( 'some' )
359 // InternalAlloyLanguage.g:23:9: 'some'
360 {
361 match("some");
362
363
364 }
365
366 state.type = _type;
367 state.channel = _channel;
368 }
369 finally {
370 }
371 }
372 // $ANTLR end "T__23"
373
374 // $ANTLR start "T__24"
375 public final void mT__24() throws RecognitionException {
376 try {
377 int _type = T__24;
378 int _channel = DEFAULT_TOKEN_CHANNEL;
379 // InternalAlloyLanguage.g:24:7: ( 'lone' )
380 // InternalAlloyLanguage.g:24:9: 'lone'
381 {
382 match("lone");
383
384
385 }
386
387 state.type = _type;
388 state.channel = _channel;
389 }
390 finally {
391 }
392 }
393 // $ANTLR end "T__24"
394
395 // $ANTLR start "T__25"
396 public final void mT__25() throws RecognitionException {
397 try {
398 int _type = T__25;
399 int _channel = DEFAULT_TOKEN_CHANNEL;
400 // InternalAlloyLanguage.g:25:7: ( 'one' )
401 // InternalAlloyLanguage.g:25:9: 'one'
402 {
403 match("one");
404
405
406 }
407
408 state.type = _type;
409 state.channel = _channel;
410 }
411 finally {
412 }
413 }
414 // $ANTLR end "T__25"
415
416 // $ANTLR start "T__26"
417 public final void mT__26() throws RecognitionException {
418 try {
419 int _type = T__26;
420 int _channel = DEFAULT_TOKEN_CHANNEL;
421 // InternalAlloyLanguage.g:26:7: ( 'set' )
422 // InternalAlloyLanguage.g:26:9: 'set'
423 {
424 match("set");
425
426
427 }
428
429 state.type = _type;
430 state.channel = _channel;
431 }
432 finally {
433 }
434 }
435 // $ANTLR end "T__26"
436
437 // $ANTLR start "T__27"
438 public final void mT__27() throws RecognitionException {
439 try {
440 int _type = T__27;
441 int _channel = DEFAULT_TOKEN_CHANNEL;
442 // InternalAlloyLanguage.g:27:7: ( 'plus' )
443 // InternalAlloyLanguage.g:27:9: 'plus'
444 {
445 match("plus");
446
447
448 }
449
450 state.type = _type;
451 state.channel = _channel;
452 }
453 finally {
454 }
455 }
456 // $ANTLR end "T__27"
457
458 // $ANTLR start "T__28"
459 public final void mT__28() throws RecognitionException {
460 try {
461 int _type = T__28;
462 int _channel = DEFAULT_TOKEN_CHANNEL;
463 // InternalAlloyLanguage.g:28:7: ( 'sub' )
464 // InternalAlloyLanguage.g:28:9: 'sub'
465 {
466 match("sub");
467
468
469 }
470
471 state.type = _type;
472 state.channel = _channel;
473 }
474 finally {
475 }
476 }
477 // $ANTLR end "T__28"
478
479 // $ANTLR start "T__29"
480 public final void mT__29() throws RecognitionException {
481 try {
482 int _type = T__29;
483 int _channel = DEFAULT_TOKEN_CHANNEL;
484 // InternalAlloyLanguage.g:29:7: ( 'mul' )
485 // InternalAlloyLanguage.g:29:9: 'mul'
486 {
487 match("mul");
488
489
490 }
491
492 state.type = _type;
493 state.channel = _channel;
494 }
495 finally {
496 }
497 }
498 // $ANTLR end "T__29"
499
500 // $ANTLR start "T__30"
501 public final void mT__30() throws RecognitionException {
502 try {
503 int _type = T__30;
504 int _channel = DEFAULT_TOKEN_CHANNEL;
505 // InternalAlloyLanguage.g:30:7: ( 'rem' )
506 // InternalAlloyLanguage.g:30:9: 'rem'
507 {
508 match("rem");
509
510
511 }
512
513 state.type = _type;
514 state.channel = _channel;
515 }
516 finally {
517 }
518 }
519 // $ANTLR end "T__30"
520
521 // $ANTLR start "T__31"
522 public final void mT__31() throws RecognitionException {
523 try {
524 int _type = T__31;
525 int _channel = DEFAULT_TOKEN_CHANNEL;
526 // InternalAlloyLanguage.g:31:7: ( 'div' )
527 // InternalAlloyLanguage.g:31:9: 'div'
528 {
529 match("div");
530
531
532 }
533
534 state.type = _type;
535 state.channel = _channel;
536 }
537 finally {
538 }
539 }
540 // $ANTLR end "T__31"
541
542 // $ANTLR start "T__32"
543 public final void mT__32() throws RecognitionException {
544 try {
545 int _type = T__32;
546 int _channel = DEFAULT_TOKEN_CHANNEL;
547 // InternalAlloyLanguage.g:32:7: ( 'enum' )
548 // InternalAlloyLanguage.g:32:9: 'enum'
549 {
550 match("enum");
551
552
553 }
554
555 state.type = _type;
556 state.channel = _channel;
557 }
558 finally {
559 }
560 }
561 // $ANTLR end "T__32"
562
563 // $ANTLR start "T__33"
564 public final void mT__33() throws RecognitionException {
565 try {
566 int _type = T__33;
567 int _channel = DEFAULT_TOKEN_CHANNEL;
568 // InternalAlloyLanguage.g:33:7: ( '{' )
569 // InternalAlloyLanguage.g:33:9: '{'
570 {
571 match('{');
572
573 }
574
575 state.type = _type;
576 state.channel = _channel;
577 }
578 finally {
579 }
580 }
581 // $ANTLR end "T__33"
582
583 // $ANTLR start "T__34"
584 public final void mT__34() throws RecognitionException {
585 try {
586 int _type = T__34;
587 int _channel = DEFAULT_TOKEN_CHANNEL;
588 // InternalAlloyLanguage.g:34:7: ( '}' )
589 // InternalAlloyLanguage.g:34:9: '}'
590 {
591 match('}');
592
593 }
594
595 state.type = _type;
596 state.channel = _channel;
597 }
598 finally {
599 }
600 }
601 // $ANTLR end "T__34"
602
603 // $ANTLR start "T__35"
604 public final void mT__35() throws RecognitionException {
605 try {
606 int _type = T__35;
607 int _channel = DEFAULT_TOKEN_CHANNEL;
608 // InternalAlloyLanguage.g:35:7: ( ',' )
609 // InternalAlloyLanguage.g:35:9: ','
610 {
611 match(',');
612
613 }
614
615 state.type = _type;
616 state.channel = _channel;
617 }
618 finally {
619 }
620 }
621 // $ANTLR end "T__35"
622
623 // $ANTLR start "T__36"
624 public final void mT__36() throws RecognitionException {
625 try {
626 int _type = T__36;
627 int _channel = DEFAULT_TOKEN_CHANNEL;
628 // InternalAlloyLanguage.g:36:7: ( 'sig' )
629 // InternalAlloyLanguage.g:36:9: 'sig'
630 {
631 match("sig");
632
633
634 }
635
636 state.type = _type;
637 state.channel = _channel;
638 }
639 finally {
640 }
641 }
642 // $ANTLR end "T__36"
643
644 // $ANTLR start "T__37"
645 public final void mT__37() throws RecognitionException {
646 try {
647 int _type = T__37;
648 int _channel = DEFAULT_TOKEN_CHANNEL;
649 // InternalAlloyLanguage.g:37:7: ( 'extends' )
650 // InternalAlloyLanguage.g:37:9: 'extends'
651 {
652 match("extends");
653
654
655 }
656
657 state.type = _type;
658 state.channel = _channel;
659 }
660 finally {
661 }
662 }
663 // $ANTLR end "T__37"
664
665 // $ANTLR start "T__38"
666 public final void mT__38() throws RecognitionException {
667 try {
668 int _type = T__38;
669 int _channel = DEFAULT_TOKEN_CHANNEL;
670 // InternalAlloyLanguage.g:38:7: ( 'in' )
671 // InternalAlloyLanguage.g:38:9: 'in'
672 {
673 match("in");
674
675
676 }
677
678 state.type = _type;
679 state.channel = _channel;
680 }
681 finally {
682 }
683 }
684 // $ANTLR end "T__38"
685
686 // $ANTLR start "T__39"
687 public final void mT__39() throws RecognitionException {
688 try {
689 int _type = T__39;
690 int _channel = DEFAULT_TOKEN_CHANNEL;
691 // InternalAlloyLanguage.g:39:7: ( '+' )
692 // InternalAlloyLanguage.g:39:9: '+'
693 {
694 match('+');
695
696 }
697
698 state.type = _type;
699 state.channel = _channel;
700 }
701 finally {
702 }
703 }
704 // $ANTLR end "T__39"
705
706 // $ANTLR start "T__40"
707 public final void mT__40() throws RecognitionException {
708 try {
709 int _type = T__40;
710 int _channel = DEFAULT_TOKEN_CHANNEL;
711 // InternalAlloyLanguage.g:40:7: ( ':' )
712 // InternalAlloyLanguage.g:40:9: ':'
713 {
714 match(':');
715
716 }
717
718 state.type = _type;
719 state.channel = _channel;
720 }
721 finally {
722 }
723 }
724 // $ANTLR end "T__40"
725
726 // $ANTLR start "T__41"
727 public final void mT__41() throws RecognitionException {
728 try {
729 int _type = T__41;
730 int _channel = DEFAULT_TOKEN_CHANNEL;
731 // InternalAlloyLanguage.g:41:7: ( 'fun' )
732 // InternalAlloyLanguage.g:41:9: 'fun'
733 {
734 match("fun");
735
736
737 }
738
739 state.type = _type;
740 state.channel = _channel;
741 }
742 finally {
743 }
744 }
745 // $ANTLR end "T__41"
746
747 // $ANTLR start "T__42"
748 public final void mT__42() throws RecognitionException {
749 try {
750 int _type = T__42;
751 int _channel = DEFAULT_TOKEN_CHANNEL;
752 // InternalAlloyLanguage.g:42:7: ( '[' )
753 // InternalAlloyLanguage.g:42:9: '['
754 {
755 match('[');
756
757 }
758
759 state.type = _type;
760 state.channel = _channel;
761 }
762 finally {
763 }
764 }
765 // $ANTLR end "T__42"
766
767 // $ANTLR start "T__43"
768 public final void mT__43() throws RecognitionException {
769 try {
770 int _type = T__43;
771 int _channel = DEFAULT_TOKEN_CHANNEL;
772 // InternalAlloyLanguage.g:43:7: ( ']' )
773 // InternalAlloyLanguage.g:43:9: ']'
774 {
775 match(']');
776
777 }
778
779 state.type = _type;
780 state.channel = _channel;
781 }
782 finally {
783 }
784 }
785 // $ANTLR end "T__43"
786
787 // $ANTLR start "T__44"
788 public final void mT__44() throws RecognitionException {
789 try {
790 int _type = T__44;
791 int _channel = DEFAULT_TOKEN_CHANNEL;
792 // InternalAlloyLanguage.g:44:7: ( 'pred' )
793 // InternalAlloyLanguage.g:44:9: 'pred'
794 {
795 match("pred");
796
797
798 }
799
800 state.type = _type;
801 state.channel = _channel;
802 }
803 finally {
804 }
805 }
806 // $ANTLR end "T__44"
807
808 // $ANTLR start "T__45"
809 public final void mT__45() throws RecognitionException {
810 try {
811 int _type = T__45;
812 int _channel = DEFAULT_TOKEN_CHANNEL;
813 // InternalAlloyLanguage.g:45:7: ( 'fact' )
814 // InternalAlloyLanguage.g:45:9: 'fact'
815 {
816 match("fact");
817
818
819 }
820
821 state.type = _type;
822 state.channel = _channel;
823 }
824 finally {
825 }
826 }
827 // $ANTLR end "T__45"
828
829 // $ANTLR start "T__46"
830 public final void mT__46() throws RecognitionException {
831 try {
832 int _type = T__46;
833 int _channel = DEFAULT_TOKEN_CHANNEL;
834 // InternalAlloyLanguage.g:46:7: ( 'else' )
835 // InternalAlloyLanguage.g:46:9: 'else'
836 {
837 match("else");
838
839
840 }
841
842 state.type = _type;
843 state.channel = _channel;
844 }
845 finally {
846 }
847 }
848 // $ANTLR end "T__46"
849
850 // $ANTLR start "T__47"
851 public final void mT__47() throws RecognitionException {
852 try {
853 int _type = T__47;
854 int _channel = DEFAULT_TOKEN_CHANNEL;
855 // InternalAlloyLanguage.g:47:7: ( '=' )
856 // InternalAlloyLanguage.g:47:9: '='
857 {
858 match('=');
859
860 }
861
862 state.type = _type;
863 state.channel = _channel;
864 }
865 finally {
866 }
867 }
868 // $ANTLR end "T__47"
869
870 // $ANTLR start "T__48"
871 public final void mT__48() throws RecognitionException {
872 try {
873 int _type = T__48;
874 int _channel = DEFAULT_TOKEN_CHANNEL;
875 // InternalAlloyLanguage.g:48:7: ( '!=' )
876 // InternalAlloyLanguage.g:48:9: '!='
877 {
878 match("!=");
879
880
881 }
882
883 state.type = _type;
884 state.channel = _channel;
885 }
886 finally {
887 }
888 }
889 // $ANTLR end "T__48"
890
891 // $ANTLR start "T__49"
892 public final void mT__49() throws RecognitionException {
893 try {
894 int _type = T__49;
895 int _channel = DEFAULT_TOKEN_CHANNEL;
896 // InternalAlloyLanguage.g:49:7: ( '>' )
897 // InternalAlloyLanguage.g:49:9: '>'
898 {
899 match('>');
900
901 }
902
903 state.type = _type;
904 state.channel = _channel;
905 }
906 finally {
907 }
908 }
909 // $ANTLR end "T__49"
910
911 // $ANTLR start "T__50"
912 public final void mT__50() throws RecognitionException {
913 try {
914 int _type = T__50;
915 int _channel = DEFAULT_TOKEN_CHANNEL;
916 // InternalAlloyLanguage.g:50:7: ( '>=' )
917 // InternalAlloyLanguage.g:50:9: '>='
918 {
919 match(">=");
920
921
922 }
923
924 state.type = _type;
925 state.channel = _channel;
926 }
927 finally {
928 }
929 }
930 // $ANTLR end "T__50"
931
932 // $ANTLR start "T__51"
933 public final void mT__51() throws RecognitionException {
934 try {
935 int _type = T__51;
936 int _channel = DEFAULT_TOKEN_CHANNEL;
937 // InternalAlloyLanguage.g:51:7: ( '<' )
938 // InternalAlloyLanguage.g:51:9: '<'
939 {
940 match('<');
941
942 }
943
944 state.type = _type;
945 state.channel = _channel;
946 }
947 finally {
948 }
949 }
950 // $ANTLR end "T__51"
951
952 // $ANTLR start "T__52"
953 public final void mT__52() throws RecognitionException {
954 try {
955 int _type = T__52;
956 int _channel = DEFAULT_TOKEN_CHANNEL;
957 // InternalAlloyLanguage.g:52:7: ( '<=' )
958 // InternalAlloyLanguage.g:52:9: '<='
959 {
960 match("<=");
961
962
963 }
964
965 state.type = _type;
966 state.channel = _channel;
967 }
968 finally {
969 }
970 }
971 // $ANTLR end "T__52"
972
973 // $ANTLR start "T__53"
974 public final void mT__53() throws RecognitionException {
975 try {
976 int _type = T__53;
977 int _channel = DEFAULT_TOKEN_CHANNEL;
978 // InternalAlloyLanguage.g:53:7: ( '++' )
979 // InternalAlloyLanguage.g:53:9: '++'
980 {
981 match("++");
982
983
984 }
985
986 state.type = _type;
987 state.channel = _channel;
988 }
989 finally {
990 }
991 }
992 // $ANTLR end "T__53"
993
994 // $ANTLR start "T__54"
995 public final void mT__54() throws RecognitionException {
996 try {
997 int _type = T__54;
998 int _channel = DEFAULT_TOKEN_CHANNEL;
999 // InternalAlloyLanguage.g:54:7: ( ':>' )
1000 // InternalAlloyLanguage.g:54:9: ':>'
1001 {
1002 match(":>");
1003
1004
1005 }
1006
1007 state.type = _type;
1008 state.channel = _channel;
1009 }
1010 finally {
1011 }
1012 }
1013 // $ANTLR end "T__54"
1014
1015 // $ANTLR start "T__55"
1016 public final void mT__55() throws RecognitionException {
1017 try {
1018 int _type = T__55;
1019 int _channel = DEFAULT_TOKEN_CHANNEL;
1020 // InternalAlloyLanguage.g:55:7: ( '<:' )
1021 // InternalAlloyLanguage.g:55:9: '<:'
1022 {
1023 match("<:");
1024
1025
1026 }
1027
1028 state.type = _type;
1029 state.channel = _channel;
1030 }
1031 finally {
1032 }
1033 }
1034 // $ANTLR end "T__55"
1035
1036 // $ANTLR start "T__56"
1037 public final void mT__56() throws RecognitionException {
1038 try {
1039 int _type = T__56;
1040 int _channel = DEFAULT_TOKEN_CHANNEL;
1041 // InternalAlloyLanguage.g:56:7: ( '.' )
1042 // InternalAlloyLanguage.g:56:9: '.'
1043 {
1044 match('.');
1045
1046 }
1047
1048 state.type = _type;
1049 state.channel = _channel;
1050 }
1051 finally {
1052 }
1053 }
1054 // $ANTLR end "T__56"
1055
1056 // $ANTLR start "T__57"
1057 public final void mT__57() throws RecognitionException {
1058 try {
1059 int _type = T__57;
1060 int _channel = DEFAULT_TOKEN_CHANNEL;
1061 // InternalAlloyLanguage.g:57:7: ( '-' )
1062 // InternalAlloyLanguage.g:57:9: '-'
1063 {
1064 match('-');
1065
1066 }
1067
1068 state.type = _type;
1069 state.channel = _channel;
1070 }
1071 finally {
1072 }
1073 }
1074 // $ANTLR end "T__57"
1075
1076 // $ANTLR start "T__58"
1077 public final void mT__58() throws RecognitionException {
1078 try {
1079 int _type = T__58;
1080 int _channel = DEFAULT_TOKEN_CHANNEL;
1081 // InternalAlloyLanguage.g:58:7: ( '&' )
1082 // InternalAlloyLanguage.g:58:9: '&'
1083 {
1084 match('&');
1085
1086 }
1087
1088 state.type = _type;
1089 state.channel = _channel;
1090 }
1091 finally {
1092 }
1093 }
1094 // $ANTLR end "T__58"
1095
1096 // $ANTLR start "T__59"
1097 public final void mT__59() throws RecognitionException {
1098 try {
1099 int _type = T__59;
1100 int _channel = DEFAULT_TOKEN_CHANNEL;
1101 // InternalAlloyLanguage.g:59:7: ( '->' )
1102 // InternalAlloyLanguage.g:59:9: '->'
1103 {
1104 match("->");
1105
1106
1107 }
1108
1109 state.type = _type;
1110 state.channel = _channel;
1111 }
1112 finally {
1113 }
1114 }
1115 // $ANTLR end "T__59"
1116
1117 // $ANTLR start "T__60"
1118 public final void mT__60() throws RecognitionException {
1119 try {
1120 int _type = T__60;
1121 int _channel = DEFAULT_TOKEN_CHANNEL;
1122 // InternalAlloyLanguage.g:60:7: ( '~' )
1123 // InternalAlloyLanguage.g:60:9: '~'
1124 {
1125 match('~');
1126
1127 }
1128
1129 state.type = _type;
1130 state.channel = _channel;
1131 }
1132 finally {
1133 }
1134 }
1135 // $ANTLR end "T__60"
1136
1137 // $ANTLR start "T__61"
1138 public final void mT__61() throws RecognitionException {
1139 try {
1140 int _type = T__61;
1141 int _channel = DEFAULT_TOKEN_CHANNEL;
1142 // InternalAlloyLanguage.g:61:7: ( '^' )
1143 // InternalAlloyLanguage.g:61:9: '^'
1144 {
1145 match('^');
1146
1147 }
1148
1149 state.type = _type;
1150 state.channel = _channel;
1151 }
1152 finally {
1153 }
1154 }
1155 // $ANTLR end "T__61"
1156
1157 // $ANTLR start "T__62"
1158 public final void mT__62() throws RecognitionException {
1159 try {
1160 int _type = T__62;
1161 int _channel = DEFAULT_TOKEN_CHANNEL;
1162 // InternalAlloyLanguage.g:62:7: ( '*' )
1163 // InternalAlloyLanguage.g:62:9: '*'
1164 {
1165 match('*');
1166
1167 }
1168
1169 state.type = _type;
1170 state.channel = _channel;
1171 }
1172 finally {
1173 }
1174 }
1175 // $ANTLR end "T__62"
1176
1177 // $ANTLR start "T__63"
1178 public final void mT__63() throws RecognitionException {
1179 try {
1180 int _type = T__63;
1181 int _channel = DEFAULT_TOKEN_CHANNEL;
1182 // InternalAlloyLanguage.g:63:7: ( '#' )
1183 // InternalAlloyLanguage.g:63:9: '#'
1184 {
1185 match('#');
1186
1187 }
1188
1189 state.type = _type;
1190 state.channel = _channel;
1191 }
1192 finally {
1193 }
1194 }
1195 // $ANTLR end "T__63"
1196
1197 // $ANTLR start "T__64"
1198 public final void mT__64() throws RecognitionException {
1199 try {
1200 int _type = T__64;
1201 int _channel = DEFAULT_TOKEN_CHANNEL;
1202 // InternalAlloyLanguage.g:64:7: ( 'sum' )
1203 // InternalAlloyLanguage.g:64:9: 'sum'
1204 {
1205 match("sum");
1206
1207
1208 }
1209
1210 state.type = _type;
1211 state.channel = _channel;
1212 }
1213 finally {
1214 }
1215 }
1216 // $ANTLR end "T__64"
1217
1218 // $ANTLR start "T__65"
1219 public final void mT__65() throws RecognitionException {
1220 try {
1221 int _type = T__65;
1222 int _channel = DEFAULT_TOKEN_CHANNEL;
1223 // InternalAlloyLanguage.g:65:7: ( 'none' )
1224 // InternalAlloyLanguage.g:65:9: 'none'
1225 {
1226 match("none");
1227
1228
1229 }
1230
1231 state.type = _type;
1232 state.channel = _channel;
1233 }
1234 finally {
1235 }
1236 }
1237 // $ANTLR end "T__65"
1238
1239 // $ANTLR start "T__66"
1240 public final void mT__66() throws RecognitionException {
1241 try {
1242 int _type = T__66;
1243 int _channel = DEFAULT_TOKEN_CHANNEL;
1244 // InternalAlloyLanguage.g:66:7: ( 'iden' )
1245 // InternalAlloyLanguage.g:66:9: 'iden'
1246 {
1247 match("iden");
1248
1249
1250 }
1251
1252 state.type = _type;
1253 state.channel = _channel;
1254 }
1255 finally {
1256 }
1257 }
1258 // $ANTLR end "T__66"
1259
1260 // $ANTLR start "T__67"
1261 public final void mT__67() throws RecognitionException {
1262 try {
1263 int _type = T__67;
1264 int _channel = DEFAULT_TOKEN_CHANNEL;
1265 // InternalAlloyLanguage.g:67:7: ( 'univ' )
1266 // InternalAlloyLanguage.g:67:9: 'univ'
1267 {
1268 match("univ");
1269
1270
1271 }
1272
1273 state.type = _type;
1274 state.channel = _channel;
1275 }
1276 finally {
1277 }
1278 }
1279 // $ANTLR end "T__67"
1280
1281 // $ANTLR start "T__68"
1282 public final void mT__68() throws RecognitionException {
1283 try {
1284 int _type = T__68;
1285 int _channel = DEFAULT_TOKEN_CHANNEL;
1286 // InternalAlloyLanguage.g:68:7: ( 'Int' )
1287 // InternalAlloyLanguage.g:68:9: 'Int'
1288 {
1289 match("Int");
1290
1291
1292 }
1293
1294 state.type = _type;
1295 state.channel = _channel;
1296 }
1297 finally {
1298 }
1299 }
1300 // $ANTLR end "T__68"
1301
1302 // $ANTLR start "T__69"
1303 public final void mT__69() throws RecognitionException {
1304 try {
1305 int _type = T__69;
1306 int _channel = DEFAULT_TOKEN_CHANNEL;
1307 // InternalAlloyLanguage.g:69:7: ( '(' )
1308 // InternalAlloyLanguage.g:69:9: '('
1309 {
1310 match('(');
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: ( ')' )
1328 // InternalAlloyLanguage.g:70:9: ')'
1329 {
1330 match(')');
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: ( 'run' )
1348 // InternalAlloyLanguage.g:71:9: 'run'
1349 {
1350 match("run");
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: ( 'for' )
1369 // InternalAlloyLanguage.g:72:9: 'for'
1370 {
1371 match("for");
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: ( 'abstract' )
1390 // InternalAlloyLanguage.g:73:9: 'abstract'
1391 {
1392 match("abstract");
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: ( 'disj' )
1411 // InternalAlloyLanguage.g:74:9: 'disj'
1412 {
1413 match("disj");
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: ( 'exactly' )
1432 // InternalAlloyLanguage.g:75:9: 'exactly'
1433 {
1434 match("exactly");
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:10078:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* )
1453 // InternalAlloyLanguage.g:10078: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:10078: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:10080:10: ( ( '0' .. '9' )+ )
1514 // InternalAlloyLanguage.g:10080:12: ( '0' .. '9' )+
1515 {
1516 // InternalAlloyLanguage.g:10080: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:10080: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:10082:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
1563 // InternalAlloyLanguage.g:10082:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
1564 {
1565 // InternalAlloyLanguage.g:10082: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:10082:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
1584 {
1585 match('\"');
1586 // InternalAlloyLanguage.g:10082: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:10082:21: '\\\\' .
1603 {
1604 match('\\');
1605 matchAny();
1606
1607 }
1608 break;
1609 case 2 :
1610 // InternalAlloyLanguage.g:10082: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:10082:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
1636 {
1637 match('\'');
1638 // InternalAlloyLanguage.g:10082: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:10082:54: '\\\\' .
1655 {
1656 match('\\');
1657 matchAny();
1658
1659 }
1660 break;
1661 case 2 :
1662 // InternalAlloyLanguage.g:10082: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:10084:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
1706 // InternalAlloyLanguage.g:10084:19: '/*' ( options {greedy=false; } : . )* '*/'
1707 {
1708 match("/*");
1709
1710 // InternalAlloyLanguage.g:10084: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:10084: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:10086:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
1766 // InternalAlloyLanguage.g:10086:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
1767 {
1768 match("//");
1769
1770 // InternalAlloyLanguage.g:10086: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:10086: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:10086: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:10086:41: ( '\\r' )? '\\n'
1813 {
1814 // InternalAlloyLanguage.g:10086: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:10086: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:10088:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
1856 // InternalAlloyLanguage.g:10088:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
1857 {
1858 // InternalAlloyLanguage.g:10088: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:10090:16: ( . )
1913 // InternalAlloyLanguage.g:10090: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\52\1\56\1\61\1\56\1\67\1\71\1\56\1\76\10\56\3\uffff\1\122\1\124\1\56\2\uffff\1\133\1\uffff\1\136\4\uffff\2\56\4\uffff\3\52\3\uffff\1\154\1\56\1\uffff\1\157\2\uffff\2\56\1\162\1\56\4\uffff\3\56\2\uffff\1\171\16\56\7\uffff\3\56\13\uffff\2\56\10\uffff\1\u0090\2\uffff\1\u0091\1\56\1\uffff\1\56\1\u0094\1\u0095\1\56\1\u0097\1\56\1\uffff\1\56\1\u009a\1\u009b\1\u009c\1\u009d\3\56\1\u00a1\1\u00a2\1\u00a3\1\u00a4\5\56\1\u00aa\1\56\1\u00ac\1\56\1\u00ae\2\uffff\1\56\1\u00b0\2\uffff\1\56\1\uffff\1\u00b2\1\u00b3\4\uffff\1\u00b4\1\u00b5\1\u00b6\4\uffff\1\u00b7\1\u00b8\2\56\1\u00bb\1\uffff\1\u00bc\1\uffff\1\u00bd\1\uffff\1\56\1\uffff\1\56\7\uffff\2\56\3\uffff\4\56\1\u00c6\1\56\1\u00c8\1\u00c9\1\uffff\1\u00ca\3\uffff";
2445 static final String DFA11_eofS =
2446 "\u00cb\uffff";
2447 static final String DFA11_minS =
2448 "\1\0\1\174\1\156\1\72\1\144\1\76\1\46\1\142\1\75\1\157\1\145\1\157\1\154\1\165\1\145\1\151\1\154\3\uffff\1\53\1\76\1\141\2\uffff\1\75\1\uffff\1\76\4\uffff\2\156\4\uffff\2\0\1\52\3\uffff\1\42\1\145\1\uffff\1\76\2\uffff\1\146\1\160\1\42\1\145\4\uffff\1\144\1\154\1\163\2\uffff\1\42\1\155\1\164\1\142\1\147\1\156\1\165\1\145\1\154\1\155\1\156\1\163\1\165\1\141\1\163\7\uffff\1\156\1\143\1\162\13\uffff\1\151\1\164\10\uffff\1\42\2\uffff\1\42\1\154\1\uffff\1\156\2\42\1\164\1\42\1\145\1\uffff\1\145\4\42\1\145\1\163\1\144\4\42\1\152\1\155\1\145\1\143\1\145\1\42\1\164\1\42\1\166\1\42\2\uffff\1\151\1\42\2\uffff\1\162\1\uffff\2\42\4\uffff\3\42\4\uffff\2\42\1\156\1\164\1\42\1\uffff\1\42\1\uffff\1\42\1\uffff\1\145\1\uffff\1\141\7\uffff\1\144\1\154\3\uffff\1\163\1\143\1\163\1\171\1\42\1\164\2\42\1\uffff\1\42\3\uffff";
2449 static final String DFA11_maxS =
2450 "\1\uffff\1\174\1\162\1\75\1\156\1\76\1\46\1\156\1\75\1\157\1\165\1\157\1\162\2\165\1\151\1\170\3\uffff\1\53\1\76\1\165\2\uffff\1\75\1\uffff\1\76\4\uffff\2\156\4\uffff\2\uffff\1\57\3\uffff\1\172\1\145\1\uffff\1\76\2\uffff\1\146\1\160\1\172\1\145\4\uffff\1\144\1\154\1\163\2\uffff\1\172\1\155\1\164\1\155\1\147\1\156\1\165\1\145\1\154\1\155\1\156\1\166\1\165\1\164\1\163\7\uffff\1\156\1\143\1\162\13\uffff\1\151\1\164\10\uffff\1\172\2\uffff\1\172\1\154\1\uffff\1\156\2\172\1\164\1\172\1\145\1\uffff\1\145\4\172\1\145\1\163\1\144\4\172\1\152\1\155\1\145\1\143\1\145\1\172\1\164\1\172\1\166\1\172\2\uffff\1\151\1\172\2\uffff\1\162\1\uffff\2\172\4\uffff\3\172\4\uffff\2\172\1\156\1\164\1\172\1\uffff\1\172\1\uffff\1\172\1\uffff\1\145\1\uffff\1\141\7\uffff\1\144\1\154\3\uffff\1\163\1\143\1\163\1\171\1\172\1\164\2\172\1\uffff\1\172\3\uffff";
2451 static final String DFA11_acceptS =
2452 "\21\uffff\1\27\1\30\1\31\3\uffff\1\40\1\41\1\uffff\1\56\1\uffff\1\62\1\63\1\64\1\65\2\uffff\1\73\1\74\1\102\1\103\3\uffff\1\107\1\110\1\1\2\uffff\1\102\1\uffff\1\55\1\51\4\uffff\1\5\1\45\1\7\1\60\3\uffff\1\46\1\11\17\uffff\1\27\1\30\1\31\1\53\1\35\1\54\1\36\3\uffff\1\40\1\41\1\50\1\47\1\56\1\61\1\57\1\62\1\63\1\64\1\65\2\uffff\1\73\1\74\1\103\1\104\1\105\1\106\1\107\1\2\1\uffff\1\3\1\52\2\uffff\1\34\6\uffff\1\14\26\uffff\1\17\1\4\2\uffff\1\10\1\13\1\uffff\1\12\2\uffff\1\20\1\22\1\66\1\32\3\uffff\1\23\1\24\1\75\1\25\5\uffff\1\37\1\uffff\1\76\1\uffff\1\72\1\uffff\1\70\1\uffff\1\67\1\15\1\16\1\21\1\42\1\100\1\26\2\uffff\1\44\1\43\1\71\10\uffff\1\6\1\uffff\1\33\1\101\1\77";
2453 static final String DFA11_specialS =
2454 "\1\1\45\uffff\1\0\1\2\u00a3\uffff}>";
2455 static final String[] DFA11_transitionS = {
2456 "\11\52\2\51\2\52\1\51\22\52\1\51\1\10\1\46\1\37\2\52\1\6\1\47\1\42\1\43\1\36\1\24\1\23\1\33\1\32\1\50\12\45\1\25\1\52\1\3\1\5\1\31\2\52\10\44\1\41\21\44\1\27\1\52\1\30\1\35\1\44\1\52\1\7\2\44\1\17\1\20\1\26\2\44\1\4\2\44\1\13\1\15\1\11\1\2\1\14\1\44\1\16\1\12\1\44\1\40\5\44\1\21\1\1\1\22\1\34\uff81\52",
2457 "\1\53",
2458 "\1\55\3\uffff\1\54",
2459 "\1\60\2\uffff\1\57",
2460 "\1\65\1\uffff\1\62\6\uffff\1\63\1\64",
2461 "\1\66",
2462 "\1\70",
2463 "\1\74\11\uffff\1\73\1\uffff\1\72",
2464 "\1\75",
2465 "\1\77",
2466 "\1\101\3\uffff\1\103\5\uffff\1\100\5\uffff\1\102",
2467 "\1\104",
2468 "\1\105\5\uffff\1\106",
2469 "\1\107",
2470 "\1\110\17\uffff\1\111",
2471 "\1\112",
2472 "\1\115\1\uffff\1\113\11\uffff\1\114",
2473 "",
2474 "",
2475 "",
2476 "\1\121",
2477 "\1\123",
2478 "\1\126\15\uffff\1\127\5\uffff\1\125",
2479 "",
2480 "",
2481 "\1\132",
2482 "",
2483 "\1\135",
2484 "",
2485 "",
2486 "",
2487 "",
2488 "\1\143",
2489 "\1\144",
2490 "",
2491 "",
2492 "",
2493 "",
2494 "\0\150",
2495 "\0\150",
2496 "\1\151\4\uffff\1\152",
2497 "",
2498 "",
2499 "",
2500 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2501 "\1\155",
2502 "",
2503 "\1\156",
2504 "",
2505 "",
2506 "\1\160",
2507 "\1\161",
2508 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2509 "\1\163",
2510 "",
2511 "",
2512 "",
2513 "",
2514 "\1\164",
2515 "\1\165",
2516 "\1\166",
2517 "",
2518 "",
2519 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\15\56\1\170\5\56\1\167\6\56",
2520 "\1\172",
2521 "\1\173",
2522 "\1\174\12\uffff\1\175",
2523 "\1\176",
2524 "\1\177",
2525 "\1\u0080",
2526 "\1\u0081",
2527 "\1\u0082",
2528 "\1\u0083",
2529 "\1\u0084",
2530 "\1\u0086\2\uffff\1\u0085",
2531 "\1\u0087",
2532 "\1\u0089\22\uffff\1\u0088",
2533 "\1\u008a",
2534 "",
2535 "",
2536 "",
2537 "",
2538 "",
2539 "",
2540 "",
2541 "\1\u008b",
2542 "\1\u008c",
2543 "\1\u008d",
2544 "",
2545 "",
2546 "",
2547 "",
2548 "",
2549 "",
2550 "",
2551 "",
2552 "",
2553 "",
2554 "",
2555 "\1\u008e",
2556 "\1\u008f",
2557 "",
2558 "",
2559 "",
2560 "",
2561 "",
2562 "",
2563 "",
2564 "",
2565 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2566 "",
2567 "",
2568 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2569 "\1\u0092",
2570 "",
2571 "\1\u0093",
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\u0096",
2575 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2576 "\1\u0098",
2577 "",
2578 "\1\u0099",
2579 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
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\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
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\u009e",
2584 "\1\u009f",
2585 "\1\u00a0",
2586 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2587 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2588 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2589 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2590 "\1\u00a5",
2591 "\1\u00a6",
2592 "\1\u00a7",
2593 "\1\u00a8",
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\u00ab",
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 "",
2601 "",
2602 "\1\u00af",
2603 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2604 "",
2605 "",
2606 "\1\u00b1",
2607 "",
2608 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2609 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2610 "",
2611 "",
2612 "",
2613 "",
2614 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2615 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
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 "",
2619 "",
2620 "",
2621 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2622 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2623 "\1\u00b9",
2624 "\1\u00ba",
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 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
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 "\1\u00be",
2632 "",
2633 "\1\u00bf",
2634 "",
2635 "",
2636 "",
2637 "",
2638 "",
2639 "",
2640 "",
2641 "\1\u00c0",
2642 "\1\u00c1",
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\u00c7",
2652 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
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 "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56",
2656 "",
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_38 = input.LA(1);
2699
2700 s = -1;
2701 if ( ((LA11_38>='\u0000' && LA11_38<='\uFFFF')) ) {s = 104;}
2702
2703 else s = 42;
2704
2705 if ( s>=0 ) return s;
2706 break;
2707 case 1 :
2708 int LA11_0 = input.LA(1);
2709
2710 s = -1;
2711 if ( (LA11_0=='|') ) {s = 1;}
2712
2713 else if ( (LA11_0=='o') ) {s = 2;}
2714
2715 else if ( (LA11_0=='<') ) {s = 3;}
2716
2717 else if ( (LA11_0=='i') ) {s = 4;}
2718
2719 else if ( (LA11_0=='=') ) {s = 5;}
2720
2721 else if ( (LA11_0=='&') ) {s = 6;}
2722
2723 else if ( (LA11_0=='a') ) {s = 7;}
2724
2725 else if ( (LA11_0=='!') ) {s = 8;}
2726
2727 else if ( (LA11_0=='n') ) {s = 9;}
2728
2729 else if ( (LA11_0=='s') ) {s = 10;}
2730
2731 else if ( (LA11_0=='l') ) {s = 11;}
2732
2733 else if ( (LA11_0=='p') ) {s = 12;}
2734
2735 else if ( (LA11_0=='m') ) {s = 13;}
2736
2737 else if ( (LA11_0=='r') ) {s = 14;}
2738
2739 else if ( (LA11_0=='d') ) {s = 15;}
2740
2741 else if ( (LA11_0=='e') ) {s = 16;}
2742
2743 else if ( (LA11_0=='{') ) {s = 17;}
2744
2745 else if ( (LA11_0=='}') ) {s = 18;}
2746
2747 else if ( (LA11_0==',') ) {s = 19;}
2748
2749 else if ( (LA11_0=='+') ) {s = 20;}
2750
2751 else if ( (LA11_0==':') ) {s = 21;}
2752
2753 else if ( (LA11_0=='f') ) {s = 22;}
2754
2755 else if ( (LA11_0=='[') ) {s = 23;}
2756
2757 else if ( (LA11_0==']') ) {s = 24;}
2758
2759 else if ( (LA11_0=='>') ) {s = 25;}
2760
2761 else if ( (LA11_0=='.') ) {s = 26;}
2762
2763 else if ( (LA11_0=='-') ) {s = 27;}
2764
2765 else if ( (LA11_0=='~') ) {s = 28;}
2766
2767 else if ( (LA11_0=='^') ) {s = 29;}
2768
2769 else if ( (LA11_0=='*') ) {s = 30;}
2770
2771 else if ( (LA11_0=='#') ) {s = 31;}
2772
2773 else if ( (LA11_0=='u') ) {s = 32;}
2774
2775 else if ( (LA11_0=='I') ) {s = 33;}
2776
2777 else if ( (LA11_0=='(') ) {s = 34;}
2778
2779 else if ( (LA11_0==')') ) {s = 35;}
2780
2781 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;}
2782
2783 else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 37;}
2784
2785 else if ( (LA11_0=='\"') ) {s = 38;}
2786
2787 else if ( (LA11_0=='\'') ) {s = 39;}
2788
2789 else if ( (LA11_0=='/') ) {s = 40;}
2790
2791 else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 41;}
2792
2793 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;}
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-01 11:00:54 +0000