~ubuntu-branches/ubuntu/saucy/eclipse-linuxtools/saucy-proposed
» Revision
5
: lttng/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFLexer.java
« back to all changes in this revision
Viewing changes to lttng/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFLexer.java
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Package Import Robot
- Author(s): Jakub Adam
- Date: 2013-05-21 11:41:41 UTC
- mfrom: (3.1.1 sid)
- Revision ID: package-import@ubuntu.com-20130521114141-91ys603bw8ypocqg
Tags: 1.2.1+dfsg-1
* Add d/get-orig-source.
* Removed leftover binaries, DFSG-incompatibly licensed and useless
files: .gitignore, a.out, *.libhover, glibc-2.14.xml from upstream
tarball (Closes: #708873).
* Add eclipse-rse into Build-Depends (Closes: #709268).
- Reflexes change in eclipse-cdt that doesn't depend on RSE anymore.
* Bump Standards-Version to 3.9.4.
* Removed leftover binaries, DFSG-incompatibly licensed and useless
files: .gitignore, a.out, *.libhover, glibc-2.14.xml from upstream
tarball (Closes: #708873).
* Add eclipse-rse into Build-Depends (Closes: #709268).
- Reflexes change in eclipse-cdt that doesn't depend on RSE anymore.
* Bump Standards-Version to 3.9.4.
- files added:
- debian/get-orig-source
- files removed:
- .gitignore
- libhover/org.eclipse.linuxtools.cdt.libhover.newlib/data
- lttng/org.eclipse.linuxtools.ctf.parser/src
- lttng/org.eclipse.linuxtools.ctf.parser/src/org
- lttng/org.eclipse.linuxtools.ctf.parser/src/org/eclipse
- lttng/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools
- lttng/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf
- lttng/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser
- files modified:
- debian/changelog
added
removed
lttng/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
}
b'\\ No newline at end of file'
Loggerhead is a web-based interface for Breezy
Version: 2.0.1