projects / deliverable / tracecompass.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update Grammar and Add support for callsites
[deliverable/tracecompass.git] / org.eclipse.linuxtools.ctf.parser / src / org / eclipse / linuxtools / ctf / parser / CTFLexer.java
1 // $ANTLR !Unknown version! CTFLexer.g 2012-10-22 14:14:33
2
3 package org.eclipse.linuxtools.ctf.parser;
4
5 import org.antlr.runtime.BaseRecognizer;
6 import org.antlr.runtime.CharStream;
7 import org.antlr.runtime.DFA;
8 import org.antlr.runtime.EarlyExitException;
9 import org.antlr.runtime.Lexer;
10 import org.antlr.runtime.MismatchedSetException;
11 import org.antlr.runtime.NoViableAltException;
12 import org.antlr.runtime.RecognitionException;
13 import org.antlr.runtime.RecognizerSharedState;
14
15 @SuppressWarnings({ "javadoc", "nls", "incomplete-switch" })
16 public class CTFLexer extends Lexer {
17 public static final int SIGN = 50;
18 public static final int TERM = 48;
19 public static final int BOOLTOK = 26;
20 public static final int LT = 40;
21 public static final int TYPEDEFTOK = 22;
22 public static final int STRING_CONTENT = 71;
23 public static final int INTEGER_TYPES_SUFFIX = 54;
24 public static final int POINTER = 49;
25 public static final int HEX_PREFIX = 58;
26 public static final int INTTOK = 13;
27 public static final int SEPARATOR = 35;
28 public static final int TYPE_ASSIGNMENT = 39;
29 public static final int ENUMTOK = 8;
30 public static final int COMPLEXTOK = 27;
31 public static final int IMAGINARYTOK = 28;
32 public static final int DOUBLEQUOTE = 70;
33 public static final int STREAMTOK = 17;
34 public static final int EOF = -1;
35 public static final int LPAREN = 44;
36 public static final int INFINITYTOK = 33;
37 public static final int STRINGPREFIX = 66;
38 public static final int UNSIGNEDTOK = 23;
39 public static final int ESCAPE_SEQUENCE = 65;
40 public static final int CHAR_CONTENT = 68;
41 public static final int RPAREN = 45;
42 public static final int UNICODE_ESCAPE = 63;
43 public static final int STRING_LITERAL = 72;
44 public static final int CALLSITETOK = 31;
45 public static final int SINGLEQUOTE = 67;
46 public static final int IDENTIFIER = 79;
47 public static final int ALIGNTOK = 4;
48 public static final int FLOATTOK = 11;
49 public static final int COMMENT_CLOSE = 75;
50 public static final int STRINGTOK = 18;
51 public static final int HEX_LITERAL = 60;
52 public static final int DIGIT = 56;
53 public static final int COMMENT = 76;
54 public static final int DOT = 52;
55 public static final int STRUCTTOK = 19;
56 public static final int ENVTOK = 29;
57 public static final int TYPEALIASTOK = 21;
58 public static final int OPENBRAC = 42;
59 public static final int FLOATINGPOINTTOK = 10;
60 public static final int EVENTTOK = 9;
61 public static final int LINE_COMMENT = 77;
62 public static final int NINFINITYTOK = 34;
63 public static final int VOIDTOK = 25;
64 public static final int DOUBLETOK = 7;
65 public static final int CHARACTER_LITERAL = 69;
66 public static final int OCTAL_LITERAL = 55;
67 public static final int COMMENT_OPEN = 74;
68 public static final int HEX_DIGIT = 59;
69 public static final int OCTAL_ESCAPE = 62;
70 public static final int NANNUMBERTOK = 32;
71 public static final int LONGTOK = 14;
72 public static final int CLOCKTOK = 30;
73 public static final int SIGNEDTOK = 16;
74 public static final int TRACETOK = 20;
75 public static final int COLON = 36;
76 public static final int HEXADECIMAL_ESCAPE = 64;
77 public static final int CHARTOK = 6;
78 public static final int LCURL = 46;
79 public static final int WS = 73;
80 public static final int INTEGERTOK = 12;
81 public static final int VARIANTTOK = 24;
82 public static final int ELIPSES = 37;
83 public static final int NONDIGIT = 78;
84 public static final int RCURL = 47;
85 public static final int ARROW = 51;
86 public static final int GT = 41;
87 public static final int ASSIGNMENT = 38;
88 public static final int SHORTTOK = 15;
89 public static final int NONZERO_DIGIT = 61;
90 public static final int DECIMAL_LITERAL = 57;
91 public static final int CONSTTOK = 5;
92 public static final int BACKSLASH = 53;
93 public static final int CLOSEBRAC = 43;
94
95 // delegates
96 // delegators
97
98 public CTFLexer() {
99 }
100
101 public CTFLexer(CharStream input) {
102 this(input, new RecognizerSharedState());
103 }
104
105 public CTFLexer(CharStream input, RecognizerSharedState state) {
106 super(input, state);
107
108 }
109
110 @Override
111 public String getGrammarFileName() {
112 return "CTFLexer.g";
113 }
114
115 // $ANTLR start "ALIGNTOK"
116 public final void mALIGNTOK() throws RecognitionException {
117 try {
118 int _type = ALIGNTOK;
119 int _channel = DEFAULT_TOKEN_CHANNEL;
120 // CTFLexer.g:18:18: ( 'align' )
121 // CTFLexer.g:18:20: 'align'
122 {
123 match("align");
124
125 }
126
127 state.type = _type;
128 state.channel = _channel;
129 } finally {
130 }
131 }
132
133 // $ANTLR end "ALIGNTOK"
134
135 // $ANTLR start "CONSTTOK"
136 public final void mCONSTTOK() throws RecognitionException {
137 try {
138 int _type = CONSTTOK;
139 int _channel = DEFAULT_TOKEN_CHANNEL;
140 // CTFLexer.g:19:18: ( 'const' )
141 // CTFLexer.g:19:20: 'const'
142 {
143 match("const");
144
145 }
146
147 state.type = _type;
148 state.channel = _channel;
149 } finally {
150 }
151 }
152
153 // $ANTLR end "CONSTTOK"
154
155 // $ANTLR start "CHARTOK"
156 public final void mCHARTOK() throws RecognitionException {
157 try {
158 int _type = CHARTOK;
159 int _channel = DEFAULT_TOKEN_CHANNEL;
160 // CTFLexer.g:20:18: ( 'char' )
161 // CTFLexer.g:20:20: 'char'
162 {
163 match("char");
164
165 }
166
167 state.type = _type;
168 state.channel = _channel;
169 } finally {
170 }
171 }
172
173 // $ANTLR end "CHARTOK"
174
175 // $ANTLR start "DOUBLETOK"
176 public final void mDOUBLETOK() throws RecognitionException {
177 try {
178 int _type = DOUBLETOK;
179 int _channel = DEFAULT_TOKEN_CHANNEL;
180 // CTFLexer.g:21:18: ( 'double' )
181 // CTFLexer.g:21:20: 'double'
182 {
183 match("double");
184
185 }
186
187 state.type = _type;
188 state.channel = _channel;
189 } finally {
190 }
191 }
192
193 // $ANTLR end "DOUBLETOK"
194
195 // $ANTLR start "ENUMTOK"
196 public final void mENUMTOK() throws RecognitionException {
197 try {
198 int _type = ENUMTOK;
199 int _channel = DEFAULT_TOKEN_CHANNEL;
200 // CTFLexer.g:22:18: ( 'enum' )
201 // CTFLexer.g:22:20: 'enum'
202 {
203 match("enum");
204
205 }
206
207 state.type = _type;
208 state.channel = _channel;
209 } finally {
210 }
211 }
212
213 // $ANTLR end "ENUMTOK"
214
215 // $ANTLR start "EVENTTOK"
216 public final void mEVENTTOK() throws RecognitionException {
217 try {
218 int _type = EVENTTOK;
219 int _channel = DEFAULT_TOKEN_CHANNEL;
220 // CTFLexer.g:23:18: ( 'event' )
221 // CTFLexer.g:23:20: 'event'
222 {
223 match("event");
224
225 }
226
227 state.type = _type;
228 state.channel = _channel;
229 } finally {
230 }
231 }
232
233 // $ANTLR end "EVENTTOK"
234
235 // $ANTLR start "FLOATINGPOINTTOK"
236 public final void mFLOATINGPOINTTOK() throws RecognitionException {
237 try {
238 int _type = FLOATINGPOINTTOK;
239 int _channel = DEFAULT_TOKEN_CHANNEL;
240 // CTFLexer.g:24:18: ( 'floating_point' )
241 // CTFLexer.g:24:20: 'floating_point'
242 {
243 match("floating_point");
244
245 }
246
247 state.type = _type;
248 state.channel = _channel;
249 } finally {
250 }
251 }
252
253 // $ANTLR end "FLOATINGPOINTTOK"
254
255 // $ANTLR start "FLOATTOK"
256 public final void mFLOATTOK() throws RecognitionException {
257 try {
258 int _type = FLOATTOK;
259 int _channel = DEFAULT_TOKEN_CHANNEL;
260 // CTFLexer.g:25:18: ( 'float' )
261 // CTFLexer.g:25:20: 'float'
262 {
263 match("float");
264
265 }
266
267 state.type = _type;
268 state.channel = _channel;
269 } finally {
270 }
271 }
272
273 // $ANTLR end "FLOATTOK"
274
275 // $ANTLR start "INTEGERTOK"
276 public final void mINTEGERTOK() throws RecognitionException {
277 try {
278 int _type = INTEGERTOK;
279 int _channel = DEFAULT_TOKEN_CHANNEL;
280 // CTFLexer.g:26:18: ( 'integer' )
281 // CTFLexer.g:26:20: 'integer'
282 {
283 match("integer");
284
285 }
286
287 state.type = _type;
288 state.channel = _channel;
289 } finally {
290 }
291 }
292
293 // $ANTLR end "INTEGERTOK"
294
295 // $ANTLR start "INTTOK"
296 public final void mINTTOK() throws RecognitionException {
297 try {
298 int _type = INTTOK;
299 int _channel = DEFAULT_TOKEN_CHANNEL;
300 // CTFLexer.g:27:18: ( 'int' )
301 // CTFLexer.g:27:20: 'int'
302 {
303 match("int");
304
305 }
306
307 state.type = _type;
308 state.channel = _channel;
309 } finally {
310 }
311 }
312
313 // $ANTLR end "INTTOK"
314
315 // $ANTLR start "LONGTOK"
316 public final void mLONGTOK() throws RecognitionException {
317 try {
318 int _type = LONGTOK;
319 int _channel = DEFAULT_TOKEN_CHANNEL;
320 // CTFLexer.g:28:18: ( 'long' )
321 // CTFLexer.g:28:20: 'long'
322 {
323 match("long");
324
325 }
326
327 state.type = _type;
328 state.channel = _channel;
329 } finally {
330 }
331 }
332
333 // $ANTLR end "LONGTOK"
334
335 // $ANTLR start "SHORTTOK"
336 public final void mSHORTTOK() throws RecognitionException {
337 try {
338 int _type = SHORTTOK;
339 int _channel = DEFAULT_TOKEN_CHANNEL;
340 // CTFLexer.g:29:18: ( 'short' )
341 // CTFLexer.g:29:20: 'short'
342 {
343 match("short");
344
345 }
346
347 state.type = _type;
348 state.channel = _channel;
349 } finally {
350 }
351 }
352
353 // $ANTLR end "SHORTTOK"
354
355 // $ANTLR start "SIGNEDTOK"
356 public final void mSIGNEDTOK() throws RecognitionException {
357 try {
358 int _type = SIGNEDTOK;
359 int _channel = DEFAULT_TOKEN_CHANNEL;
360 // CTFLexer.g:30:18: ( 'signed' )
361 // CTFLexer.g:30:20: 'signed'
362 {
363 match("signed");
364
365 }
366
367 state.type = _type;
368 state.channel = _channel;
369 } finally {
370 }
371 }
372
373 // $ANTLR end "SIGNEDTOK"
374
375 // $ANTLR start "STREAMTOK"
376 public final void mSTREAMTOK() throws RecognitionException {
377 try {
378 int _type = STREAMTOK;
379 int _channel = DEFAULT_TOKEN_CHANNEL;
380 // CTFLexer.g:31:18: ( 'stream' )
381 // CTFLexer.g:31:20: 'stream'
382 {
383 match("stream");
384
385 }
386
387 state.type = _type;
388 state.channel = _channel;
389 } finally {
390 }
391 }
392
393 // $ANTLR end "STREAMTOK"
394
395 // $ANTLR start "STRINGTOK"
396 public final void mSTRINGTOK() throws RecognitionException {
397 try {
398 int _type = STRINGTOK;
399 int _channel = DEFAULT_TOKEN_CHANNEL;
400 // CTFLexer.g:32:18: ( 'string' )
401 // CTFLexer.g:32:20: 'string'
402 {
403 match("string");
404
405 }
406
407 state.type = _type;
408 state.channel = _channel;
409 } finally {
410 }
411 }
412
413 // $ANTLR end "STRINGTOK"
414
415 // $ANTLR start "STRUCTTOK"
416 public final void mSTRUCTTOK() throws RecognitionException {
417 try {
418 int _type = STRUCTTOK;
419 int _channel = DEFAULT_TOKEN_CHANNEL;
420 // CTFLexer.g:33:18: ( 'struct' )
421 // CTFLexer.g:33:20: 'struct'
422 {
423 match("struct");
424
425 }
426
427 state.type = _type;
428 state.channel = _channel;
429 } finally {
430 }
431 }
432
433 // $ANTLR end "STRUCTTOK"
434
435 // $ANTLR start "TRACETOK"
436 public final void mTRACETOK() throws RecognitionException {
437 try {
438 int _type = TRACETOK;
439 int _channel = DEFAULT_TOKEN_CHANNEL;
440 // CTFLexer.g:34:18: ( 'trace' )
441 // CTFLexer.g:34:20: 'trace'
442 {
443 match("trace");
444
445 }
446
447 state.type = _type;
448 state.channel = _channel;
449 } finally {
450 }
451 }
452
453 // $ANTLR end "TRACETOK"
454
455 // $ANTLR start "TYPEALIASTOK"
456 public final void mTYPEALIASTOK() throws RecognitionException {
457 try {
458 int _type = TYPEALIASTOK;
459 int _channel = DEFAULT_TOKEN_CHANNEL;
460 // CTFLexer.g:35:18: ( 'typealias' )
461 // CTFLexer.g:35:20: 'typealias'
462 {
463 match("typealias");
464
465 }
466
467 state.type = _type;
468 state.channel = _channel;
469 } finally {
470 }
471 }
472
473 // $ANTLR end "TYPEALIASTOK"
474
475 // $ANTLR start "TYPEDEFTOK"
476 public final void mTYPEDEFTOK() throws RecognitionException {
477 try {
478 int _type = TYPEDEFTOK;
479 int _channel = DEFAULT_TOKEN_CHANNEL;
480 // CTFLexer.g:36:18: ( 'typedef' )
481 // CTFLexer.g:36:20: 'typedef'
482 {
483 match("typedef");
484
485 }
486
487 state.type = _type;
488 state.channel = _channel;
489 } finally {
490 }
491 }
492
493 // $ANTLR end "TYPEDEFTOK"
494
495 // $ANTLR start "UNSIGNEDTOK"
496 public final void mUNSIGNEDTOK() throws RecognitionException {
497 try {
498 int _type = UNSIGNEDTOK;
499 int _channel = DEFAULT_TOKEN_CHANNEL;
500 // CTFLexer.g:37:18: ( 'unsigned' )
501 // CTFLexer.g:37:20: 'unsigned'
502 {
503 match("unsigned");
504
505 }
506
507 state.type = _type;
508 state.channel = _channel;
509 } finally {
510 }
511 }
512
513 // $ANTLR end "UNSIGNEDTOK"
514
515 // $ANTLR start "VARIANTTOK"
516 public final void mVARIANTTOK() throws RecognitionException {
517 try {
518 int _type = VARIANTTOK;
519 int _channel = DEFAULT_TOKEN_CHANNEL;
520 // CTFLexer.g:38:18: ( 'variant' )
521 // CTFLexer.g:38:20: 'variant'
522 {
523 match("variant");
524
525 }
526
527 state.type = _type;
528 state.channel = _channel;
529 } finally {
530 }
531 }
532
533 // $ANTLR end "VARIANTTOK"
534
535 // $ANTLR start "VOIDTOK"
536 public final void mVOIDTOK() throws RecognitionException {
537 try {
538 int _type = VOIDTOK;
539 int _channel = DEFAULT_TOKEN_CHANNEL;
540 // CTFLexer.g:39:18: ( 'void' )
541 // CTFLexer.g:39:20: 'void'
542 {
543 match("void");
544
545 }
546
547 state.type = _type;
548 state.channel = _channel;
549 } finally {
550 }
551 }
552
553 // $ANTLR end "VOIDTOK"
554
555 // $ANTLR start "BOOLTOK"
556 public final void mBOOLTOK() throws RecognitionException {
557 try {
558 int _type = BOOLTOK;
559 int _channel = DEFAULT_TOKEN_CHANNEL;
560 // CTFLexer.g:40:18: ( '_Bool' )
561 // CTFLexer.g:40:20: '_Bool'
562 {
563 match("_Bool");
564
565 }
566
567 state.type = _type;
568 state.channel = _channel;
569 } finally {
570 }
571 }
572
573 // $ANTLR end "BOOLTOK"
574
575 // $ANTLR start "COMPLEXTOK"
576 public final void mCOMPLEXTOK() throws RecognitionException {
577 try {
578 int _type = COMPLEXTOK;
579 int _channel = DEFAULT_TOKEN_CHANNEL;
580 // CTFLexer.g:41:18: ( '_Complex' )
581 // CTFLexer.g:41:20: '_Complex'
582 {
583 match("_Complex");
584
585 }
586
587 state.type = _type;
588 state.channel = _channel;
589 } finally {
590 }
591 }
592
593 // $ANTLR end "COMPLEXTOK"
594
595 // $ANTLR start "IMAGINARYTOK"
596 public final void mIMAGINARYTOK() throws RecognitionException {
597 try {
598 int _type = IMAGINARYTOK;
599 int _channel = DEFAULT_TOKEN_CHANNEL;
600 // CTFLexer.g:42:18: ( '_Imaginary' )
601 // CTFLexer.g:42:20: '_Imaginary'
602 {
603 match("_Imaginary");
604
605 }
606
607 state.type = _type;
608 state.channel = _channel;
609 } finally {
610 }
611 }
612
613 // $ANTLR end "IMAGINARYTOK"
614
615 // $ANTLR start "ENVTOK"
616 public final void mENVTOK() throws RecognitionException {
617 try {
618 int _type = ENVTOK;
619 int _channel = DEFAULT_TOKEN_CHANNEL;
620 // CTFLexer.g:43:18: ( 'env' )
621 // CTFLexer.g:43:20: 'env'
622 {
623 match("env");
624
625 }
626
627 state.type = _type;
628 state.channel = _channel;
629 } finally {
630 }
631 }
632
633 // $ANTLR end "ENVTOK"
634
635 // $ANTLR start "CLOCKTOK"
636 public final void mCLOCKTOK() throws RecognitionException {
637 try {
638 int _type = CLOCKTOK;
639 int _channel = DEFAULT_TOKEN_CHANNEL;
640 // CTFLexer.g:44:18: ( 'clock' )
641 // CTFLexer.g:44:20: 'clock'
642 {
643 match("clock");
644
645 }
646
647 state.type = _type;
648 state.channel = _channel;
649 } finally {
650 }
651 }
652
653 // $ANTLR end "CLOCKTOK"
654
655 // $ANTLR start "CALLSITETOK"
656 public final void mCALLSITETOK() throws RecognitionException {
657 try {
658 int _type = CALLSITETOK;
659 int _channel = DEFAULT_TOKEN_CHANNEL;
660 // CTFLexer.g:48:18: ( 'callsite' )
661 // CTFLexer.g:48:20: 'callsite'
662 {
663 match("callsite");
664
665 }
666
667 state.type = _type;
668 state.channel = _channel;
669 } finally {
670 }
671 }
672
673 // $ANTLR end "CALLSITETOK"
674
675 // $ANTLR start "NANNUMBERTOK"
676 public final void mNANNUMBERTOK() throws RecognitionException {
677 try {
678 int _type = NANNUMBERTOK;
679 int _channel = DEFAULT_TOKEN_CHANNEL;
680 // CTFLexer.g:54:15: ( 'NaN' )
681 // CTFLexer.g:54:17: 'NaN'
682 {
683 match("NaN");
684
685 }
686
687 state.type = _type;
688 state.channel = _channel;
689 } finally {
690 }
691 }
692
693 // $ANTLR end "NANNUMBERTOK"
694
695 // $ANTLR start "INFINITYTOK"
696 public final void mINFINITYTOK() throws RecognitionException {
697 try {
698 int _type = INFINITYTOK;
699 int _channel = DEFAULT_TOKEN_CHANNEL;
700 // CTFLexer.g:55:15: ( '+inf' )
701 // CTFLexer.g:55:17: '+inf'
702 {
703 match("+inf");
704
705 }
706
707 state.type = _type;
708 state.channel = _channel;
709 } finally {
710 }
711 }
712
713 // $ANTLR end "INFINITYTOK"
714
715 // $ANTLR start "NINFINITYTOK"
716 public final void mNINFINITYTOK() throws RecognitionException {
717 try {
718 int _type = NINFINITYTOK;
719 int _channel = DEFAULT_TOKEN_CHANNEL;
720 // CTFLexer.g:56:15: ( '-inf' )
721 // CTFLexer.g:56:17: '-inf'
722 {
723 match("-inf");
724
725 }
726
727 state.type = _type;
728 state.channel = _channel;
729 } finally {
730 }
731 }
732
733 // $ANTLR end "NINFINITYTOK"
734
735 // $ANTLR start "SEPARATOR"
736 public final void mSEPARATOR() throws RecognitionException {
737 try {
738 int _type = SEPARATOR;
739 int _channel = DEFAULT_TOKEN_CHANNEL;
740 // CTFLexer.g:61:20: ( ',' )
741 // CTFLexer.g:61:22: ','
742 {
743 match(',');
744
745 }
746
747 state.type = _type;
748 state.channel = _channel;
749 } finally {
750 }
751 }
752
753 // $ANTLR end "SEPARATOR"
754
755 // $ANTLR start "COLON"
756 public final void mCOLON() throws RecognitionException {
757 try {
758 int _type = COLON;
759 int _channel = DEFAULT_TOKEN_CHANNEL;
760 // CTFLexer.g:62:20: ( ':' )
761 // CTFLexer.g:62:22: ':'
762 {
763 match(':');
764
765 }
766
767 state.type = _type;
768 state.channel = _channel;
769 } finally {
770 }
771 }
772
773 // $ANTLR end "COLON"
774
775 // $ANTLR start "ELIPSES"
776 public final void mELIPSES() throws RecognitionException {
777 try {
778 int _type = ELIPSES;
779 int _channel = DEFAULT_TOKEN_CHANNEL;
780 // CTFLexer.g:63:20: ( '...' )
781 // CTFLexer.g:63:22: '...'
782 {
783 match("...");
784
785 }
786
787 state.type = _type;
788 state.channel = _channel;
789 } finally {
790 }
791 }
792
793 // $ANTLR end "ELIPSES"
794
795 // $ANTLR start "ASSIGNMENT"
796 public final void mASSIGNMENT() throws RecognitionException {
797 try {
798 int _type = ASSIGNMENT;
799 int _channel = DEFAULT_TOKEN_CHANNEL;
800 // CTFLexer.g:64:20: ( '=' )
801 // CTFLexer.g:64:22: '='
802 {
803 match('=');
804
805 }
806
807 state.type = _type;
808 state.channel = _channel;
809 } finally {
810 }
811 }
812
813 // $ANTLR end "ASSIGNMENT"
814
815 // $ANTLR start "TYPE_ASSIGNMENT"
816 public final void mTYPE_ASSIGNMENT() throws RecognitionException {
817 try {
818 int _type = TYPE_ASSIGNMENT;
819 int _channel = DEFAULT_TOKEN_CHANNEL;
820 // CTFLexer.g:65:20: ( ':=' )
821 // CTFLexer.g:65:22: ':='
822 {
823 match(":=");
824
825 }
826
827 state.type = _type;
828 state.channel = _channel;
829 } finally {
830 }
831 }
832
833 // $ANTLR end "TYPE_ASSIGNMENT"
834
835 // $ANTLR start "LT"
836 public final void mLT() throws RecognitionException {
837 try {
838 int _type = LT;
839 int _channel = DEFAULT_TOKEN_CHANNEL;
840 // CTFLexer.g:66:20: ( '<' )
841 // CTFLexer.g:66:22: '<'
842 {
843 match('<');
844
845 }
846
847 state.type = _type;
848 state.channel = _channel;
849 } finally {
850 }
851 }
852
853 // $ANTLR end "LT"
854
855 // $ANTLR start "GT"
856 public final void mGT() throws RecognitionException {
857 try {
858 int _type = GT;
859 int _channel = DEFAULT_TOKEN_CHANNEL;
860 // CTFLexer.g:67:20: ( '>' )
861 // CTFLexer.g:67:22: '>'
862 {
863 match('>');
864
865 }
866
867 state.type = _type;
868 state.channel = _channel;
869 } finally {
870 }
871 }
872
873 // $ANTLR end "GT"
874
875 // $ANTLR start "OPENBRAC"
876 public final void mOPENBRAC() throws RecognitionException {
877 try {
878 int _type = OPENBRAC;
879 int _channel = DEFAULT_TOKEN_CHANNEL;
880 // CTFLexer.g:68:20: ( '[' )
881 // CTFLexer.g:68:22: '['
882 {
883 match('[');
884
885 }
886
887 state.type = _type;
888 state.channel = _channel;
889 } finally {
890 }
891 }
892
893 // $ANTLR end "OPENBRAC"
894
895 // $ANTLR start "CLOSEBRAC"
896 public final void mCLOSEBRAC() throws RecognitionException {
897 try {
898 int _type = CLOSEBRAC;
899 int _channel = DEFAULT_TOKEN_CHANNEL;
900 // CTFLexer.g:69:20: ( ']' )
901 // CTFLexer.g:69:22: ']'
902 {
903 match(']');
904
905 }
906
907 state.type = _type;
908 state.channel = _channel;
909 } finally {
910 }
911 }
912
913 // $ANTLR end "CLOSEBRAC"
914
915 // $ANTLR start "LPAREN"
916 public final void mLPAREN() throws RecognitionException {
917 try {
918 int _type = LPAREN;
919 int _channel = DEFAULT_TOKEN_CHANNEL;
920 // CTFLexer.g:70:20: ( '(' )
921 // CTFLexer.g:70:22: '('
922 {
923 match('(');
924
925 }
926
927 state.type = _type;
928 state.channel = _channel;
929 } finally {
930 }
931 }
932
933 // $ANTLR end "LPAREN"
934
935 // $ANTLR start "RPAREN"
936 public final void mRPAREN() throws RecognitionException {
937 try {
938 int _type = RPAREN;
939 int _channel = DEFAULT_TOKEN_CHANNEL;
940 // CTFLexer.g:71:20: ( ')' )
941 // CTFLexer.g:71:22: ')'
942 {
943 match(')');
944
945 }
946
947 state.type = _type;
948 state.channel = _channel;
949 } finally {
950 }
951 }
952
953 // $ANTLR end "RPAREN"
954
955 // $ANTLR start "LCURL"
956 public final void mLCURL() throws RecognitionException {
957 try {
958 int _type = LCURL;
959 int _channel = DEFAULT_TOKEN_CHANNEL;
960 // CTFLexer.g:72:20: ( '{' )
961 // CTFLexer.g:72:22: '{'
962 {
963 match('{');
964
965 }
966
967 state.type = _type;
968 state.channel = _channel;
969 } finally {
970 }
971 }
972
973 // $ANTLR end "LCURL"
974
975 // $ANTLR start "RCURL"
976 public final void mRCURL() throws RecognitionException {
977 try {
978 int _type = RCURL;
979 int _channel = DEFAULT_TOKEN_CHANNEL;
980 // CTFLexer.g:73:20: ( '}' )
981 // CTFLexer.g:73:22: '}'
982 {
983 match('}');
984
985 }
986
987 state.type = _type;
988 state.channel = _channel;
989 } finally {
990 }
991 }
992
993 // $ANTLR end "RCURL"
994
995 // $ANTLR start "TERM"
996 public final void mTERM() throws RecognitionException {
997 try {
998 int _type = TERM;
999 int _channel = DEFAULT_TOKEN_CHANNEL;
1000 // CTFLexer.g:74:20: ( ';' )
1001 // CTFLexer.g:74:22: ';'
1002 {
1003 match(';');
1004
1005 }
1006
1007 state.type = _type;
1008 state.channel = _channel;
1009 } finally {
1010 }
1011 }
1012
1013 // $ANTLR end "TERM"
1014
1015 // $ANTLR start "POINTER"
1016 public final void mPOINTER() throws RecognitionException {
1017 try {
1018 int _type = POINTER;
1019 int _channel = DEFAULT_TOKEN_CHANNEL;
1020 // CTFLexer.g:75:20: ( '*' )
1021 // CTFLexer.g:75:22: '*'
1022 {
1023 match('*');
1024
1025 }
1026
1027 state.type = _type;
1028 state.channel = _channel;
1029 } finally {
1030 }
1031 }
1032
1033 // $ANTLR end "POINTER"
1034
1035 // $ANTLR start "SIGN"
1036 public final void mSIGN() throws RecognitionException {
1037 try {
1038 int _type = SIGN;
1039 int _channel = DEFAULT_TOKEN_CHANNEL;
1040 // CTFLexer.g:76:20: ( '+' | '-' )
1041 // CTFLexer.g:
1042 {
1043 if (input.LA(1) == '+' || input.LA(1) == '-') {
1044 input.consume();
1045
1046 } else {
1047 MismatchedSetException mse = new MismatchedSetException(
1048 null, input);
1049 recover(mse);
1050 throw mse;
1051 }
1052
1053 }
1054
1055 state.type = _type;
1056 state.channel = _channel;
1057 } finally {
1058 }
1059 }
1060
1061 // $ANTLR end "SIGN"
1062
1063 // $ANTLR start "ARROW"
1064 public final void mARROW() throws RecognitionException {
1065 try {
1066 int _type = ARROW;
1067 int _channel = DEFAULT_TOKEN_CHANNEL;
1068 // CTFLexer.g:77:20: ( '->' )
1069 // CTFLexer.g:77:22: '->'
1070 {
1071 match("->");
1072
1073 }
1074
1075 state.type = _type;
1076 state.channel = _channel;
1077 } finally {
1078 }
1079 }
1080
1081 // $ANTLR end "ARROW"
1082
1083 // $ANTLR start "DOT"
1084 public final void mDOT() throws RecognitionException {
1085 try {
1086 int _type = DOT;
1087 int _channel = DEFAULT_TOKEN_CHANNEL;
1088 // CTFLexer.g:78:20: ( '.' )
1089 // CTFLexer.g:78:22: '.'
1090 {
1091 match('.');
1092
1093 }
1094
1095 state.type = _type;
1096 state.channel = _channel;
1097 } finally {
1098 }
1099 }
1100
1101 // $ANTLR end "DOT"
1102
1103 // $ANTLR start "BACKSLASH"
1104 public final void mBACKSLASH() throws RecognitionException {
1105 try {
1106 // CTFLexer.g:79:20: ( '\\\\' )
1107 // CTFLexer.g:79:22: '\\\\'
1108 {
1109 match('\\');
1110
1111 }
1112
1113 } finally {
1114 }
1115 }
1116
1117 // $ANTLR end "BACKSLASH"
1118
1119 // $ANTLR start "OCTAL_LITERAL"
1120 public final void mOCTAL_LITERAL() throws RecognitionException {
1121 try {
1122 int _type = OCTAL_LITERAL;
1123 int _channel = DEFAULT_TOKEN_CHANNEL;
1124 // CTFLexer.g:94:15: ( '0' ( '0' .. '7' )+ ( INTEGER_TYPES_SUFFIX )?
1125 // )
1126 // CTFLexer.g:94:17: '0' ( '0' .. '7' )+ ( INTEGER_TYPES_SUFFIX )?
1127 {
1128 match('0');
1129 // CTFLexer.g:94:21: ( '0' .. '7' )+
1130 int cnt1 = 0;
1131 loop1: do {
1132 int alt1 = 2;
1133 int LA1_0 = input.LA(1);
1134
1135 if (((LA1_0 >= '0' && LA1_0 <= '7'))) {
1136 alt1 = 1;
1137 }
1138
1139 switch (alt1) {
1140 case 1:
1141 // CTFLexer.g:94:22: '0' .. '7'
1142 {
1143 matchRange('0', '7');
1144
1145 }
1146 break;
1147
1148 default:
1149 if (cnt1 >= 1) {
1150 break loop1;
1151 }
1152 EarlyExitException eee = new EarlyExitException(1,
1153 input);
1154 throw eee;
1155 }
1156 cnt1++;
1157 } while (true);
1158
1159 // CTFLexer.g:94:33: ( INTEGER_TYPES_SUFFIX )?
1160 int alt2 = 2;
1161 int LA2_0 = input.LA(1);
1162
1163 if ((LA2_0 == 'L' || LA2_0 == 'U' || LA2_0 == 'l' || LA2_0 == 'u')) {
1164 alt2 = 1;
1165 }
1166 switch (alt2) {
1167 case 1:
1168 // CTFLexer.g:94:33: INTEGER_TYPES_SUFFIX
1169 {
1170 mINTEGER_TYPES_SUFFIX();
1171
1172 }
1173 break;
1174
1175 }
1176
1177 }
1178
1179 state.type = _type;
1180 state.channel = _channel;
1181 } finally {
1182 }
1183 }
1184
1185 // $ANTLR end "OCTAL_LITERAL"
1186
1187 // $ANTLR start "DECIMAL_LITERAL"
1188 public final void mDECIMAL_LITERAL() throws RecognitionException {
1189 try {
1190 int _type = DECIMAL_LITERAL;
1191 int _channel = DEFAULT_TOKEN_CHANNEL;
1192 // CTFLexer.g:96:17: ( ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )? )
1193 // CTFLexer.g:96:19: ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )?
1194 {
1195 // CTFLexer.g:96:19: ( DIGIT )+
1196 int cnt3 = 0;
1197 loop3: do {
1198 int alt3 = 2;
1199 int LA3_0 = input.LA(1);
1200
1201 if (((LA3_0 >= '0' && LA3_0 <= '9'))) {
1202 alt3 = 1;
1203 }
1204
1205 switch (alt3) {
1206 case 1:
1207 // CTFLexer.g:96:19: DIGIT
1208 {
1209 mDIGIT();
1210
1211 }
1212 break;
1213
1214 default:
1215 if (cnt3 >= 1) {
1216 break loop3;
1217 }
1218 EarlyExitException eee = new EarlyExitException(3,
1219 input);
1220 throw eee;
1221 }
1222 cnt3++;
1223 } while (true);
1224
1225 // CTFLexer.g:96:26: ( INTEGER_TYPES_SUFFIX )?
1226 int alt4 = 2;
1227 int LA4_0 = input.LA(1);
1228
1229 if ((LA4_0 == 'L' || LA4_0 == 'U' || LA4_0 == 'l' || LA4_0 == 'u')) {
1230 alt4 = 1;
1231 }
1232 switch (alt4) {
1233 case 1:
1234 // CTFLexer.g:96:26: INTEGER_TYPES_SUFFIX
1235 {
1236 mINTEGER_TYPES_SUFFIX();
1237
1238 }
1239 break;
1240
1241 }
1242
1243 }
1244
1245 state.type = _type;
1246 state.channel = _channel;
1247 } finally {
1248 }
1249 }
1250
1251 // $ANTLR end "DECIMAL_LITERAL"
1252
1253 // $ANTLR start "HEX_LITERAL"
1254 public final void mHEX_LITERAL() throws RecognitionException {
1255 try {
1256 int _type = HEX_LITERAL;
1257 int _channel = DEFAULT_TOKEN_CHANNEL;
1258 // CTFLexer.g:98:13: ( HEX_PREFIX ( HEX_DIGIT )+ (
1259 // INTEGER_TYPES_SUFFIX )? )
1260 // CTFLexer.g:98:15: HEX_PREFIX ( HEX_DIGIT )+ (
1261 // INTEGER_TYPES_SUFFIX )?
1262 {
1263 mHEX_PREFIX();
1264 // CTFLexer.g:98:26: ( HEX_DIGIT )+
1265 int cnt5 = 0;
1266 loop5: do {
1267 int alt5 = 2;
1268 int LA5_0 = input.LA(1);
1269
1270 if (((LA5_0 >= '0' && LA5_0 <= '9')
1271 || (LA5_0 >= 'A' && LA5_0 <= 'F') || (LA5_0 >= 'a' && LA5_0 <= 'f'))) {
1272 alt5 = 1;
1273 }
1274
1275 switch (alt5) {
1276 case 1:
1277 // CTFLexer.g:98:26: HEX_DIGIT
1278 {
1279 mHEX_DIGIT();
1280
1281 }
1282 break;
1283
1284 default:
1285 if (cnt5 >= 1) {
1286 break loop5;
1287 }
1288 EarlyExitException eee = new EarlyExitException(5,
1289 input);
1290 throw eee;
1291 }
1292 cnt5++;
1293 } while (true);
1294
1295 // CTFLexer.g:98:37: ( INTEGER_TYPES_SUFFIX )?
1296 int alt6 = 2;
1297 int LA6_0 = input.LA(1);
1298
1299 if ((LA6_0 == 'L' || LA6_0 == 'U' || LA6_0 == 'l' || LA6_0 == 'u')) {
1300 alt6 = 1;
1301 }
1302 switch (alt6) {
1303 case 1:
1304 // CTFLexer.g:98:37: INTEGER_TYPES_SUFFIX
1305 {
1306 mINTEGER_TYPES_SUFFIX();
1307
1308 }
1309 break;
1310
1311 }
1312
1313 }
1314
1315 state.type = _type;
1316 state.channel = _channel;
1317 } finally {
1318 }
1319 }
1320
1321 // $ANTLR end "HEX_LITERAL"
1322
1323 // $ANTLR start "HEX_DIGIT"
1324 public final void mHEX_DIGIT() throws RecognitionException {
1325 try {
1326 // CTFLexer.g:99:20: ( DIGIT | ( 'a' .. 'f' ) | ( 'A' .. 'F' ) )
1327 int alt7 = 3;
1328 switch (input.LA(1)) {
1329 case '0':
1330 case '1':
1331 case '2':
1332 case '3':
1333 case '4':
1334 case '5':
1335 case '6':
1336 case '7':
1337 case '8':
1338 case '9': {
1339 alt7 = 1;
1340 }
1341 break;
1342 case 'a':
1343 case 'b':
1344 case 'c':
1345 case 'd':
1346 case 'e':
1347 case 'f': {
1348 alt7 = 2;
1349 }
1350 break;
1351 case 'A':
1352 case 'B':
1353 case 'C':
1354 case 'D':
1355 case 'E':
1356 case 'F': {
1357 alt7 = 3;
1358 }
1359 break;
1360 default:
1361 NoViableAltException nvae = new NoViableAltException("", 7, 0,
1362 input);
1363
1364 throw nvae;
1365 }
1366
1367 switch (alt7) {
1368 case 1:
1369 // CTFLexer.g:99:22: DIGIT
1370 {
1371 mDIGIT();
1372
1373 }
1374 break;
1375 case 2:
1376 // CTFLexer.g:99:30: ( 'a' .. 'f' )
1377 {
1378 // CTFLexer.g:99:30: ( 'a' .. 'f' )
1379 // CTFLexer.g:99:31: 'a' .. 'f'
1380 {
1381 matchRange('a', 'f');
1382
1383 }
1384
1385 }
1386 break;
1387 case 3:
1388 // CTFLexer.g:99:43: ( 'A' .. 'F' )
1389 {
1390 // CTFLexer.g:99:43: ( 'A' .. 'F' )
1391 // CTFLexer.g:99:44: 'A' .. 'F'
1392 {
1393 matchRange('A', 'F');
1394
1395 }
1396
1397 }
1398 break;
1399
1400 }
1401 } finally {
1402 }
1403 }
1404
1405 // $ANTLR end "HEX_DIGIT"
1406
1407 // $ANTLR start "HEX_PREFIX"
1408 public final void mHEX_PREFIX() throws RecognitionException {
1409 try {
1410 // CTFLexer.g:100:21: ( '0' ( 'x' | 'X' ) )
1411 // CTFLexer.g:100:23: '0' ( 'x' | 'X' )
1412 {
1413 match('0');
1414 if (input.LA(1) == 'X' || input.LA(1) == 'x') {
1415 input.consume();
1416
1417 } else {
1418 MismatchedSetException mse = new MismatchedSetException(
1419 null, input);
1420 recover(mse);
1421 throw mse;
1422 }
1423
1424 }
1425
1426 } finally {
1427 }
1428 }
1429
1430 // $ANTLR end "HEX_PREFIX"
1431
1432 // $ANTLR start "DIGIT"
1433 public final void mDIGIT() throws RecognitionException {
1434 try {
1435 // CTFLexer.g:103:16: ( '0' .. '9' )
1436 // CTFLexer.g:103:18: '0' .. '9'
1437 {
1438 matchRange('0', '9');
1439
1440 }
1441
1442 } finally {
1443 }
1444 }
1445
1446 // $ANTLR end "DIGIT"
1447
1448 // $ANTLR start "NONZERO_DIGIT"
1449 public final void mNONZERO_DIGIT() throws RecognitionException {
1450 try {
1451 // CTFLexer.g:104:24: ( '1' .. '9' )
1452 // CTFLexer.g:104:26: '1' .. '9'
1453 {
1454 matchRange('1', '9');
1455
1456 }
1457
1458 } finally {
1459 }
1460 }
1461
1462 // $ANTLR end "NONZERO_DIGIT"
1463
1464 // $ANTLR start "INTEGER_TYPES_SUFFIX"
1465 public final void mINTEGER_TYPES_SUFFIX() throws RecognitionException {
1466 try {
1467 // CTFLexer.g:112:31: ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'u' |
1468 // 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'l' (
1469 // 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) )
1470 int alt17 = 4;
1471 alt17 = dfa17.predict(input);
1472 switch (alt17) {
1473 case 1:
1474 // CTFLexer.g:113:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1475 {
1476 // CTFLexer.g:113:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1477 int alt10 = 2;
1478 int LA10_0 = input.LA(1);
1479
1480 if ((LA10_0 == 'l')) {
1481 alt10 = 1;
1482 } else if ((LA10_0 == 'L')) {
1483 alt10 = 2;
1484 } else {
1485 NoViableAltException nvae = new NoViableAltException("",
1486 10, 0, input);
1487
1488 throw nvae;
1489 }
1490 switch (alt10) {
1491 case 1:
1492 // CTFLexer.g:113:5: 'l' ( 'l' )?
1493 {
1494 match('l');
1495 // CTFLexer.g:113:9: ( 'l' )?
1496 int alt8 = 2;
1497 int LA8_0 = input.LA(1);
1498
1499 if ((LA8_0 == 'l')) {
1500 alt8 = 1;
1501 }
1502 switch (alt8) {
1503 case 1:
1504 // CTFLexer.g:113:10: 'l'
1505 {
1506 match('l');
1507
1508 }
1509 break;
1510
1511 }
1512
1513 }
1514 break;
1515 case 2:
1516 // CTFLexer.g:113:18: 'L' ( 'L' )?
1517 {
1518 match('L');
1519 // CTFLexer.g:113:22: ( 'L' )?
1520 int alt9 = 2;
1521 int LA9_0 = input.LA(1);
1522
1523 if ((LA9_0 == 'L')) {
1524 alt9 = 1;
1525 }
1526 switch (alt9) {
1527 case 1:
1528 // CTFLexer.g:113:23: 'L'
1529 {
1530 match('L');
1531
1532 }
1533 break;
1534
1535 }
1536
1537 }
1538 break;
1539
1540 }
1541
1542 }
1543 break;
1544 case 2:
1545 // CTFLexer.g:114:4: ( 'u' | 'U' )
1546 {
1547 if (input.LA(1) == 'U' || input.LA(1) == 'u') {
1548 input.consume();
1549
1550 } else {
1551 MismatchedSetException mse = new MismatchedSetException(
1552 null, input);
1553 recover(mse);
1554 throw mse;
1555 }
1556
1557 }
1558 break;
1559 case 3:
1560 // CTFLexer.g:115:4: ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1561 {
1562 if (input.LA(1) == 'U' || input.LA(1) == 'u') {
1563 input.consume();
1564
1565 } else {
1566 MismatchedSetException mse = new MismatchedSetException(
1567 null, input);
1568 recover(mse);
1569 throw mse;
1570 }
1571
1572 // CTFLexer.g:115:16: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1573 int alt13 = 2;
1574 int LA13_0 = input.LA(1);
1575
1576 if ((LA13_0 == 'l')) {
1577 alt13 = 1;
1578 } else if ((LA13_0 == 'L')) {
1579 alt13 = 2;
1580 } else {
1581 NoViableAltException nvae = new NoViableAltException("",
1582 13, 0, input);
1583
1584 throw nvae;
1585 }
1586 switch (alt13) {
1587 case 1:
1588 // CTFLexer.g:115:17: 'l' ( 'l' )?
1589 {
1590 match('l');
1591 // CTFLexer.g:115:21: ( 'l' )?
1592 int alt11 = 2;
1593 int LA11_0 = input.LA(1);
1594
1595 if ((LA11_0 == 'l')) {
1596 alt11 = 1;
1597 }
1598 switch (alt11) {
1599 case 1:
1600 // CTFLexer.g:115:22: 'l'
1601 {
1602 match('l');
1603
1604 }
1605 break;
1606
1607 }
1608
1609 }
1610 break;
1611 case 2:
1612 // CTFLexer.g:115:30: 'L' ( 'L' )?
1613 {
1614 match('L');
1615 // CTFLexer.g:115:34: ( 'L' )?
1616 int alt12 = 2;
1617 int LA12_0 = input.LA(1);
1618
1619 if ((LA12_0 == 'L')) {
1620 alt12 = 1;
1621 }
1622 switch (alt12) {
1623 case 1:
1624 // CTFLexer.g:115:35: 'L'
1625 {
1626 match('L');
1627
1628 }
1629 break;
1630
1631 }
1632
1633 }
1634 break;
1635
1636 }
1637
1638 }
1639 break;
1640 case 4:
1641 // CTFLexer.g:116:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' )
1642 {
1643 // CTFLexer.g:116:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1644 int alt16 = 2;
1645 int LA16_0 = input.LA(1);
1646
1647 if ((LA16_0 == 'l')) {
1648 alt16 = 1;
1649 } else if ((LA16_0 == 'L')) {
1650 alt16 = 2;
1651 } else {
1652 NoViableAltException nvae = new NoViableAltException("",
1653 16, 0, input);
1654
1655 throw nvae;
1656 }
1657 switch (alt16) {
1658 case 1:
1659 // CTFLexer.g:116:5: 'l' ( 'l' )?
1660 {
1661 match('l');
1662 // CTFLexer.g:116:9: ( 'l' )?
1663 int alt14 = 2;
1664 int LA14_0 = input.LA(1);
1665
1666 if ((LA14_0 == 'l')) {
1667 alt14 = 1;
1668 }
1669 switch (alt14) {
1670 case 1:
1671 // CTFLexer.g:116:10: 'l'
1672 {
1673 match('l');
1674
1675 }
1676 break;
1677
1678 }
1679
1680 }
1681 break;
1682 case 2:
1683 // CTFLexer.g:116:18: 'L' ( 'L' )?
1684 {
1685 match('L');
1686 // CTFLexer.g:116:22: ( 'L' )?
1687 int alt15 = 2;
1688 int LA15_0 = input.LA(1);
1689
1690 if ((LA15_0 == 'L')) {
1691 alt15 = 1;
1692 }
1693 switch (alt15) {
1694 case 1:
1695 // CTFLexer.g:116:23: 'L'
1696 {
1697 match('L');
1698
1699 }
1700 break;
1701
1702 }
1703
1704 }
1705 break;
1706
1707 }
1708
1709 if (input.LA(1) == 'U' || input.LA(1) == 'u') {
1710 input.consume();
1711
1712 } else {
1713 MismatchedSetException mse = new MismatchedSetException(
1714 null, input);
1715 recover(mse);
1716 throw mse;
1717 }
1718
1719 }
1720 break;
1721
1722 }
1723 } finally {
1724 }
1725 }
1726
1727 // $ANTLR end "INTEGER_TYPES_SUFFIX"
1728
1729 // $ANTLR start "ESCAPE_SEQUENCE"
1730 public final void mESCAPE_SEQUENCE() throws RecognitionException {
1731 try {
1732 // CTFLexer.g:122:26: ( BACKSLASH ( '\\'' | '\"' | '?' | BACKSLASH |
1733 // 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' ) | OCTAL_ESCAPE |
1734 // UNICODE_ESCAPE | HEXADECIMAL_ESCAPE )
1735 int alt18 = 4;
1736 int LA18_0 = input.LA(1);
1737
1738 if ((LA18_0 == '\\')) {
1739 switch (input.LA(2)) {
1740 case 'x': {
1741 alt18 = 4;
1742 }
1743 break;
1744 case '0':
1745 case '1':
1746 case '2':
1747 case '3':
1748 case '4':
1749 case '5':
1750 case '6':
1751 case '7': {
1752 alt18 = 2;
1753 }
1754 break;
1755 case '\"':
1756 case '\'':
1757 case '?':
1758 case '\\':
1759 case 'a':
1760 case 'b':
1761 case 'f':
1762 case 'n':
1763 case 'r':
1764 case 't':
1765 case 'v': {
1766 alt18 = 1;
1767 }
1768 break;
1769 case 'U':
1770 case 'u': {
1771 alt18 = 3;
1772 }
1773 break;
1774 default:
1775 NoViableAltException nvae = new NoViableAltException("",
1776 18, 1, input);
1777
1778 throw nvae;
1779 }
1780
1781 } else {
1782 NoViableAltException nvae = new NoViableAltException("", 18, 0,
1783 input);
1784
1785 throw nvae;
1786 }
1787 switch (alt18) {
1788 case 1:
1789 // CTFLexer.g:123:4: BACKSLASH ( '\\'' | '\"' | '?' | BACKSLASH |
1790 // 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' )
1791 {
1792 mBACKSLASH();
1793 if (input.LA(1) == '\"' || input.LA(1) == '\''
1794 || input.LA(1) == '?' || input.LA(1) == '\\'
1795 || (input.LA(1) >= 'a' && input.LA(1) <= 'b')
1796 || input.LA(1) == 'f' || input.LA(1) == 'n'
1797 || input.LA(1) == 'r' || input.LA(1) == 't'
1798 || input.LA(1) == 'v') {
1799 input.consume();
1800
1801 } else {
1802 MismatchedSetException mse = new MismatchedSetException(
1803 null, input);
1804 recover(mse);
1805 throw mse;
1806 }
1807
1808 }
1809 break;
1810 case 2:
1811 // CTFLexer.g:124:4: OCTAL_ESCAPE
1812 {
1813 mOCTAL_ESCAPE();
1814
1815 }
1816 break;
1817 case 3:
1818 // CTFLexer.g:125:4: UNICODE_ESCAPE
1819 {
1820 mUNICODE_ESCAPE();
1821
1822 }
1823 break;
1824 case 4:
1825 // CTFLexer.g:126:4: HEXADECIMAL_ESCAPE
1826 {
1827 mHEXADECIMAL_ESCAPE();
1828
1829 }
1830 break;
1831
1832 }
1833 } finally {
1834 }
1835 }
1836
1837 // $ANTLR end "ESCAPE_SEQUENCE"
1838
1839 // $ANTLR start "OCTAL_ESCAPE"
1840 public final void mOCTAL_ESCAPE() throws RecognitionException {
1841 try {
1842 // CTFLexer.g:132:23: ( BACKSLASH ( '0' .. '3' ) ( '0' .. '7' ) (
1843 // '0' .. '7' ) | BACKSLASH ( '0' .. '7' ) ( '0' .. '7' ) |
1844 // BACKSLASH ( '0' .. '7' ) )
1845 int alt19 = 3;
1846 int LA19_0 = input.LA(1);
1847
1848 if ((LA19_0 == '\\')) {
1849 int LA19_1 = input.LA(2);
1850
1851 if (((LA19_1 >= '0' && LA19_1 <= '3'))) {
1852 int LA19_2 = input.LA(3);
1853
1854 if (((LA19_2 >= '0' && LA19_2 <= '7'))) {
1855 int LA19_4 = input.LA(4);
1856
1857 if (((LA19_4 >= '0' && LA19_4 <= '7'))) {
1858 alt19 = 1;
1859 } else {
1860 alt19 = 2;
1861 }
1862 } else {
1863 alt19 = 3;
1864 }
1865 } else if (((LA19_1 >= '4' && LA19_1 <= '7'))) {
1866 int LA19_3 = input.LA(3);
1867
1868 if (((LA19_3 >= '0' && LA19_3 <= '7'))) {
1869 alt19 = 2;
1870 } else {
1871 alt19 = 3;
1872 }
1873 } else {
1874 NoViableAltException nvae = new NoViableAltException("",
1875 19, 1, input);
1876
1877 throw nvae;
1878 }
1879 } else {
1880 NoViableAltException nvae = new NoViableAltException("", 19, 0,
1881 input);
1882
1883 throw nvae;
1884 }
1885 switch (alt19) {
1886 case 1:
1887 // CTFLexer.g:133:5: BACKSLASH ( '0' .. '3' ) ( '0' .. '7' ) ( '0'
1888 // .. '7' )
1889 {
1890 mBACKSLASH();
1891 // CTFLexer.g:133:15: ( '0' .. '3' )
1892 // CTFLexer.g:133:16: '0' .. '3'
1893 {
1894 matchRange('0', '3');
1895
1896 }
1897
1898 // CTFLexer.g:133:26: ( '0' .. '7' )
1899 // CTFLexer.g:133:27: '0' .. '7'
1900 {
1901 matchRange('0', '7');
1902
1903 }
1904
1905 // CTFLexer.g:133:37: ( '0' .. '7' )
1906 // CTFLexer.g:133:38: '0' .. '7'
1907 {
1908 matchRange('0', '7');
1909
1910 }
1911
1912 }
1913 break;
1914 case 2:
1915 // CTFLexer.g:134:5: BACKSLASH ( '0' .. '7' ) ( '0' .. '7' )
1916 {
1917 mBACKSLASH();
1918 // CTFLexer.g:134:15: ( '0' .. '7' )
1919 // CTFLexer.g:134:16: '0' .. '7'
1920 {
1921 matchRange('0', '7');
1922
1923 }
1924
1925 // CTFLexer.g:134:26: ( '0' .. '7' )
1926 // CTFLexer.g:134:27: '0' .. '7'
1927 {
1928 matchRange('0', '7');
1929
1930 }
1931
1932 }
1933 break;
1934 case 3:
1935 // CTFLexer.g:135:5: BACKSLASH ( '0' .. '7' )
1936 {
1937 mBACKSLASH();
1938 // CTFLexer.g:135:15: ( '0' .. '7' )
1939 // CTFLexer.g:135:16: '0' .. '7'
1940 {
1941 matchRange('0', '7');
1942
1943 }
1944
1945 }
1946 break;
1947
1948 }
1949 } finally {
1950 }
1951 }
1952
1953 // $ANTLR end "OCTAL_ESCAPE"
1954
1955 // $ANTLR start "HEXADECIMAL_ESCAPE"
1956 public final void mHEXADECIMAL_ESCAPE() throws RecognitionException {
1957 try {
1958 // CTFLexer.g:141:29: ( BACKSLASH 'x' ( HEX_DIGIT )+ )
1959 // CTFLexer.g:141:31: BACKSLASH 'x' ( HEX_DIGIT )+
1960 {
1961 mBACKSLASH();
1962 match('x');
1963 // CTFLexer.g:141:45: ( HEX_DIGIT )+
1964 int cnt20 = 0;
1965 loop20: do {
1966 int alt20 = 2;
1967 int LA20_0 = input.LA(1);
1968
1969 if (((LA20_0 >= '0' && LA20_0 <= '9')
1970 || (LA20_0 >= 'A' && LA20_0 <= 'F') || (LA20_0 >= 'a' && LA20_0 <= 'f'))) {
1971 alt20 = 1;
1972 }
1973
1974 switch (alt20) {
1975 case 1:
1976 // CTFLexer.g:141:45: HEX_DIGIT
1977 {
1978 mHEX_DIGIT();
1979
1980 }
1981 break;
1982
1983 default:
1984 if (cnt20 >= 1) {
1985 break loop20;
1986 }
1987 EarlyExitException eee = new EarlyExitException(20,
1988 input);
1989 throw eee;
1990 }
1991 cnt20++;
1992 } while (true);
1993
1994 }
1995
1996 } finally {
1997 }
1998 }
1999
2000 // $ANTLR end "HEXADECIMAL_ESCAPE"
2001
2002 // $ANTLR start "UNICODE_ESCAPE"
2003 public final void mUNICODE_ESCAPE() throws RecognitionException {
2004 try {
2005 // CTFLexer.g:146:25: ( BACKSLASH 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT
2006 // HEX_DIGIT | BACKSLASH 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
2007 // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
2008 int alt21 = 2;
2009 int LA21_0 = input.LA(1);
2010
2011 if ((LA21_0 == '\\')) {
2012 int LA21_1 = input.LA(2);
2013
2014 if ((LA21_1 == 'U')) {
2015 alt21 = 2;
2016 } else if ((LA21_1 == 'u')) {
2017 alt21 = 1;
2018 } else {
2019 NoViableAltException nvae = new NoViableAltException("",
2020 21, 1, input);
2021
2022 throw nvae;
2023 }
2024 } else {
2025 NoViableAltException nvae = new NoViableAltException("", 21, 0,
2026 input);
2027
2028 throw nvae;
2029 }
2030 switch (alt21) {
2031 case 1:
2032 // CTFLexer.g:147:5: BACKSLASH 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT
2033 // HEX_DIGIT
2034 {
2035 mBACKSLASH();
2036 match('u');
2037 mHEX_DIGIT();
2038 mHEX_DIGIT();
2039 mHEX_DIGIT();
2040 mHEX_DIGIT();
2041
2042 }
2043 break;
2044 case 2:
2045 // CTFLexer.g:148:5: BACKSLASH 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT
2046 // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
2047 {
2048 mBACKSLASH();
2049 match('U');
2050 mHEX_DIGIT();
2051 mHEX_DIGIT();
2052 mHEX_DIGIT();
2053 mHEX_DIGIT();
2054 mHEX_DIGIT();
2055 mHEX_DIGIT();
2056 mHEX_DIGIT();
2057 mHEX_DIGIT();
2058
2059 }
2060 break;
2061
2062 }
2063 } finally {
2064 }
2065 }
2066
2067 // $ANTLR end "UNICODE_ESCAPE"
2068
2069 // $ANTLR start "STRINGPREFIX"
2070 public final void mSTRINGPREFIX() throws RecognitionException {
2071 try {
2072 // CTFLexer.g:153:23: ( 'L' )
2073 // CTFLexer.g:153:25: 'L'
2074 {
2075 match('L');
2076
2077 }
2078
2079 } finally {
2080 }
2081 }
2082
2083 // $ANTLR end "STRINGPREFIX"
2084
2085 // $ANTLR start "CHARACTER_LITERAL"
2086 public final void mCHARACTER_LITERAL() throws RecognitionException {
2087 try {
2088 int _type = CHARACTER_LITERAL;
2089 int _channel = DEFAULT_TOKEN_CHANNEL;
2090 // CTFLexer.g:158:19: ( ( STRINGPREFIX )? SINGLEQUOTE ( CHAR_CONTENT
2091 // )+ SINGLEQUOTE )
2092 // CTFLexer.g:158:21: ( STRINGPREFIX )? SINGLEQUOTE ( CHAR_CONTENT
2093 // )+ SINGLEQUOTE
2094 {
2095 // CTFLexer.g:158:21: ( STRINGPREFIX )?
2096 int alt22 = 2;
2097 int LA22_0 = input.LA(1);
2098
2099 if ((LA22_0 == 'L')) {
2100 alt22 = 1;
2101 }
2102 switch (alt22) {
2103 case 1:
2104 // CTFLexer.g:158:21: STRINGPREFIX
2105 {
2106 mSTRINGPREFIX();
2107
2108 }
2109 break;
2110
2111 }
2112
2113 mSINGLEQUOTE();
2114 // CTFLexer.g:158:47: ( CHAR_CONTENT )+
2115 int cnt23 = 0;
2116 loop23: do {
2117 int alt23 = 2;
2118 int LA23_0 = input.LA(1);
2119
2120 if (((LA23_0 >= '\u0000' && LA23_0 <= '&') || (LA23_0 >= '(' && LA23_0 <= '\uFFFF'))) {
2121 alt23 = 1;
2122 }
2123
2124 switch (alt23) {
2125 case 1:
2126 // CTFLexer.g:158:47: CHAR_CONTENT
2127 {
2128 mCHAR_CONTENT();
2129
2130 }
2131 break;
2132
2133 default:
2134 if (cnt23 >= 1) {
2135 break loop23;
2136 }
2137 EarlyExitException eee = new EarlyExitException(23,
2138 input);
2139 throw eee;
2140 }
2141 cnt23++;
2142 } while (true);
2143
2144 mSINGLEQUOTE();
2145
2146 }
2147
2148 state.type = _type;
2149 state.channel = _channel;
2150 } finally {
2151 }
2152 }
2153
2154 // $ANTLR end "CHARACTER_LITERAL"
2155
2156 // $ANTLR start "CHAR_CONTENT"
2157 public final void mCHAR_CONTENT() throws RecognitionException {
2158 try {
2159 // CTFLexer.g:159:23: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
2160 // SINGLEQUOTE ) ) )
2161 // CTFLexer.g:159:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
2162 // SINGLEQUOTE ) )
2163 {
2164 // CTFLexer.g:159:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
2165 // SINGLEQUOTE ) )
2166 int alt24 = 2;
2167 int LA24_0 = input.LA(1);
2168
2169 if ((LA24_0 == '\\')) {
2170 alt24 = 1;
2171 } else if (((LA24_0 >= '\u0000' && LA24_0 <= '&')
2172 || (LA24_0 >= '(' && LA24_0 <= '[') || (LA24_0 >= ']' && LA24_0 <= '\uFFFF'))) {
2173 alt24 = 2;
2174 } else {
2175 NoViableAltException nvae = new NoViableAltException("",
2176 24, 0, input);
2177
2178 throw nvae;
2179 }
2180 switch (alt24) {
2181 case 1:
2182 // CTFLexer.g:159:26: ESCAPE_SEQUENCE
2183 {
2184 mESCAPE_SEQUENCE();
2185
2186 }
2187 break;
2188 case 2:
2189 // CTFLexer.g:159:44: ~ ( BACKSLASH | SINGLEQUOTE )
2190 {
2191 if ((input.LA(1) >= '\u0000' && input.LA(1) <= '&')
2192 || (input.LA(1) >= '(' && input.LA(1) <= '[')
2193 || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF')) {
2194 input.consume();
2195
2196 } else {
2197 MismatchedSetException mse = new MismatchedSetException(
2198 null, input);
2199 recover(mse);
2200 throw mse;
2201 }
2202
2203 }
2204 break;
2205
2206 }
2207
2208 }
2209
2210 } finally {
2211 }
2212 }
2213
2214 // $ANTLR end "CHAR_CONTENT"
2215
2216 // $ANTLR start "SINGLEQUOTE"
2217 public final void mSINGLEQUOTE() throws RecognitionException {
2218 try {
2219 // CTFLexer.g:160:22: ( '\\'' )
2220 // CTFLexer.g:160:24: '\\''
2221 {
2222 match('\'');
2223
2224 }
2225
2226 } finally {
2227 }
2228 }
2229
2230 // $ANTLR end "SINGLEQUOTE"
2231
2232 // $ANTLR start "STRING_LITERAL"
2233 public final void mSTRING_LITERAL() throws RecognitionException {
2234 try {
2235 int _type = STRING_LITERAL;
2236 int _channel = DEFAULT_TOKEN_CHANNEL;
2237 // CTFLexer.g:165:16: ( ( STRINGPREFIX )? DOUBLEQUOTE (
2238 // STRING_CONTENT )* DOUBLEQUOTE )
2239 // CTFLexer.g:165:18: ( STRINGPREFIX )? DOUBLEQUOTE ( STRING_CONTENT
2240 // )* DOUBLEQUOTE
2241 {
2242 // CTFLexer.g:165:18: ( STRINGPREFIX )?
2243 int alt25 = 2;
2244 int LA25_0 = input.LA(1);
2245
2246 if ((LA25_0 == 'L')) {
2247 alt25 = 1;
2248 }
2249 switch (alt25) {
2250 case 1:
2251 // CTFLexer.g:165:18: STRINGPREFIX
2252 {
2253 mSTRINGPREFIX();
2254
2255 }
2256 break;
2257
2258 }
2259
2260 mDOUBLEQUOTE();
2261 // CTFLexer.g:165:44: ( STRING_CONTENT )*
2262 loop26: do {
2263 int alt26 = 2;
2264 int LA26_0 = input.LA(1);
2265
2266 if (((LA26_0 >= '\u0000' && LA26_0 <= '!') || (LA26_0 >= '#' && LA26_0 <= '\uFFFF'))) {
2267 alt26 = 1;
2268 }
2269
2270 switch (alt26) {
2271 case 1:
2272 // CTFLexer.g:165:44: STRING_CONTENT
2273 {
2274 mSTRING_CONTENT();
2275
2276 }
2277 break;
2278
2279 default:
2280 break loop26;
2281 }
2282 } while (true);
2283
2284 mDOUBLEQUOTE();
2285
2286 }
2287
2288 state.type = _type;
2289 state.channel = _channel;
2290 } finally {
2291 }
2292 }
2293
2294 // $ANTLR end "STRING_LITERAL"
2295
2296 // $ANTLR start "STRING_CONTENT"
2297 public final void mSTRING_CONTENT() throws RecognitionException {
2298 try {
2299 // CTFLexer.g:166:25: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
2300 // DOUBLEQUOTE ) ) )
2301 // CTFLexer.g:166:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
2302 // DOUBLEQUOTE ) )
2303 {
2304 // CTFLexer.g:166:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
2305 // DOUBLEQUOTE ) )
2306 int alt27 = 2;
2307 int LA27_0 = input.LA(1);
2308
2309 if ((LA27_0 == '\\')) {
2310 alt27 = 1;
2311 } else if (((LA27_0 >= '\u0000' && LA27_0 <= '!')
2312 || (LA27_0 >= '#' && LA27_0 <= '[') || (LA27_0 >= ']' && LA27_0 <= '\uFFFF'))) {
2313 alt27 = 2;
2314 } else {
2315 NoViableAltException nvae = new NoViableAltException("",
2316 27, 0, input);
2317
2318 throw nvae;
2319 }
2320 switch (alt27) {
2321 case 1:
2322 // CTFLexer.g:166:28: ESCAPE_SEQUENCE
2323 {
2324 mESCAPE_SEQUENCE();
2325
2326 }
2327 break;
2328 case 2:
2329 // CTFLexer.g:166:46: ~ ( BACKSLASH | DOUBLEQUOTE )
2330 {
2331 if ((input.LA(1) >= '\u0000' && input.LA(1) <= '!')
2332 || (input.LA(1) >= '#' && input.LA(1) <= '[')
2333 || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF')) {
2334 input.consume();
2335
2336 } else {
2337 MismatchedSetException mse = new MismatchedSetException(
2338 null, input);
2339 recover(mse);
2340 throw mse;
2341 }
2342
2343 }
2344 break;
2345
2346 }
2347
2348 }
2349
2350 } finally {
2351 }
2352 }
2353
2354 // $ANTLR end "STRING_CONTENT"
2355
2356 // $ANTLR start "DOUBLEQUOTE"
2357 public final void mDOUBLEQUOTE() throws RecognitionException {
2358 try {
2359 // CTFLexer.g:167:22: ( '\"' )
2360 // CTFLexer.g:167:24: '\"'
2361 {
2362 match('\"');
2363
2364 }
2365
2366 } finally {
2367 }
2368 }
2369
2370 // $ANTLR end "DOUBLEQUOTE"
2371
2372 // $ANTLR start "WS"
2373 public final void mWS() throws RecognitionException {
2374 try {
2375 int _type = WS;
2376 int _channel = DEFAULT_TOKEN_CHANNEL;
2377 // CTFLexer.g:172:4: ( ( ' ' | '\\r' | '\\t' | '\ ' | '\\n' ) )
2378 // CTFLexer.g:172:6: ( ' ' | '\\r' | '\\t' | '\ ' | '\\n' )
2379 {
2380 if ((input.LA(1) >= '\t' && input.LA(1) <= '\n')
2381 || (input.LA(1) >= '\f' && input.LA(1) <= '\r')
2382 || input.LA(1) == ' ') {
2383 input.consume();
2384
2385 } else {
2386 MismatchedSetException mse = new MismatchedSetException(
2387 null, input);
2388 recover(mse);
2389 throw mse;
2390 }
2391
2392 _channel = HIDDEN;
2393
2394 }
2395
2396 state.type = _type;
2397 state.channel = _channel;
2398 } finally {
2399 }
2400 }
2401
2402 // $ANTLR end "WS"
2403
2404 // $ANTLR start "COMMENT"
2405 public final void mCOMMENT() throws RecognitionException {
2406 try {
2407 int _type = COMMENT;
2408 int _channel = DEFAULT_TOKEN_CHANNEL;
2409 // CTFLexer.g:179:9: ( COMMENT_OPEN ( . )* COMMENT_CLOSE )
2410 // CTFLexer.g:179:11: COMMENT_OPEN ( . )* COMMENT_CLOSE
2411 {
2412 mCOMMENT_OPEN();
2413 // CTFLexer.g:179:24: ( . )*
2414 loop28: do {
2415 int alt28 = 2;
2416 int LA28_0 = input.LA(1);
2417
2418 if ((LA28_0 == '*')) {
2419 int LA28_1 = input.LA(2);
2420
2421 if ((LA28_1 == '/')) {
2422 alt28 = 2;
2423 } else if (((LA28_1 >= '\u0000' && LA28_1 <= '.') || (LA28_1 >= '0' && LA28_1 <= '\uFFFF'))) {
2424 alt28 = 1;
2425 }
2426
2427 } else if (((LA28_0 >= '\u0000' && LA28_0 <= ')') || (LA28_0 >= '+' && LA28_0 <= '\uFFFF'))) {
2428 alt28 = 1;
2429 }
2430
2431 switch (alt28) {
2432 case 1:
2433 // CTFLexer.g:179:24: .
2434 {
2435 matchAny();
2436
2437 }
2438 break;
2439
2440 default:
2441 break loop28;
2442 }
2443 } while (true);
2444
2445 mCOMMENT_CLOSE();
2446 _channel = HIDDEN;
2447
2448 }
2449
2450 state.type = _type;
2451 state.channel = _channel;
2452 } finally {
2453 }
2454 }
2455
2456 // $ANTLR end "COMMENT"
2457
2458 // $ANTLR start "COMMENT_OPEN"
2459 public final void mCOMMENT_OPEN() throws RecognitionException {
2460 try {
2461 // CTFLexer.g:180:23: ( '/*' )
2462 // CTFLexer.g:180:25: '/*'
2463 {
2464 match("/*");
2465
2466 }
2467
2468 } finally {
2469 }
2470 }
2471
2472 // $ANTLR end "COMMENT_OPEN"
2473
2474 // $ANTLR start "COMMENT_CLOSE"
2475 public final void mCOMMENT_CLOSE() throws RecognitionException {
2476 try {
2477 // CTFLexer.g:181:24: ( '*/' )
2478 // CTFLexer.g:181:26: '*/'
2479 {
2480 match("*/");
2481
2482 }
2483
2484 } finally {
2485 }
2486 }
2487
2488 // $ANTLR end "COMMENT_CLOSE"
2489
2490 // $ANTLR start "LINE_COMMENT"
2491 public final void mLINE_COMMENT() throws RecognitionException {
2492 try {
2493 int _type = LINE_COMMENT;
2494 int _channel = DEFAULT_TOKEN_CHANNEL;
2495 // CTFLexer.g:186:14: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )?
2496 // '\\n' )
2497 // CTFLexer.g:186:16: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
2498 {
2499 match("//");
2500
2501 // CTFLexer.g:186:21: (~ ( '\\n' | '\\r' ) )*
2502 loop29: do {
2503 int alt29 = 2;
2504 int LA29_0 = input.LA(1);
2505
2506 if (((LA29_0 >= '\u0000' && LA29_0 <= '\t')
2507 || (LA29_0 >= '\u000B' && LA29_0 <= '\f') || (LA29_0 >= '\u000E' && LA29_0 <= '\uFFFF'))) {
2508 alt29 = 1;
2509 }
2510
2511 switch (alt29) {
2512 case 1:
2513 // CTFLexer.g:186:21: ~ ( '\\n' | '\\r' )
2514 {
2515 if ((input.LA(1) >= '\u0000' && input.LA(1) <= '\t')
2516 || (input.LA(1) >= '\u000B' && input.LA(1) <= '\f')
2517 || (input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF')) {
2518 input.consume();
2519
2520 } else {
2521 MismatchedSetException mse = new MismatchedSetException(
2522 null, input);
2523 recover(mse);
2524 throw mse;
2525 }
2526
2527 }
2528 break;
2529
2530 default:
2531 break loop29;
2532 }
2533 } while (true);
2534
2535 // CTFLexer.g:186:35: ( '\\r' )?
2536 int alt30 = 2;
2537 int LA30_0 = input.LA(1);
2538
2539 if ((LA30_0 == '\r')) {
2540 alt30 = 1;
2541 }
2542 switch (alt30) {
2543 case 1:
2544 // CTFLexer.g:186:35: '\\r'
2545 {
2546 match('\r');
2547
2548 }
2549 break;
2550
2551 }
2552
2553 match('\n');
2554 _channel = HIDDEN;
2555
2556 }
2557
2558 state.type = _type;
2559 state.channel = _channel;
2560 } finally {
2561 }
2562 }
2563
2564 // $ANTLR end "LINE_COMMENT"
2565
2566 // $ANTLR start "IDENTIFIER"
2567 public final void mIDENTIFIER() throws RecognitionException {
2568 try {
2569 int _type = IDENTIFIER;
2570 int _channel = DEFAULT_TOKEN_CHANNEL;
2571 // CTFLexer.g:191:12: ( NONDIGIT ( NONDIGIT | DIGIT )* )
2572 // CTFLexer.g:191:14: NONDIGIT ( NONDIGIT | DIGIT )*
2573 {
2574 mNONDIGIT();
2575 // CTFLexer.g:191:23: ( NONDIGIT | DIGIT )*
2576 loop31: do {
2577 int alt31 = 3;
2578 int LA31_0 = input.LA(1);
2579
2580 if (((LA31_0 >= 'A' && LA31_0 <= 'Z') || LA31_0 == '_' || (LA31_0 >= 'a' && LA31_0 <= 'z'))) {
2581 alt31 = 1;
2582 } else if (((LA31_0 >= '0' && LA31_0 <= '9'))) {
2583 alt31 = 2;
2584 }
2585
2586 switch (alt31) {
2587 case 1:
2588 // CTFLexer.g:191:24: NONDIGIT
2589 {
2590 mNONDIGIT();
2591
2592 }
2593 break;
2594 case 2:
2595 // CTFLexer.g:191:35: DIGIT
2596 {
2597 mDIGIT();
2598
2599 }
2600 break;
2601
2602 default:
2603 break loop31;
2604 }
2605 } while (true);
2606
2607 }
2608
2609 state.type = _type;
2610 state.channel = _channel;
2611 } finally {
2612 }
2613 }
2614
2615 // $ANTLR end "IDENTIFIER"
2616
2617 // $ANTLR start "NONDIGIT"
2618 public final void mNONDIGIT() throws RecognitionException {
2619 try {
2620 // CTFLexer.g:192:19: ( ( '_' ) | ( 'A' .. 'Z' ) | ( 'a' .. 'z' ) )
2621 int alt32 = 3;
2622 switch (input.LA(1)) {
2623 case '_': {
2624 alt32 = 1;
2625 }
2626 break;
2627 case 'A':
2628 case 'B':
2629 case 'C':
2630 case 'D':
2631 case 'E':
2632 case 'F':
2633 case 'G':
2634 case 'H':
2635 case 'I':
2636 case 'J':
2637 case 'K':
2638 case 'L':
2639 case 'M':
2640 case 'N':
2641 case 'O':
2642 case 'P':
2643 case 'Q':
2644 case 'R':
2645 case 'S':
2646 case 'T':
2647 case 'U':
2648 case 'V':
2649 case 'W':
2650 case 'X':
2651 case 'Y':
2652 case 'Z': {
2653 alt32 = 2;
2654 }
2655 break;
2656 case 'a':
2657 case 'b':
2658 case 'c':
2659 case 'd':
2660 case 'e':
2661 case 'f':
2662 case 'g':
2663 case 'h':
2664 case 'i':
2665 case 'j':
2666 case 'k':
2667 case 'l':
2668 case 'm':
2669 case 'n':
2670 case 'o':
2671 case 'p':
2672 case 'q':
2673 case 'r':
2674 case 's':
2675 case 't':
2676 case 'u':
2677 case 'v':
2678 case 'w':
2679 case 'x':
2680 case 'y':
2681 case 'z': {
2682 alt32 = 3;
2683 }
2684 break;
2685 default:
2686 NoViableAltException nvae = new NoViableAltException("", 32, 0,
2687 input);
2688
2689 throw nvae;
2690 }
2691
2692 switch (alt32) {
2693 case 1:
2694 // CTFLexer.g:192:21: ( '_' )
2695 {
2696 // CTFLexer.g:192:21: ( '_' )
2697 // CTFLexer.g:192:22: '_'
2698 {
2699 match('_');
2700
2701 }
2702
2703 }
2704 break;
2705 case 2:
2706 // CTFLexer.g:192:29: ( 'A' .. 'Z' )
2707 {
2708 // CTFLexer.g:192:29: ( 'A' .. 'Z' )
2709 // CTFLexer.g:192:30: 'A' .. 'Z'
2710 {
2711 matchRange('A', 'Z');
2712
2713 }
2714
2715 }
2716 break;
2717 case 3:
2718 // CTFLexer.g:192:42: ( 'a' .. 'z' )
2719 {
2720 // CTFLexer.g:192:42: ( 'a' .. 'z' )
2721 // CTFLexer.g:192:43: 'a' .. 'z'
2722 {
2723 matchRange('a', 'z');
2724
2725 }
2726
2727 }
2728 break;
2729
2730 }
2731 } finally {
2732 }
2733 }
2734
2735 // $ANTLR end "NONDIGIT"
2736
2737 @Override
2738 public void mTokens() throws RecognitionException {
2739 // CTFLexer.g:1:8: ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK | ENUMTOK
2740 // | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK | INTTOK |
2741 // LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK | STRUCTTOK |
2742 // TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK | VARIANTTOK |
2743 // VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK | CLOCKTOK |
2744 // CALLSITETOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR |
2745 // COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC |
2746 // CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN |
2747 // ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL |
2748 // CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT |
2749 // IDENTIFIER )
2750 int alt33 = 58;
2751 alt33 = dfa33.predict(input);
2752 switch (alt33) {
2753 case 1:
2754 // CTFLexer.g:1:10: ALIGNTOK
2755 {
2756 mALIGNTOK();
2757
2758 }
2759 break;
2760 case 2:
2761 // CTFLexer.g:1:19: CONSTTOK
2762 {
2763 mCONSTTOK();
2764
2765 }
2766 break;
2767 case 3:
2768 // CTFLexer.g:1:28: CHARTOK
2769 {
2770 mCHARTOK();
2771
2772 }
2773 break;
2774 case 4:
2775 // CTFLexer.g:1:36: DOUBLETOK
2776 {
2777 mDOUBLETOK();
2778
2779 }
2780 break;
2781 case 5:
2782 // CTFLexer.g:1:46: ENUMTOK
2783 {
2784 mENUMTOK();
2785
2786 }
2787 break;
2788 case 6:
2789 // CTFLexer.g:1:54: EVENTTOK
2790 {
2791 mEVENTTOK();
2792
2793 }
2794 break;
2795 case 7:
2796 // CTFLexer.g:1:63: FLOATINGPOINTTOK
2797 {
2798 mFLOATINGPOINTTOK();
2799
2800 }
2801 break;
2802 case 8:
2803 // CTFLexer.g:1:80: FLOATTOK
2804 {
2805 mFLOATTOK();
2806
2807 }
2808 break;
2809 case 9:
2810 // CTFLexer.g:1:89: INTEGERTOK
2811 {
2812 mINTEGERTOK();
2813
2814 }
2815 break;
2816 case 10:
2817 // CTFLexer.g:1:100: INTTOK
2818 {
2819 mINTTOK();
2820
2821 }
2822 break;
2823 case 11:
2824 // CTFLexer.g:1:107: LONGTOK
2825 {
2826 mLONGTOK();
2827
2828 }
2829 break;
2830 case 12:
2831 // CTFLexer.g:1:115: SHORTTOK
2832 {
2833 mSHORTTOK();
2834
2835 }
2836 break;
2837 case 13:
2838 // CTFLexer.g:1:124: SIGNEDTOK
2839 {
2840 mSIGNEDTOK();
2841
2842 }
2843 break;
2844 case 14:
2845 // CTFLexer.g:1:134: STREAMTOK
2846 {
2847 mSTREAMTOK();
2848
2849 }
2850 break;
2851 case 15:
2852 // CTFLexer.g:1:144: STRINGTOK
2853 {
2854 mSTRINGTOK();
2855
2856 }
2857 break;
2858 case 16:
2859 // CTFLexer.g:1:154: STRUCTTOK
2860 {
2861 mSTRUCTTOK();
2862
2863 }
2864 break;
2865 case 17:
2866 // CTFLexer.g:1:164: TRACETOK
2867 {
2868 mTRACETOK();
2869
2870 }
2871 break;
2872 case 18:
2873 // CTFLexer.g:1:173: TYPEALIASTOK
2874 {
2875 mTYPEALIASTOK();
2876
2877 }
2878 break;
2879 case 19:
2880 // CTFLexer.g:1:186: TYPEDEFTOK
2881 {
2882 mTYPEDEFTOK();
2883
2884 }
2885 break;
2886 case 20:
2887 // CTFLexer.g:1:197: UNSIGNEDTOK
2888 {
2889 mUNSIGNEDTOK();
2890
2891 }
2892 break;
2893 case 21:
2894 // CTFLexer.g:1:209: VARIANTTOK
2895 {
2896 mVARIANTTOK();
2897
2898 }
2899 break;
2900 case 22:
2901 // CTFLexer.g:1:220: VOIDTOK
2902 {
2903 mVOIDTOK();
2904
2905 }
2906 break;
2907 case 23:
2908 // CTFLexer.g:1:228: BOOLTOK
2909 {
2910 mBOOLTOK();
2911
2912 }
2913 break;
2914 case 24:
2915 // CTFLexer.g:1:236: COMPLEXTOK
2916 {
2917 mCOMPLEXTOK();
2918
2919 }
2920 break;
2921 case 25:
2922 // CTFLexer.g:1:247: IMAGINARYTOK
2923 {
2924 mIMAGINARYTOK();
2925
2926 }
2927 break;
2928 case 26:
2929 // CTFLexer.g:1:260: ENVTOK
2930 {
2931 mENVTOK();
2932
2933 }
2934 break;
2935 case 27:
2936 // CTFLexer.g:1:267: CLOCKTOK
2937 {
2938 mCLOCKTOK();
2939
2940 }
2941 break;
2942 case 28:
2943 // CTFLexer.g:1:276: CALLSITETOK
2944 {
2945 mCALLSITETOK();
2946
2947 }
2948 break;
2949 case 29:
2950 // CTFLexer.g:1:288: NANNUMBERTOK
2951 {
2952 mNANNUMBERTOK();
2953
2954 }
2955 break;
2956 case 30:
2957 // CTFLexer.g:1:301: INFINITYTOK
2958 {
2959 mINFINITYTOK();
2960
2961 }
2962 break;
2963 case 31:
2964 // CTFLexer.g:1:313: NINFINITYTOK
2965 {
2966 mNINFINITYTOK();
2967
2968 }
2969 break;
2970 case 32:
2971 // CTFLexer.g:1:326: SEPARATOR
2972 {
2973 mSEPARATOR();
2974
2975 }
2976 break;
2977 case 33:
2978 // CTFLexer.g:1:336: COLON
2979 {
2980 mCOLON();
2981
2982 }
2983 break;
2984 case 34:
2985 // CTFLexer.g:1:342: ELIPSES
2986 {
2987 mELIPSES();
2988
2989 }
2990 break;
2991 case 35:
2992 // CTFLexer.g:1:350: ASSIGNMENT
2993 {
2994 mASSIGNMENT();
2995
2996 }
2997 break;
2998 case 36:
2999 // CTFLexer.g:1:361: TYPE_ASSIGNMENT
3000 {
3001 mTYPE_ASSIGNMENT();
3002
3003 }
3004 break;
3005 case 37:
3006 // CTFLexer.g:1:377: LT
3007 {
3008 mLT();
3009
3010 }
3011 break;
3012 case 38:
3013 // CTFLexer.g:1:380: GT
3014 {
3015 mGT();
3016
3017 }
3018 break;
3019 case 39:
3020 // CTFLexer.g:1:383: OPENBRAC
3021 {
3022 mOPENBRAC();
3023
3024 }
3025 break;
3026 case 40:
3027 // CTFLexer.g:1:392: CLOSEBRAC
3028 {
3029 mCLOSEBRAC();
3030
3031 }
3032 break;
3033 case 41:
3034 // CTFLexer.g:1:402: LPAREN
3035 {
3036 mLPAREN();
3037
3038 }
3039 break;
3040 case 42:
3041 // CTFLexer.g:1:409: RPAREN
3042 {
3043 mRPAREN();
3044
3045 }
3046 break;
3047 case 43:
3048 // CTFLexer.g:1:416: LCURL
3049 {
3050 mLCURL();
3051
3052 }
3053 break;
3054 case 44:
3055 // CTFLexer.g:1:422: RCURL
3056 {
3057 mRCURL();
3058
3059 }
3060 break;
3061 case 45:
3062 // CTFLexer.g:1:428: TERM
3063 {
3064 mTERM();
3065
3066 }
3067 break;
3068 case 46:
3069 // CTFLexer.g:1:433: POINTER
3070 {
3071 mPOINTER();
3072
3073 }
3074 break;
3075 case 47:
3076 // CTFLexer.g:1:441: SIGN
3077 {
3078 mSIGN();
3079
3080 }
3081 break;
3082 case 48:
3083 // CTFLexer.g:1:446: ARROW
3084 {
3085 mARROW();
3086
3087 }
3088 break;
3089 case 49:
3090 // CTFLexer.g:1:452: DOT
3091 {
3092 mDOT();
3093
3094 }
3095 break;
3096 case 50:
3097 // CTFLexer.g:1:456: OCTAL_LITERAL
3098 {
3099 mOCTAL_LITERAL();
3100
3101 }
3102 break;
3103 case 51:
3104 // CTFLexer.g:1:470: DECIMAL_LITERAL
3105 {
3106 mDECIMAL_LITERAL();
3107
3108 }
3109 break;
3110 case 52:
3111 // CTFLexer.g:1:486: HEX_LITERAL
3112 {
3113 mHEX_LITERAL();
3114
3115 }
3116 break;
3117 case 53:
3118 // CTFLexer.g:1:498: CHARACTER_LITERAL
3119 {
3120 mCHARACTER_LITERAL();
3121
3122 }
3123 break;
3124 case 54:
3125 // CTFLexer.g:1:516: STRING_LITERAL
3126 {
3127 mSTRING_LITERAL();
3128
3129 }
3130 break;
3131 case 55:
3132 // CTFLexer.g:1:531: WS
3133 {
3134 mWS();
3135
3136 }
3137 break;
3138 case 56:
3139 // CTFLexer.g:1:534: COMMENT
3140 {
3141 mCOMMENT();
3142
3143 }
3144 break;
3145 case 57:
3146 // CTFLexer.g:1:542: LINE_COMMENT
3147 {
3148 mLINE_COMMENT();
3149
3150 }
3151 break;
3152 case 58:
3153 // CTFLexer.g:1:555: IDENTIFIER
3154 {
3155 mIDENTIFIER();
3156
3157 }
3158 break;
3159
3160 }
3161
3162 }
3163
3164 protected DFA17 dfa17 = new DFA17(this);
3165 protected DFA33 dfa33 = new DFA33(this);
3166 static final String DFA17_eotS = "\1\uffff\2\6\1\11\1\6\2\uffff\1\6\2\uffff";
3167 static final String DFA17_eofS = "\12\uffff";
3168 static final String DFA17_minS = "\1\114\1\125\2\114\1\125\2\uffff\1\125\2\uffff";
3169 static final String DFA17_maxS = "\3\165\1\154\1\165\2\uffff\1\165\2\uffff";
3170 static final String DFA17_acceptS = "\5\uffff\1\4\1\1\1\uffff\1\3\1\2";
3171 static final String DFA17_specialS = "\12\uffff}>";
3172 static final String[] DFA17_transitionS = {
3173 "\1\2\10\uffff\1\3\26\uffff\1\1\10\uffff\1\3",
3174 "\1\5\26\uffff\1\4\10\uffff\1\5", "\1\7\10\uffff\1\5\37\uffff\1\5",
3175 "\1\10\37\uffff\1\10", "\1\5\37\uffff\1\5", "", "",
3176 "\1\5\37\uffff\1\5", "", "" };
3177
3178 static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
3179 static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
3180 static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
3181 static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
3182 static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
3183 static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
3184 static final short[][] DFA17_transition;
3185
3186 static {
3187 int numStates = DFA17_transitionS.length;
3188 DFA17_transition = new short[numStates][];
3189 for (int i = 0; i < numStates; i++) {
3190 DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
3191 }
3192 }
3193
3194 class DFA17 extends DFA {
3195
3196 public DFA17(BaseRecognizer recognizer) {
3197 this.recognizer = recognizer;
3198 this.decisionNumber = 17;
3199 this.eot = DFA17_eot;
3200 this.eof = DFA17_eof;
3201 this.min = DFA17_min;
3202 this.max = DFA17_max;
3203 this.accept = DFA17_accept;
3204 this.special = DFA17_special;
3205 this.transition = DFA17_transition;
3206 }
3207
3208 @Override
3209 public String getDescription() {
3210 return "107:10: fragment INTEGER_TYPES_SUFFIX : ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'u' | 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) );";
3211 }
3212 }
3213
3214 static final String DFA33_eotS = "\1\uffff\15\45\2\76\1\uffff\1\102\1\104\13\uffff\1\37\1\uffff\1"
3215 + "\45\5\uffff\27\45\11\uffff\1\144\2\uffff\7\45\1\154\2\45\1\160\14"
3216 + "\45\1\177\3\144\1\uffff\2\45\1\u0087\3\45\1\u008b\1\uffff\3\45\1"
3217 + "\uffff\1\u008f\11\45\1\u009a\3\45\1\uffff\1\144\1\uffff\3\144\1"
3218 + "\u00a0\1\u00a1\1\uffff\1\u00a2\2\45\1\uffff\1\u00a5\1\u00a7\1\45"
3219 + "\1\uffff\1\u00a9\4\45\1\u00ae\4\45\1\uffff\1\u00b3\2\45\5\uffff"
3220 + "\1\45\1\u00b7\1\uffff\1\45\1\uffff\1\45\1\uffff\1\u00ba\1\u00bb"
3221 + "\1\u00bc\1\u00bd\1\uffff\4\45\1\uffff\3\45\1\uffff\1\45\1\u00c6"
3222 + "\4\uffff\1\45\1\u00c8\1\45\1\u00ca\2\45\1\u00cd\1\45\1\uffff\1\45"
3223 + "\1\uffff\1\u00d0\1\uffff\1\u00d1\1\45\1\uffff\1\45\1\u00d4\2\uffff"
3224 + "\2\45\1\uffff\1\u00d7\1\45\1\uffff\2\45\1\u00db\1\uffff";
3225 static final String DFA33_eofS = "\u00dc\uffff";
3226 static final String DFA33_minS = "\1\11\1\154\1\141\1\157\1\156\1\154\1\156\1\157\1\150\1\162\1\156"
3227 + "\1\141\1\102\1\141\1\151\1\76\1\uffff\1\75\1\56\13\uffff\1\60\1"
3228 + "\uffff\1\42\3\uffff\1\52\1\uffff\1\151\1\156\1\141\1\157\1\154\2"
3229 + "\165\1\145\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163"
3230 + "\1\162\1\151\2\157\1\155\1\116\11\uffff\1\60\2\uffff\1\147\1\163"
3231 + "\1\162\1\143\1\154\1\142\1\155\1\60\1\156\1\141\1\60\1\147\1\162"
3232 + "\1\156\1\145\1\143\1\145\2\151\1\144\1\157\1\155\1\141\1\60\1\125"
3233 + "\2\114\1\uffff\1\156\1\164\1\60\1\153\1\163\1\154\1\60\1\uffff\2"
3234 + "\164\1\147\1\uffff\1\60\1\164\1\145\1\141\1\156\1\143\1\145\1\141"
3235 + "\1\147\1\141\1\60\1\154\1\160\1\147\1\uffff\1\125\1\uffff\1\125"
3236 + "\1\154\1\114\2\60\1\uffff\1\60\1\151\1\145\1\uffff\2\60\1\145\1"
3237 + "\uffff\1\60\1\144\1\155\1\147\1\164\1\60\1\154\1\145\2\156\1\uffff"
3238 + "\1\60\1\154\1\151\5\uffff\1\164\1\60\1\uffff\1\156\1\uffff\1\162"
3239 + "\1\uffff\4\60\1\uffff\1\151\1\146\1\145\1\164\1\uffff\1\145\1\156"
3240 + "\1\145\1\uffff\1\147\1\60\4\uffff\1\141\1\60\1\144\1\60\1\170\1"
3241 + "\141\1\60\1\137\1\uffff\1\163\1\uffff\1\60\1\uffff\1\60\1\162\1"
3242 + "\uffff\1\160\1\60\2\uffff\1\171\1\157\1\uffff\1\60\1\151\1\uffff"
3243 + "\1\156\1\164\1\60\1\uffff";
3244 static final String DFA33_maxS = "\1\175\1\154\2\157\1\166\1\154\1\156\1\157\1\164\1\171\1\156\1\157"
3245 + "\1\111\1\141\2\151\1\uffff\1\75\1\56\13\uffff\1\170\1\uffff\1\47"
3246 + "\3\uffff\1\57\1\uffff\1\151\1\156\1\141\1\157\1\154\1\165\1\166"
3247 + "\1\145\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163\1\162"
3248 + "\1\151\2\157\1\155\1\116\11\uffff\1\165\2\uffff\1\147\1\163\1\162"
3249 + "\1\143\1\154\1\142\1\155\1\172\1\156\1\141\1\172\1\147\1\162\1\156"
3250 + "\1\165\1\143\1\145\2\151\1\144\1\157\1\155\1\141\1\172\2\165\1\154"
3251 + "\1\uffff\1\156\1\164\1\172\1\153\1\163\1\154\1\172\1\uffff\2\164"
3252 + "\1\147\1\uffff\1\172\1\164\1\145\1\141\1\156\1\143\1\145\1\144\1"
3253 + "\147\1\141\1\172\1\154\1\160\1\147\1\uffff\1\165\1\uffff\1\165\1"
3254 + "\154\1\114\2\172\1\uffff\1\172\1\151\1\145\1\uffff\2\172\1\145\1"
3255 + "\uffff\1\172\1\144\1\155\1\147\1\164\1\172\1\154\1\145\2\156\1\uffff"
3256 + "\1\172\1\154\1\151\5\uffff\1\164\1\172\1\uffff\1\156\1\uffff\1\162"
3257 + "\1\uffff\4\172\1\uffff\1\151\1\146\1\145\1\164\1\uffff\1\145\1\156"
3258 + "\1\145\1\uffff\1\147\1\172\4\uffff\1\141\1\172\1\144\1\172\1\170"
3259 + "\1\141\1\172\1\137\1\uffff\1\163\1\uffff\1\172\1\uffff\1\172\1\162"
3260 + "\1\uffff\1\160\1\172\2\uffff\1\171\1\157\1\uffff\1\172\1\151\1\uffff"
3261 + "\1\156\1\164\1\172\1\uffff";
3262 static final String DFA33_acceptS = "\20\uffff\1\40\2\uffff\1\43\1\45\1\46\1\47\1\50\1\51\1\52\1\53\1"
3263 + "\54\1\55\1\56\1\uffff\1\63\1\uffff\1\65\1\66\1\67\1\uffff\1\72\27"
3264 + "\uffff\1\36\1\57\1\37\1\60\1\44\1\41\1\42\1\61\1\64\1\uffff\1\70"
3265 + "\1\71\33\uffff\1\62\7\uffff\1\32\3\uffff\1\12\16\uffff\1\35\1\uffff"
3266 + "\1\62\5\uffff\1\3\3\uffff\1\5\3\uffff\1\13\12\uffff\1\26\3\uffff"
3267 + "\2\62\1\1\1\2\1\33\2\uffff\1\6\1\uffff\1\10\1\uffff\1\14\4\uffff"
3268 + "\1\21\4\uffff\1\27\3\uffff\1\4\2\uffff\1\15\1\16\1\17\1\20\10\uffff"
3269 + "\1\11\1\uffff\1\23\1\uffff\1\25\2\uffff\1\34\2\uffff\1\24\1\30\2"
3270 + "\uffff\1\22\2\uffff\1\31\3\uffff\1\7";
3271 static final String DFA33_specialS = "\u00dc\uffff}>";
3272 static final String[] DFA33_transitionS = {
3273 "\2\43\1\uffff\2\43\22\uffff\1\43\1\uffff\1\42\4\uffff\1\41\1"
3274 + "\30\1\31\1\35\1\16\1\20\1\17\1\22\1\44\1\36\11\37\1\21\1\34"
3275 + "\1\24\1\23\1\25\2\uffff\13\45\1\40\1\45\1\15\14\45\1\26\1\uffff"
3276 + "\1\27\1\uffff\1\14\1\uffff\1\1\1\45\1\2\1\3\1\4\1\5\2\45\1\6"
3277 + "\2\45\1\7\6\45\1\10\1\11\1\12\1\13\4\45\1\32\1\uffff\1\33",
3278 "\1\46",
3279 "\1\52\6\uffff\1\50\3\uffff\1\51\2\uffff\1\47",
3280 "\1\53",
3281 "\1\54\7\uffff\1\55",
3282 "\1\56",
3283 "\1\57",
3284 "\1\60",
3285 "\1\61\1\62\12\uffff\1\63",
3286 "\1\64\6\uffff\1\65",
3287 "\1\66",
3288 "\1\67\15\uffff\1\70",
3289 "\1\71\1\72\5\uffff\1\73",
3290 "\1\74",
3291 "\1\75",
3292 "\1\100\52\uffff\1\77",
3293 "",
3294 "\1\101",
3295 "\1\103",
3296 "",
3297 "",
3298 "",
3299 "",
3300 "",
3301 "",
3302 "",
3303 "",
3304 "",
3305 "",
3306 "",
3307 "\10\106\40\uffff\1\105\37\uffff\1\105",
3308 "",
3309 "\1\42\4\uffff\1\41",
3310 "",
3311 "",
3312 "",
3313 "\1\107\4\uffff\1\110",
3314 "",
3315 "\1\111",
3316 "\1\112",
3317 "\1\113",
3318 "\1\114",
3319 "\1\115",
3320 "\1\116",
3321 "\1\117\1\120",
3322 "\1\121",
3323 "\1\122",
3324 "\1\123",
3325 "\1\124",
3326 "\1\125",
3327 "\1\126",
3328 "\1\127",
3329 "\1\130",
3330 "\1\131",
3331 "\1\132",
3332 "\1\133",
3333 "\1\134",
3334 "\1\135",
3335 "\1\136",
3336 "\1\137",
3337 "\1\140",
3338 "",
3339 "",
3340 "",
3341 "",
3342 "",
3343 "",
3344 "",
3345 "",
3346 "",
3347 "\10\106\2\37\22\uffff\1\142\10\uffff\1\143\26\uffff\1\141\10"
3348 + "\uffff\1\143",
3349 "",
3350 "",
3351 "\1\145",
3352 "\1\146",
3353 "\1\147",
3354 "\1\150",
3355 "\1\151",
3356 "\1\152",
3357 "\1\153",
3358 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3359 "\1\155",
3360 "\1\156",
3361 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\4\45\1\157\25\45",
3362 "\1\161",
3363 "\1\162",
3364 "\1\163",
3365 "\1\164\3\uffff\1\165\13\uffff\1\166",
3366 "\1\167",
3367 "\1\170",
3368 "\1\171",
3369 "\1\172",
3370 "\1\173",
3371 "\1\174",
3372 "\1\175",
3373 "\1\176",
3374 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3375 "\1\u0081\26\uffff\1\u0080\10\uffff\1\u0081",
3376 "\1\u0082\10\uffff\1\u0081\37\uffff\1\u0081",
3377 "\1\u0084\37\uffff\1\u0083",
3378 "",
3379 "\1\u0085",
3380 "\1\u0086",
3381 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3382 "\1\u0088",
3383 "\1\u0089",
3384 "\1\u008a",
3385 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3386 "",
3387 "\1\u008c",
3388 "\1\u008d",
3389 "\1\u008e",
3390 "",
3391 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3392 "\1\u0090",
3393 "\1\u0091",
3394 "\1\u0092",
3395 "\1\u0093",
3396 "\1\u0094",
3397 "\1\u0095",
3398 "\1\u0096\2\uffff\1\u0097",
3399 "\1\u0098",
3400 "\1\u0099",
3401 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3402 "\1\u009b",
3403 "\1\u009c",
3404 "\1\u009d",
3405 "",
3406 "\1\u0081\37\uffff\1\u0081",
3407 "",
3408 "\1\u0081\37\uffff\1\u0081",
3409 "\1\u009e",
3410 "\1\u009f",
3411 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3412 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3413 "",
3414 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3415 "\1\u00a3",
3416 "\1\u00a4",
3417 "",
3418 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3419 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\10\45\1\u00a6\21"
3420 + "\45", "\1\u00a8", "",
3421 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00aa",
3422 "\1\u00ab", "\1\u00ac", "\1\u00ad",
3423 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00af",
3424 "\1\u00b0", "\1\u00b1", "\1\u00b2", "",
3425 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00b4",
3426 "\1\u00b5", "", "", "", "", "", "\1\u00b6",
3427 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00b8",
3428 "", "\1\u00b9", "",
3429 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3430 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3431 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3432 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00be",
3433 "\1\u00bf", "\1\u00c0", "\1\u00c1", "", "\1\u00c2", "\1\u00c3",
3434 "\1\u00c4", "", "\1\u00c5",
3435 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "", "", "",
3436 "\1\u00c7", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3437 "\1\u00c9", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3438 "\1\u00cb", "\1\u00cc",
3439 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00ce", "",
3440 "\1\u00cf", "", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3441 "", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00d2",
3442 "", "\1\u00d3", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
3443 "", "", "\1\u00d5", "\1\u00d6", "",
3444 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00d8", "",
3445 "\1\u00d9", "\1\u00da",
3446 "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "" };
3447
3448 static final short[] DFA33_eot = DFA.unpackEncodedString(DFA33_eotS);
3449 static final short[] DFA33_eof = DFA.unpackEncodedString(DFA33_eofS);
3450 static final char[] DFA33_min = DFA.unpackEncodedStringToUnsignedChars(DFA33_minS);
3451 static final char[] DFA33_max = DFA.unpackEncodedStringToUnsignedChars(DFA33_maxS);
3452 static final short[] DFA33_accept = DFA.unpackEncodedString(DFA33_acceptS);
3453 static final short[] DFA33_special = DFA.unpackEncodedString(DFA33_specialS);
3454 static final short[][] DFA33_transition;
3455
3456 static {
3457 int numStates = DFA33_transitionS.length;
3458 DFA33_transition = new short[numStates][];
3459 for (int i = 0; i < numStates; i++) {
3460 DFA33_transition[i] = DFA.unpackEncodedString(DFA33_transitionS[i]);
3461 }
3462 }
3463
3464 class DFA33 extends DFA {
3465
3466 public DFA33(BaseRecognizer recognizer) {
3467 this.recognizer = recognizer;
3468 this.decisionNumber = 33;
3469 this.eot = DFA33_eot;
3470 this.eof = DFA33_eof;
3471 this.min = DFA33_min;
3472 this.max = DFA33_max;
3473 this.accept = DFA33_accept;
3474 this.special = DFA33_special;
3475 this.transition = DFA33_transition;
3476 }
3477
3478 @Override
3479 public String getDescription() {
3480 return "1:1: Tokens : ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK | ENUMTOK | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK | STRUCTTOK | TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK | VARIANTTOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK | CLOCKTOK | CALLSITETOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR | COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC | CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN | ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT | IDENTIFIER );";
3481 }
3482 }
3483
3484 }
Tracecompass - Deliverables
This page took 0.137256 seconds and 5 git commands to generate.