GlueGen: build/gensrc/java/com/jogamp/gluegen/cgram/StdCLexer.java Source File

GlueGen v2.6.0 GlueGen, Native Binding Generator for Java™ (public API).

StdCLexer.java
Go to the documentation of this file.
1// $ANTLR 2.7.7 (2006-11-01): "StdCParser.g" -> "StdCLexer.java"$
2
3 package com.jogamp.gluegen.cgram;
4
5 import java.io.*;
6
7 import antlr.CommonAST;
8 import antlr.DumpASTVisitor;
9
10import java.io.InputStream;
11import antlr.TokenStreamException;
12import antlr.TokenStreamIOException;
13import antlr.TokenStreamRecognitionException;
14import antlr.CharStreamException;
15import antlr.CharStreamIOException;
16import antlr.ANTLRException;
17import java.io.Reader;
18import java.util.Hashtable;
19import antlr.CharScanner;
20import antlr.InputBuffer;
21import antlr.ByteBuffer;
22import antlr.CharBuffer;
23import antlr.Token;
24import antlr.CommonToken;
25import antlr.RecognitionException;
26import antlr.NoViableAltForCharException;
27import antlr.MismatchedCharException;
28import antlr.TokenStream;
29import antlr.ANTLRHashString;
30import antlr.LexerSharedInputState;
31import antlr.collections.impl.BitSet;
32import antlr.SemanticException;
33
34 import java.io.*;
35 import antlr.*;
36
37 public class StdCLexer extends antlr.CharScanner implements STDCTokenTypes, TokenStream
38 {
39
40 LineObject lineObject = new LineObject();
41 String originalSource = "";
42 PreprocessorInfoChannel preprocessorInfoChannel = new PreprocessorInfoChannel();
43 int tokenNumber = 0;
44 boolean countingTokens = true;
45 int deferredLineCount = 0;
46
47 public void setCountingTokens(boolean ct)
48 {
49 countingTokens = ct;
50 if ( countingTokens ) {
51 tokenNumber = 0;
52 }
53 else {
54 tokenNumber = 1;
55 }
56 }
57
58 public void setOriginalSource(String src)
59 {
60 originalSource = src;
61 lineObject.setSource(src);
62 }
63 public void setSource(String src)
64 {
65 lineObject.setSource(src);
66 }
67
68 public PreprocessorInfoChannel getPreprocessorInfoChannel()
69 {
70 return preprocessorInfoChannel;
71 }
72
73 public void setPreprocessingDirective(String pre)
74 {
75 preprocessorInfoChannel.addLineForTokenNumber( pre, new Integer(tokenNumber) );
76 }
77
78 public void addDefine(String name, String value)
79 {
80 }
81
82 protected Token makeToken(int t)
83 {
84 if ( t != Token.SKIP && countingTokens) {
85 tokenNumber++;
86 }
87 CToken tok = (CToken) super.makeToken(t);
88 tok.setLine(lineObject.line);
89 tok.setSource(lineObject.source);
90 tok.setTokenNumber(tokenNumber);
91
92 lineObject.line += deferredLineCount;
93 deferredLineCount = 0;
94 return tok;
95 }
96
97 public void deferredNewline() {
98 deferredLineCount++;
99 }
100
101 public void newline() {
102 lineObject.newline();
103 }
104
105
106
107
108
109
110 public StdCLexer(InputStream in) {
111 this(new ByteBuffer(in));
112}
113 public StdCLexer(Reader in) {
114 this(new CharBuffer(in));
115}
116 public StdCLexer(InputBuffer ib) {
117 this(new LexerSharedInputState(ib));
118}
119 public StdCLexer(LexerSharedInputState state) {
120 super(state);
121 caseSensitiveLiterals = true;
122 setCaseSensitive(true);
123 literals = new Hashtable();
124 literals.put(new ANTLRHashString("intptr_t", this), new Integer(39));
125 literals.put(new ANTLRHashString("extern", this), new Integer(15));
126 literals.put(new ANTLRHashString("case", this), new Integer(59));
127 literals.put(new ANTLRHashString("short", this), new Integer(20));
128 literals.put(new ANTLRHashString("break", this), new Integer(57));
129 literals.put(new ANTLRHashString("while", this), new Integer(52));
130 literals.put(new ANTLRHashString("uint32_t", this), new Integer(34));
131 literals.put(new ANTLRHashString("int16_t", this), new Integer(29));
132 literals.put(new ANTLRHashString("ptrdiff_t", this), new Integer(38));
133 literals.put(new ANTLRHashString("unsigned", this), new Integer(26));
134 literals.put(new ANTLRHashString("const", this), new Integer(17));
135 literals.put(new ANTLRHashString("float", this), new Integer(23));
136 literals.put(new ANTLRHashString("return", this), new Integer(58));
137 literals.put(new ANTLRHashString("int64_t", this), new Integer(36));
138 literals.put(new ANTLRHashString("sizeof", this), new Integer(94));
139 literals.put(new ANTLRHashString("size_t", this), new Integer(40));
140 literals.put(new ANTLRHashString("do", this), new Integer(53));
141 literals.put(new ANTLRHashString("typedef", this), new Integer(4));
142 literals.put(new ANTLRHashString("uint16_t", this), new Integer(30));
143 literals.put(new ANTLRHashString("if", this), new Integer(61));
144 literals.put(new ANTLRHashString("__int32", this), new Integer(31));
145 literals.put(new ANTLRHashString("double", this), new Integer(24));
146 literals.put(new ANTLRHashString("volatile", this), new Integer(6));
147 literals.put(new ANTLRHashString("union", this), new Integer(11));
148 literals.put(new ANTLRHashString("register", this), new Integer(14));
149 literals.put(new ANTLRHashString("auto", this), new Integer(13));
150 literals.put(new ANTLRHashString("goto", this), new Integer(55));
151 literals.put(new ANTLRHashString("enum", this), new Integer(12));
152 literals.put(new ANTLRHashString("int", this), new Integer(21));
153 literals.put(new ANTLRHashString("for", this), new Integer(54));
154 literals.put(new ANTLRHashString("int32_t", this), new Integer(32));
155 literals.put(new ANTLRHashString("uint64_t", this), new Integer(37));
156 literals.put(new ANTLRHashString("char", this), new Integer(19));
157 literals.put(new ANTLRHashString("default", this), new Integer(60));
158 literals.put(new ANTLRHashString("static", this), new Integer(16));
159 literals.put(new ANTLRHashString("int8_t", this), new Integer(27));
160 literals.put(new ANTLRHashString("uint8_t", this), new Integer(28));
161 literals.put(new ANTLRHashString("continue", this), new Integer(56));
162 literals.put(new ANTLRHashString("struct", this), new Integer(10));
163 literals.put(new ANTLRHashString("__int64", this), new Integer(35));
164 literals.put(new ANTLRHashString("signed", this), new Integer(25));
165 literals.put(new ANTLRHashString("else", this), new Integer(62));
166 literals.put(new ANTLRHashString("uintptr_t", this), new Integer(41));
167 literals.put(new ANTLRHashString("void", this), new Integer(18));
168 literals.put(new ANTLRHashString("wchar_t", this), new Integer(33));
169 literals.put(new ANTLRHashString("switch", this), new Integer(63));
170 literals.put(new ANTLRHashString("long", this), new Integer(22));
171 literals.put(new ANTLRHashString("asm", this), new Integer(5));
172}
173
174 public Token nextToken() throws TokenStreamException {
175 Token theRetToken=null;
176tryAgain:
177 for (;;) {
178 Token _token = null;
179 int _ttype = Token.INVALID_TYPE;
180 resetText();
181 try { // for char stream error handling
182 try { // for lexical error handling
183 switch ( LA(1)) {
184 case ':':
185 {
186 mCOLON(true);
187 theRetToken=_returnToken;
188 break;
189 }
190 case ',':
191 {
192 mCOMMA(true);
193 theRetToken=_returnToken;
194 break;
195 }
196 case '?':
197 {
198 mQUESTION(true);
199 theRetToken=_returnToken;
200 break;
201 }
202 case ';':
203 {
204 mSEMI(true);
205 theRetToken=_returnToken;
206 break;
207 }
208 case ')':
209 {
210 mRPAREN(true);
211 theRetToken=_returnToken;
212 break;
213 }
214 case '[':
215 {
216 mLBRACKET(true);
217 theRetToken=_returnToken;
218 break;
219 }
220 case ']':
221 {
222 mRBRACKET(true);
223 theRetToken=_returnToken;
224 break;
225 }
226 case '{':
227 {
228 mLCURLY(true);
229 theRetToken=_returnToken;
230 break;
231 }
232 case '}':
233 {
234 mRCURLY(true);
235 theRetToken=_returnToken;
236 break;
237 }
238 case '~':
239 {
240 mBNOT(true);
241 theRetToken=_returnToken;
242 break;
243 }
244 case '#':
245 {
246 mPREPROC_DIRECTIVE(true);
247 theRetToken=_returnToken;
248 break;
249 }
250 case 'A': case 'B': case 'C': case 'D':
251 case 'E': case 'F': case 'G': case 'H':
252 case 'I': case 'J': case 'K': case 'L':
253 case 'M': case 'N': case 'O': case 'P':
254 case 'Q': case 'R': case 'S': case 'T':
255 case 'U': case 'V': case 'W': case 'X':
256 case 'Y': case 'Z': case '_': case 'a':
257 case 'b': case 'c': case 'd': case 'e':
258 case 'f': case 'g': case 'h': case 'i':
259 case 'j': case 'k': case 'l': case 'm':
260 case 'n': case 'o': case 'p': case 'q':
261 case 'r': case 's': case 't': case 'u':
262 case 'v': case 'w': case 'x': case 'y':
263 case 'z':
264 {
265 mID(true);
266 theRetToken=_returnToken;
267 break;
268 }
269 case '"':
270 {
271 mStringLiteral(true);
272 theRetToken=_returnToken;
273 break;
274 }
275 case '\'':
276 {
277 mCharLiteral(true);
278 theRetToken=_returnToken;
279 break;
280 }
281 default:
282 if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
283 mRSHIFT_ASSIGN(true);
284 theRetToken=_returnToken;
285 }
286 else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
287 mLSHIFT_ASSIGN(true);
288 theRetToken=_returnToken;
289 }
290 else if ((LA(1)=='-') && (LA(2)=='>')) {
291 mPTR(true);
292 theRetToken=_returnToken;
293 }
294 else if ((LA(1)=='=') && (LA(2)=='=')) {
295 mEQUAL(true);
296 theRetToken=_returnToken;
297 }
298 else if ((LA(1)=='!') && (LA(2)=='=')) {
299 mNOT_EQUAL(true);
300 theRetToken=_returnToken;
301 }
302 else if ((LA(1)=='<') && (LA(2)=='=')) {
303 mLTE(true);
304 theRetToken=_returnToken;
305 }
306 else if ((LA(1)=='>') && (LA(2)=='=')) {
307 mGTE(true);
308 theRetToken=_returnToken;
309 }
310 else if ((LA(1)=='/') && (LA(2)=='=')) {
311 mDIV_ASSIGN(true);
312 theRetToken=_returnToken;
313 }
314 else if ((LA(1)=='+') && (LA(2)=='=')) {
315 mPLUS_ASSIGN(true);
316 theRetToken=_returnToken;
317 }
318 else if ((LA(1)=='+') && (LA(2)=='+')) {
319 mINC(true);
320 theRetToken=_returnToken;
321 }
322 else if ((LA(1)=='-') && (LA(2)=='=')) {
323 mMINUS_ASSIGN(true);
324 theRetToken=_returnToken;
325 }
326 else if ((LA(1)=='-') && (LA(2)=='-')) {
327 mDEC(true);
328 theRetToken=_returnToken;
329 }
330 else if ((LA(1)=='*') && (LA(2)=='=')) {
331 mSTAR_ASSIGN(true);
332 theRetToken=_returnToken;
333 }
334 else if ((LA(1)=='%') && (LA(2)=='=')) {
335 mMOD_ASSIGN(true);
336 theRetToken=_returnToken;
337 }
338 else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
339 mRSHIFT(true);
340 theRetToken=_returnToken;
341 }
342 else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
343 mLSHIFT(true);
344 theRetToken=_returnToken;
345 }
346 else if ((LA(1)=='&') && (LA(2)=='&')) {
347 mLAND(true);
348 theRetToken=_returnToken;
349 }
350 else if ((LA(1)=='|') && (LA(2)=='|')) {
351 mLOR(true);
352 theRetToken=_returnToken;
353 }
354 else if ((LA(1)=='&') && (LA(2)=='=')) {
355 mBAND_ASSIGN(true);
356 theRetToken=_returnToken;
357 }
358 else if ((LA(1)=='|') && (LA(2)=='=')) {
359 mBOR_ASSIGN(true);
360 theRetToken=_returnToken;
361 }
362 else if ((LA(1)=='^') && (LA(2)=='=')) {
363 mBXOR_ASSIGN(true);
364 theRetToken=_returnToken;
365 }
366 else if ((LA(1)=='/') && (LA(2)=='*')) {
367 mComment(true);
368 theRetToken=_returnToken;
369 }
370 else if ((LA(1)=='/') && (LA(2)=='/')) {
371 mCPPComment(true);
372 theRetToken=_returnToken;
373 }
374 else if ((LA(1)=='=') && (true)) {
375 mASSIGN(true);
376 theRetToken=_returnToken;
377 }
378 else if ((LA(1)=='(') && (true) && (true)) {
379 mLPAREN(true);
380 theRetToken=_returnToken;
381 }
382 else if ((LA(1)=='<') && (true)) {
383 mLT(true);
384 theRetToken=_returnToken;
385 }
386 else if ((LA(1)=='>') && (true)) {
387 mGT(true);
388 theRetToken=_returnToken;
389 }
390 else if ((LA(1)=='/') && (true)) {
391 mDIV(true);
392 theRetToken=_returnToken;
393 }
394 else if ((LA(1)=='+') && (true)) {
395 mPLUS(true);
396 theRetToken=_returnToken;
397 }
398 else if ((LA(1)=='-') && (true)) {
399 mMINUS(true);
400 theRetToken=_returnToken;
401 }
402 else if ((LA(1)=='*') && (true)) {
403 mSTAR(true);
404 theRetToken=_returnToken;
405 }
406 else if ((LA(1)=='%') && (true)) {
407 mMOD(true);
408 theRetToken=_returnToken;
409 }
410 else if ((LA(1)=='!') && (true)) {
411 mLNOT(true);
412 theRetToken=_returnToken;
413 }
414 else if ((LA(1)=='&') && (true)) {
415 mBAND(true);
416 theRetToken=_returnToken;
417 }
418 else if ((LA(1)=='|') && (true)) {
419 mBOR(true);
420 theRetToken=_returnToken;
421 }
422 else if ((LA(1)=='^') && (true)) {
423 mBXOR(true);
424 theRetToken=_returnToken;
425 }
426 else if ((_tokenSet_0.member(LA(1)))) {
427 mWhitespace(true);
428 theRetToken=_returnToken;
429 }
430 else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
431 mDefineExpr(true);
432 theRetToken=_returnToken;
433 }
434 else if ((_tokenSet_2.member(LA(1))) && (true) && (true)) {
435 mDefineExpr2(true);
436 theRetToken=_returnToken;
437 }
438 else if ((_tokenSet_2.member(LA(1))) && (true) && (true)) {
439 mNumber(true);
440 theRetToken=_returnToken;
441 }
442 else {
443 if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
444 else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
445 }
446 }
447 if ( _returnToken==null ) continue tryAgain; // found SKIP token
448 _ttype = _returnToken.getType();
449 _returnToken.setType(_ttype);
450 return _returnToken;
451 }
452 catch (RecognitionException e) {
453 throw new TokenStreamRecognitionException(e);
454 }
455 }
456 catch (CharStreamException cse) {
457 if ( cse instanceof CharStreamIOException ) {
458 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
459 }
460 else {
461 throw new TokenStreamException(cse.getMessage());
462 }
463 }
464 }
465}
466
467 protected final void mVocabulary(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
468 int _ttype; Token _token=null; int _begin=text.length();
469 _ttype = Vocabulary;
470 int _saveIndex;
471
472 matchRange('\3','\377');
473 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
474 _token = makeToken(_ttype);
475 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
476 }
477 _returnToken = _token;
478 }
479
480 public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
481 int _ttype; Token _token=null; int _begin=text.length();
482 _ttype = ASSIGN;
483 int _saveIndex;
484
485 match('=');
486 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
487 _token = makeToken(_ttype);
488 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
489 }
490 _returnToken = _token;
491 }
492
493 public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
494 int _ttype; Token _token=null; int _begin=text.length();
495 _ttype = COLON;
496 int _saveIndex;
497
498 match(':');
499 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
500 _token = makeToken(_ttype);
501 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
502 }
503 _returnToken = _token;
504 }
505
506 public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
507 int _ttype; Token _token=null; int _begin=text.length();
508 _ttype = COMMA;
509 int _saveIndex;
510
511 match(',');
512 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
513 _token = makeToken(_ttype);
514 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
515 }
516 _returnToken = _token;
517 }
518
519 public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
520 int _ttype; Token _token=null; int _begin=text.length();
521 _ttype = QUESTION;
522 int _saveIndex;
523
524 match('?');
525 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
526 _token = makeToken(_ttype);
527 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
528 }
529 _returnToken = _token;
530 }
531
532 public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
533 int _ttype; Token _token=null; int _begin=text.length();
534 _ttype = SEMI;
535 int _saveIndex;
536
537 match(';');
538 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
539 _token = makeToken(_ttype);
540 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
541 }
542 _returnToken = _token;
543 }
544
545 public final void mPTR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
546 int _ttype; Token _token=null; int _begin=text.length();
547 _ttype = PTR;
548 int _saveIndex;
549
550 match("->");
551 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
552 _token = makeToken(_ttype);
553 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
554 }
555 _returnToken = _token;
556 }
557
558 protected final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
559 int _ttype; Token _token=null; int _begin=text.length();
560 _ttype = DOT;
561 int _saveIndex;
562
563 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
564 _token = makeToken(_ttype);
565 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
566 }
567 _returnToken = _token;
568 }
569
570 protected final void mVARARGS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
571 int _ttype; Token _token=null; int _begin=text.length();
572 _ttype = VARARGS;
573 int _saveIndex;
574
575 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
576 _token = makeToken(_ttype);
577 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
578 }
579 _returnToken = _token;
580 }
581
582 public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
583 int _ttype; Token _token=null; int _begin=text.length();
584 _ttype = LPAREN;
585 int _saveIndex;
586
587 match('(');
588 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
589 _token = makeToken(_ttype);
590 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
591 }
592 _returnToken = _token;
593 }
594
595 public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
596 int _ttype; Token _token=null; int _begin=text.length();
597 _ttype = RPAREN;
598 int _saveIndex;
599
600 match(')');
601 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
602 _token = makeToken(_ttype);
603 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
604 }
605 _returnToken = _token;
606 }
607
608 public final void mLBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
609 int _ttype; Token _token=null; int _begin=text.length();
610 _ttype = LBRACKET;
611 int _saveIndex;
612
613 match('[');
614 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
615 _token = makeToken(_ttype);
616 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
617 }
618 _returnToken = _token;
619 }
620
621 public final void mRBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
622 int _ttype; Token _token=null; int _begin=text.length();
623 _ttype = RBRACKET;
624 int _saveIndex;
625
626 match(']');
627 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
628 _token = makeToken(_ttype);
629 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
630 }
631 _returnToken = _token;
632 }
633
634 public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
635 int _ttype; Token _token=null; int _begin=text.length();
636 _ttype = LCURLY;
637 int _saveIndex;
638
639 match('{');
640 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
641 _token = makeToken(_ttype);
642 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
643 }
644 _returnToken = _token;
645 }
646
647 public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
648 int _ttype; Token _token=null; int _begin=text.length();
649 _ttype = RCURLY;
650 int _saveIndex;
651
652 match('}');
653 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
654 _token = makeToken(_ttype);
655 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
656 }
657 _returnToken = _token;
658 }
659
660 public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
661 int _ttype; Token _token=null; int _begin=text.length();
662 _ttype = EQUAL;
663 int _saveIndex;
664
665 match("==");
666 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
667 _token = makeToken(_ttype);
668 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
669 }
670 _returnToken = _token;
671 }
672
673 public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
674 int _ttype; Token _token=null; int _begin=text.length();
675 _ttype = NOT_EQUAL;
676 int _saveIndex;
677
678 match("!=");
679 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
680 _token = makeToken(_ttype);
681 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
682 }
683 _returnToken = _token;
684 }
685
686 public final void mLTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
687 int _ttype; Token _token=null; int _begin=text.length();
688 _ttype = LTE;
689 int _saveIndex;
690
691 match("<=");
692 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
693 _token = makeToken(_ttype);
694 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
695 }
696 _returnToken = _token;
697 }
698
699 public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
700 int _ttype; Token _token=null; int _begin=text.length();
701 _ttype = LT;
702 int _saveIndex;
703
704 match("<");
705 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
706 _token = makeToken(_ttype);
707 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
708 }
709 _returnToken = _token;
710 }
711
712 public final void mGTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
713 int _ttype; Token _token=null; int _begin=text.length();
714 _ttype = GTE;
715 int _saveIndex;
716
717 match(">=");
718 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
719 _token = makeToken(_ttype);
720 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
721 }
722 _returnToken = _token;
723 }
724
725 public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
726 int _ttype; Token _token=null; int _begin=text.length();
727 _ttype = GT;
728 int _saveIndex;
729
730 match(">");
731 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
732 _token = makeToken(_ttype);
733 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
734 }
735 _returnToken = _token;
736 }
737
738 public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
739 int _ttype; Token _token=null; int _begin=text.length();
740 _ttype = DIV;
741 int _saveIndex;
742
743 match('/');
744 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
745 _token = makeToken(_ttype);
746 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
747 }
748 _returnToken = _token;
749 }
750
751 public final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
752 int _ttype; Token _token=null; int _begin=text.length();
753 _ttype = DIV_ASSIGN;
754 int _saveIndex;
755
756 match("/=");
757 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
758 _token = makeToken(_ttype);
759 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
760 }
761 _returnToken = _token;
762 }
763
764 public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
765 int _ttype; Token _token=null; int _begin=text.length();
766 _ttype = PLUS;
767 int _saveIndex;
768
769 match('+');
770 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
771 _token = makeToken(_ttype);
772 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
773 }
774 _returnToken = _token;
775 }
776
777 public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
778 int _ttype; Token _token=null; int _begin=text.length();
779 _ttype = PLUS_ASSIGN;
780 int _saveIndex;
781
782 match("+=");
783 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
784 _token = makeToken(_ttype);
785 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
786 }
787 _returnToken = _token;
788 }
789
790 public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
791 int _ttype; Token _token=null; int _begin=text.length();
792 _ttype = INC;
793 int _saveIndex;
794
795 match("++");
796 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
797 _token = makeToken(_ttype);
798 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
799 }
800 _returnToken = _token;
801 }
802
803 public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
804 int _ttype; Token _token=null; int _begin=text.length();
805 _ttype = MINUS;
806 int _saveIndex;
807
808 match('-');
809 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
810 _token = makeToken(_ttype);
811 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
812 }
813 _returnToken = _token;
814 }
815
816 public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
817 int _ttype; Token _token=null; int _begin=text.length();
818 _ttype = MINUS_ASSIGN;
819 int _saveIndex;
820
821 match("-=");
822 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
823 _token = makeToken(_ttype);
824 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
825 }
826 _returnToken = _token;
827 }
828
829 public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
830 int _ttype; Token _token=null; int _begin=text.length();
831 _ttype = DEC;
832 int _saveIndex;
833
834 match("--");
835 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
836 _token = makeToken(_ttype);
837 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
838 }
839 _returnToken = _token;
840 }
841
842 public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
843 int _ttype; Token _token=null; int _begin=text.length();
844 _ttype = STAR;
845 int _saveIndex;
846
847 match('*');
848 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
849 _token = makeToken(_ttype);
850 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
851 }
852 _returnToken = _token;
853 }
854
855 public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
856 int _ttype; Token _token=null; int _begin=text.length();
857 _ttype = STAR_ASSIGN;
858 int _saveIndex;
859
860 match("*=");
861 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
862 _token = makeToken(_ttype);
863 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
864 }
865 _returnToken = _token;
866 }
867
868 public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
869 int _ttype; Token _token=null; int _begin=text.length();
870 _ttype = MOD;
871 int _saveIndex;
872
873 match('%');
874 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
875 _token = makeToken(_ttype);
876 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
877 }
878 _returnToken = _token;
879 }
880
881 public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
882 int _ttype; Token _token=null; int _begin=text.length();
883 _ttype = MOD_ASSIGN;
884 int _saveIndex;
885
886 match("%=");
887 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
888 _token = makeToken(_ttype);
889 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
890 }
891 _returnToken = _token;
892 }
893
894 public final void mRSHIFT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
895 int _ttype; Token _token=null; int _begin=text.length();
896 _ttype = RSHIFT;
897 int _saveIndex;
898
899 match(">>");
900 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
901 _token = makeToken(_ttype);
902 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
903 }
904 _returnToken = _token;
905 }
906
907 public final void mRSHIFT_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
908 int _ttype; Token _token=null; int _begin=text.length();
909 _ttype = RSHIFT_ASSIGN;
910 int _saveIndex;
911
912 match(">>=");
913 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
914 _token = makeToken(_ttype);
915 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
916 }
917 _returnToken = _token;
918 }
919
920 public final void mLSHIFT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
921 int _ttype; Token _token=null; int _begin=text.length();
922 _ttype = LSHIFT;
923 int _saveIndex;
924
925 match("<<");
926 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
927 _token = makeToken(_ttype);
928 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
929 }
930 _returnToken = _token;
931 }
932
933 public final void mLSHIFT_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
934 int _ttype; Token _token=null; int _begin=text.length();
935 _ttype = LSHIFT_ASSIGN;
936 int _saveIndex;
937
938 match("<<=");
939 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
940 _token = makeToken(_ttype);
941 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
942 }
943 _returnToken = _token;
944 }
945
946 public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
947 int _ttype; Token _token=null; int _begin=text.length();
948 _ttype = LAND;
949 int _saveIndex;
950
951 match("&&");
952 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
953 _token = makeToken(_ttype);
954 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
955 }
956 _returnToken = _token;
957 }
958
959 public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
960 int _ttype; Token _token=null; int _begin=text.length();
961 _ttype = LNOT;
962 int _saveIndex;
963
964 match('!');
965 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
966 _token = makeToken(_ttype);
967 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
968 }
969 _returnToken = _token;
970 }
971
972 public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
973 int _ttype; Token _token=null; int _begin=text.length();
974 _ttype = LOR;
975 int _saveIndex;
976
977 match("||");
978 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
979 _token = makeToken(_ttype);
980 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
981 }
982 _returnToken = _token;
983 }
984
985 public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
986 int _ttype; Token _token=null; int _begin=text.length();
987 _ttype = BAND;
988 int _saveIndex;
989
990 match('&');
991 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
992 _token = makeToken(_ttype);
993 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
994 }
995 _returnToken = _token;
996 }
997
998 public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
999 int _ttype; Token _token=null; int _begin=text.length();
1000 _ttype = BAND_ASSIGN;
1001 int _saveIndex;
1002
1003 match("&=");
1004 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1005 _token = makeToken(_ttype);
1006 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1007 }
1008 _returnToken = _token;
1009 }
1010
1011 public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1012 int _ttype; Token _token=null; int _begin=text.length();
1013 _ttype = BNOT;
1014 int _saveIndex;
1015
1016 match('~');
1017 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1018 _token = makeToken(_ttype);
1019 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1020 }
1021 _returnToken = _token;
1022 }
1023
1024 public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1025 int _ttype; Token _token=null; int _begin=text.length();
1026 _ttype = BOR;
1027 int _saveIndex;
1028
1029 match('|');
1030 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1031 _token = makeToken(_ttype);
1032 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1033 }
1034 _returnToken = _token;
1035 }
1036
1037 public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1038 int _ttype; Token _token=null; int _begin=text.length();
1039 _ttype = BOR_ASSIGN;
1040 int _saveIndex;
1041
1042 match("|=");
1043 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1044 _token = makeToken(_ttype);
1045 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1046 }
1047 _returnToken = _token;
1048 }
1049
1050 public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1051 int _ttype; Token _token=null; int _begin=text.length();
1052 _ttype = BXOR;
1053 int _saveIndex;
1054
1055 match('^');
1056 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1057 _token = makeToken(_ttype);
1058 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1059 }
1060 _returnToken = _token;
1061 }
1062
1063 public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1064 int _ttype; Token _token=null; int _begin=text.length();
1065 _ttype = BXOR_ASSIGN;
1066 int _saveIndex;
1067
1068 match("^=");
1069 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1070 _token = makeToken(_ttype);
1071 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1072 }
1073 _returnToken = _token;
1074 }
1075
1076 public final void mWhitespace(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1077 int _ttype; Token _token=null; int _begin=text.length();
1078 _ttype = Whitespace;
1079 int _saveIndex;
1080
1081 {
1082 if ((LA(1)=='\r') && (LA(2)=='\n')) {
1083 match("\r\n");
1084 if ( inputState.guessing==0 ) {
1085 newline();
1086 }
1087 }
1088 else if ((_tokenSet_3.member(LA(1)))) {
1089 {
1090 switch ( LA(1)) {
1091 case '\u0003': case '\u0004': case '\u0005': case '\u0006':
1092 case '\u0007': case '\u0008':
1093 {
1094 matchRange('\003','\010');
1095 break;
1096 }
1097 case '\t':
1098 {
1099 match('\t');
1100 break;
1101 }
1102 case '\u000b':
1103 {
1104 match('\013');
1105 break;
1106 }
1107 case '\u000c':
1108 {
1109 match('\f');
1110 break;
1111 }
1112 case '\u000e': case '\u000f': case '\u0010': case '\u0011':
1113 case '\u0012': case '\u0013': case '\u0014': case '\u0015':
1114 case '\u0016': case '\u0017': case '\u0018': case '\u0019':
1115 case '\u001a': case '\u001b': case '\u001c': case '\u001d':
1116 case '\u001e': case '\u001f':
1117 {
1118 matchRange('\016','\037');
1119 break;
1120 }
1121 case ' ':
1122 {
1123 match(' ');
1124 break;
1125 }
1126 default:
1127 if (((LA(1) >= '\u007f' && LA(1) <= '\u00ff'))) {
1128 matchRange('\177','\377');
1129 }
1130 else {
1131 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1132 }
1133 }
1134 }
1135 }
1136 else if ((LA(1)=='\n'||LA(1)=='\r') && (true)) {
1137 {
1138 switch ( LA(1)) {
1139 case '\n':
1140 {
1141 match('\n');
1142 break;
1143 }
1144 case '\r':
1145 {
1146 match('\r');
1147 break;
1148 }
1149 default:
1150 {
1151 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1152 }
1153 }
1154 }
1155 if ( inputState.guessing==0 ) {
1156 newline();
1157 }
1158 }
1159 else {
1160 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1161 }
1162
1163 }
1164 if ( inputState.guessing==0 ) {
1165 _ttype = Token.SKIP;
1166 }
1167 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1168 _token = makeToken(_ttype);
1169 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1170 }
1171 _returnToken = _token;
1172 }
1173
1174 public final void mComment(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1175 int _ttype; Token _token=null; int _begin=text.length();
1176 _ttype = Comment;
1177 int _saveIndex;
1178
1179 match("/*");
1180 {
1181 _loop269:
1182 do {
1183 if (((LA(1)=='*') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && ((LA(3) >= '\u0000' && LA(3) <= '\u00ff')))&&( LA(2) != '/' )) {
1184 match('*');
1185 }
1186 else if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0000' && LA(3) <= '\u00ff'))) {
1187 match("\r\n");
1188 if ( inputState.guessing==0 ) {
1189 deferredNewline();
1190 }
1191 }
1192 else if ((LA(1)=='\n'||LA(1)=='\r') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && ((LA(3) >= '\u0000' && LA(3) <= '\u00ff'))) {
1193 {
1194 switch ( LA(1)) {
1195 case '\r':
1196 {
1197 match('\r');
1198 break;
1199 }
1200 case '\n':
1201 {
1202 match('\n');
1203 break;
1204 }
1205 default:
1206 {
1207 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1208 }
1209 }
1210 }
1211 if ( inputState.guessing==0 ) {
1212 deferredNewline();
1213 }
1214 }
1215 else if ((_tokenSet_4.member(LA(1)))) {
1216 {
1217 match(_tokenSet_4);
1218 }
1219 }
1220 else {
1221 break _loop269;
1222 }
1223
1224 } while (true);
1225 }
1226 match("*/");
1227 if ( inputState.guessing==0 ) {
1228 _ttype = Token.SKIP;
1229
1230 }
1231 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1232 _token = makeToken(_ttype);
1233 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1234 }
1235 _returnToken = _token;
1236 }
1237
1238 public final void mCPPComment(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1239 int _ttype; Token _token=null; int _begin=text.length();
1240 _ttype = CPPComment;
1241 int _saveIndex;
1242
1243 match("//");
1244 {
1245 _loop273:
1246 do {
1247 if ((_tokenSet_5.member(LA(1)))) {
1248 {
1249 match(_tokenSet_5);
1250 }
1251 }
1252 else {
1253 break _loop273;
1254 }
1255
1256 } while (true);
1257 }
1258 if ( inputState.guessing==0 ) {
1259
1260 _ttype = Token.SKIP;
1261
1262 }
1263 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1264 _token = makeToken(_ttype);
1265 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1266 }
1267 _returnToken = _token;
1268 }
1269
1270 protected final void mNonWhitespace(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1271 int _ttype; Token _token=null; int _begin=text.length();
1272 _ttype = NonWhitespace;
1273 int _saveIndex;
1274
1275 {
1276 _loop277:
1277 do {
1278 if ((_tokenSet_6.member(LA(1)))) {
1279 {
1280 match(_tokenSet_6);
1281 }
1282 }
1283 else {
1284 break _loop277;
1285 }
1286
1287 } while (true);
1288 }
1289 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1290 _token = makeToken(_ttype);
1291 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1292 }
1293 _returnToken = _token;
1294 }
1295
1296 public final void mPREPROC_DIRECTIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1297 int _ttype; Token _token=null; int _begin=text.length();
1298 _ttype = PREPROC_DIRECTIVE;
1299 int _saveIndex;
1300 Token i=null;
1301 Token n=null;
1302 Token nw=null;
1303
1304 match('#');
1305 {
1306 boolean synPredMatched284 = false;
1307 if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))) && (_tokenSet_9.member(LA(3))))) {
1308 int _m284 = mark();
1309 synPredMatched284 = true;
1310 inputState.guessing++;
1311 try {
1312 {
1313 switch ( LA(1)) {
1314 case 'l':
1315 {
1316 match("line");
1317 break;
1318 }
1319 case '\t': case '\u000c': case ' ':
1320 {
1321 {
1322 {
1323 int _cnt283=0;
1324 _loop283:
1325 do {
1326 switch ( LA(1)) {
1327 case ' ':
1328 {
1329 match(' ');
1330 break;
1331 }
1332 case '\t':
1333 {
1334 match('\t');
1335 break;
1336 }
1337 case '\u000c':
1338 {
1339 match('\014');
1340 break;
1341 }
1342 default:
1343 {
1344 if ( _cnt283>=1 ) { break _loop283; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1345 }
1346 }
1347 _cnt283++;
1348 } while (true);
1349 }
1350 matchRange('0','9');
1351 }
1352 break;
1353 }
1354 default:
1355 {
1356 }
1357 }
1358 }
1359 }
1360 catch (RecognitionException pe) {
1361 synPredMatched284 = false;
1362 }
1363 rewind(_m284);
1364inputState.guessing--;
1365 }
1366 if ( synPredMatched284 ) {
1367 mLineDirective(false);
1368 }
1369 else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_12.member(LA(3)))) {
1370 {
1371 {
1372 _loop287:
1373 do {
1374 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1375 mSpace(false);
1376 }
1377 else {
1378 break _loop287;
1379 }
1380
1381 } while (true);
1382 }
1383 match("define");
1384 {
1385 _loop289:
1386 do {
1387 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1388 mSpace(false);
1389 }
1390 else {
1391 break _loop289;
1392 }
1393
1394 } while (true);
1395 }
1396 mID(true);
1397 i=_returnToken;
1398 {
1399 _loop291:
1400 do {
1401 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1402 mSpace(false);
1403 }
1404 else {
1405 break _loop291;
1406 }
1407
1408 } while (true);
1409 }
1410 {
1411 if ((_tokenSet_1.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1412 mDefineExpr(true);
1413 n=_returnToken;
1414 }
1415 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
1416 }
1417 else {
1418 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1419 }
1420
1421 }
1422 mNonWhitespace(true);
1423 nw=_returnToken;
1424 {
1425 if ((LA(1)=='\r') && (LA(2)=='\n')) {
1426 match("\r\n");
1427 }
1428 else if ((LA(1)=='\r') && (true)) {
1429 match("\r");
1430 }
1431 else if ((LA(1)=='\n')) {
1432 match("\n");
1433 }
1434 else {
1435 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1436 }
1437
1438 }
1439 }
1440 if ( inputState.guessing==0 ) {
1441
1442 if (n != null) {
1443 // System.out.println("addDefine: #define " + i.getText() + " " + n.getText()+" @ "+lineObject.getSource()+":"+(lineObject.line+deferredLineCount));
1444 addDefine(i.getText(), n.getText());
1445 } else {
1446 setPreprocessingDirective("#define " + i.getText() + " " + nw.getText());
1447 }
1448 deferredNewline();
1449
1450 }
1451 }
1452 else {
1453 {
1454 _loop295:
1455 do {
1456 if ((_tokenSet_5.member(LA(1)))) {
1457 matchNot('\n');
1458 }
1459 else {
1460 break _loop295;
1461 }
1462
1463 } while (true);
1464 }
1465 if ( inputState.guessing==0 ) {
1466 setPreprocessingDirective(getText());
1467 }
1468 }
1469
1470 }
1471 if ( inputState.guessing==0 ) {
1472
1473 _ttype = Token.SKIP;
1474
1475 }
1476 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1477 _token = makeToken(_ttype);
1478 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1479 }
1480 _returnToken = _token;
1481 }
1482
1483 protected final void mLineDirective(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1484 int _ttype; Token _token=null; int _begin=text.length();
1485 _ttype = LineDirective;
1486 int _saveIndex;
1487 Token n=null;
1488 Token fn=null;
1489 Token fi=null;
1490
1491 boolean oldCountingTokens = countingTokens;
1492 countingTokens = false;
1493
1494
1495 if ( inputState.guessing==0 ) {
1496
1497 lineObject = new LineObject();
1498 deferredLineCount = 0;
1499
1500 }
1501 {
1502 switch ( LA(1)) {
1503 case 'l':
1504 {
1505 match("line");
1506 break;
1507 }
1508 case '\t': case '\u000c': case ' ':
1509 {
1510 break;
1511 }
1512 default:
1513 {
1514 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1515 }
1516 }
1517 }
1518 {
1519 int _cnt320=0;
1520 _loop320:
1521 do {
1522 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1523 mSpace(false);
1524 }
1525 else {
1526 if ( _cnt320>=1 ) { break _loop320; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1527 }
1528
1529 _cnt320++;
1530 } while (true);
1531 }
1532 mNumber(true);
1533 n=_returnToken;
1534 if ( inputState.guessing==0 ) {
1535
1536 lineObject.setLine(Integer.parseInt(n.getText()));
1537
1538 }
1539 {
1540 int _cnt322=0;
1541 _loop322:
1542 do {
1543 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1544 mSpace(false);
1545 }
1546 else {
1547 if ( _cnt322>=1 ) { break _loop322; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1548 }
1549
1550 _cnt322++;
1551 } while (true);
1552 }
1553 {
1554 if ((LA(1)=='"') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && ((LA(3) >= '\u0000' && LA(3) <= '\u00ff'))) {
1555 mStringLiteral(true);
1556 fn=_returnToken;
1557 if ( inputState.guessing==0 ) {
1558 try {
1559 final String newSource = fn.getText().substring(1,fn.getText().length()-1);
1560 // System.out.println("line: "+lineObject.getSource()+" -> "+newSource+", line "+(lineObject.line+deferredLineCount));
1561 lineObject.setSource(newSource);
1562 }
1563 catch (StringIndexOutOfBoundsException e) { /*not possible*/ }
1564
1565 }
1566 }
1567 else if ((_tokenSet_13.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1568 mID(true);
1569 fi=_returnToken;
1570 if ( inputState.guessing==0 ) {
1571 lineObject.setSource(fi.getText());
1572 }
1573 }
1574 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
1575 }
1576 else {
1577 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1578 }
1579
1580 }
1581 {
1582 _loop325:
1583 do {
1584 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1585 mSpace(false);
1586 }
1587 else {
1588 break _loop325;
1589 }
1590
1591 } while (true);
1592 }
1593 {
1594 if ((LA(1)=='1') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1595 match("1");
1596 if ( inputState.guessing==0 ) {
1597 lineObject.setEnteringFile(true);
1598 }
1599 }
1600 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
1601 }
1602 else {
1603 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1604 }
1605
1606 }
1607 {
1608 _loop328:
1609 do {
1610 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1611 mSpace(false);
1612 }
1613 else {
1614 break _loop328;
1615 }
1616
1617 } while (true);
1618 }
1619 {
1620 if ((LA(1)=='2') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1621 match("2");
1622 if ( inputState.guessing==0 ) {
1623 lineObject.setReturningToFile(true);
1624 }
1625 }
1626 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
1627 }
1628 else {
1629 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1630 }
1631
1632 }
1633 {
1634 _loop331:
1635 do {
1636 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1637 mSpace(false);
1638 }
1639 else {
1640 break _loop331;
1641 }
1642
1643 } while (true);
1644 }
1645 {
1646 if ((LA(1)=='3') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1647 match("3");
1648 if ( inputState.guessing==0 ) {
1649 lineObject.setSystemHeader(true);
1650 }
1651 }
1652 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
1653 }
1654 else {
1655 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1656 }
1657
1658 }
1659 {
1660 _loop334:
1661 do {
1662 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1663 mSpace(false);
1664 }
1665 else {
1666 break _loop334;
1667 }
1668
1669 } while (true);
1670 }
1671 {
1672 if ((LA(1)=='4') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
1673 match("4");
1674 if ( inputState.guessing==0 ) {
1675 lineObject.setTreatAsC(true);
1676 }
1677 }
1678 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
1679 }
1680 else {
1681 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1682 }
1683
1684 }
1685 {
1686 _loop338:
1687 do {
1688 if ((_tokenSet_6.member(LA(1)))) {
1689 {
1690 match(_tokenSet_6);
1691 }
1692 }
1693 else {
1694 break _loop338;
1695 }
1696
1697 } while (true);
1698 }
1699 {
1700 if ((LA(1)=='\r') && (LA(2)=='\n')) {
1701 match("\r\n");
1702 }
1703 else if ((LA(1)=='\r') && (true)) {
1704 match("\r");
1705 }
1706 else if ((LA(1)=='\n')) {
1707 match("\n");
1708 }
1709 else {
1710 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1711 }
1712
1713 }
1714 if ( inputState.guessing==0 ) {
1715
1716 preprocessorInfoChannel.addLineForTokenNumber(new LineObject(lineObject), new Integer(tokenNumber));
1717 countingTokens = oldCountingTokens;
1718
1719 }
1720 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1721 _token = makeToken(_ttype);
1722 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1723 }
1724 _returnToken = _token;
1725 }
1726
1727 protected final void mSpace(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1728 int _ttype; Token _token=null; int _begin=text.length();
1729 _ttype = Space;
1730 int _saveIndex;
1731
1732 {
1733 switch ( LA(1)) {
1734 case ' ':
1735 {
1736 match(' ');
1737 break;
1738 }
1739 case '\t':
1740 {
1741 match('\t');
1742 break;
1743 }
1744 case '\u000c':
1745 {
1746 match('\014');
1747 break;
1748 }
1749 default:
1750 {
1751 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1752 }
1753 }
1754 }
1755 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1756 _token = makeToken(_ttype);
1757 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1758 }
1759 _returnToken = _token;
1760 }
1761
1762 public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1763 int _ttype; Token _token=null; int _begin=text.length();
1764 _ttype = ID;
1765 int _saveIndex;
1766
1767 {
1768 switch ( LA(1)) {
1769 case 'a': case 'b': case 'c': case 'd':
1770 case 'e': case 'f': case 'g': case 'h':
1771 case 'i': case 'j': case 'k': case 'l':
1772 case 'm': case 'n': case 'o': case 'p':
1773 case 'q': case 'r': case 's': case 't':
1774 case 'u': case 'v': case 'w': case 'x':
1775 case 'y': case 'z':
1776 {
1777 matchRange('a','z');
1778 break;
1779 }
1780 case 'A': case 'B': case 'C': case 'D':
1781 case 'E': case 'F': case 'G': case 'H':
1782 case 'I': case 'J': case 'K': case 'L':
1783 case 'M': case 'N': case 'O': case 'P':
1784 case 'Q': case 'R': case 'S': case 'T':
1785 case 'U': case 'V': case 'W': case 'X':
1786 case 'Y': case 'Z':
1787 {
1788 matchRange('A','Z');
1789 break;
1790 }
1791 case '_':
1792 {
1793 match('_');
1794 break;
1795 }
1796 default:
1797 {
1798 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1799 }
1800 }
1801 }
1802 {
1803 _loop412:
1804 do {
1805 if (((LA(1) >= 'a' && LA(1) <= 'z')) && (true) && (true)) {
1806 matchRange('a','z');
1807 }
1808 else if (((LA(1) >= 'A' && LA(1) <= 'Z')) && (true) && (true)) {
1809 matchRange('A','Z');
1810 }
1811 else if ((LA(1)=='_') && (true) && (true)) {
1812 match('_');
1813 }
1814 else if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
1815 matchRange('0','9');
1816 }
1817 else {
1818 break _loop412;
1819 }
1820
1821 } while (true);
1822 }
1823 _ttype = testLiteralsTable(_ttype);
1824 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1825 _token = makeToken(_ttype);
1826 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1827 }
1828 _returnToken = _token;
1829 }
1830
1831 public final void mDefineExpr(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1832 int _ttype; Token _token=null; int _begin=text.length();
1833 _ttype = DefineExpr;
1834 int _saveIndex;
1835
1836 switch ( LA(1)) {
1837 case '(':
1838 {
1839 {
1840 {
1841 mLPAREN(false);
1842 }
1843 {
1844 _loop300:
1845 do {
1846 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1847 mSpace(false);
1848 }
1849 else {
1850 break _loop300;
1851 }
1852
1853 } while (true);
1854 }
1855 {
1856 mDefineExpr2(false);
1857 }
1858 {
1859 _loop303:
1860 do {
1861 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1862 mSpace(false);
1863 }
1864 else {
1865 break _loop303;
1866 }
1867
1868 } while (true);
1869 }
1870 {
1871 mRPAREN(false);
1872 }
1873 }
1874 break;
1875 }
1876 case '.': case '0': case '1': case '2':
1877 case '3': case '4': case '5': case '6':
1878 case '7': case '8': case '9':
1879 {
1880 {
1881 mDefineExpr2(false);
1882 }
1883 break;
1884 }
1885 default:
1886 {
1887 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1888 }
1889 }
1890 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1891 _token = makeToken(_ttype);
1892 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1893 }
1894 _returnToken = _token;
1895 }
1896
1897 public final void mDefineExpr2(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1898 int _ttype; Token _token=null; int _begin=text.length();
1899 _ttype = DefineExpr2;
1900 int _saveIndex;
1901
1902 {
1903 mNumber(false);
1904 }
1905 {
1906 if ((_tokenSet_14.member(LA(1))) && (_tokenSet_15.member(LA(2))) && (true)) {
1907 {
1908 _loop310:
1909 do {
1910 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1911 mSpace(false);
1912 }
1913 else {
1914 break _loop310;
1915 }
1916
1917 } while (true);
1918 }
1919 {
1920 switch ( LA(1)) {
1921 case '<':
1922 {
1923 mLSHIFT(false);
1924 break;
1925 }
1926 case '>':
1927 {
1928 mRSHIFT(false);
1929 break;
1930 }
1931 case '+':
1932 {
1933 mPLUS(false);
1934 break;
1935 }
1936 case '-':
1937 {
1938 mMINUS(false);
1939 break;
1940 }
1941 case '*':
1942 {
1943 mSTAR(false);
1944 break;
1945 }
1946 case '/':
1947 {
1948 mDIV(false);
1949 break;
1950 }
1951 case '%':
1952 {
1953 mMOD(false);
1954 break;
1955 }
1956 default:
1957 {
1958 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1959 }
1960 }
1961 }
1962 {
1963 _loop313:
1964 do {
1965 if ((LA(1)=='\t'||LA(1)=='\u000c'||LA(1)==' ')) {
1966 mSpace(false);
1967 }
1968 else {
1969 break _loop313;
1970 }
1971
1972 } while (true);
1973 }
1974 {
1975 mDefineExpr(false);
1976 }
1977 }
1978 else {
1979 }
1980
1981 }
1982 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1983 _token = makeToken(_ttype);
1984 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1985 }
1986 _returnToken = _token;
1987 }
1988
1989 public final void mNumber(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1990 int _ttype; Token _token=null; int _begin=text.length();
1991 _ttype = Number;
1992 int _saveIndex;
1993
1994 boolean synPredMatched393 = false;
1995 if (((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='.'))) {
1996 int _m393 = mark();
1997 synPredMatched393 = true;
1998 inputState.guessing++;
1999 try {
2000 {
2001 match("...");
2002 }
2003 }
2004 catch (RecognitionException pe) {
2005 synPredMatched393 = false;
2006 }
2007 rewind(_m393);
2008inputState.guessing--;
2009 }
2010 if ( synPredMatched393 ) {
2011 match("...");
2012 if ( inputState.guessing==0 ) {
2013 _ttype = VARARGS;
2014 }
2015 }
2016 else if ((LA(1)=='0') && (LA(2)=='X'||LA(2)=='x') && (_tokenSet_16.member(LA(3)))) {
2017 match('0');
2018 {
2019 switch ( LA(1)) {
2020 case 'x':
2021 {
2022 match('x');
2023 break;
2024 }
2025 case 'X':
2026 {
2027 match('X');
2028 break;
2029 }
2030 default:
2031 {
2032 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2033 }
2034 }
2035 }
2036 {
2037 int _cnt407=0;
2038 _loop407:
2039 do {
2040 if (((LA(1) >= 'a' && LA(1) <= 'f')) && (true) && (true)) {
2041 matchRange('a','f');
2042 }
2043 else if (((LA(1) >= 'A' && LA(1) <= 'F')) && (true) && (true)) {
2044 matchRange('A','F');
2045 }
2046 else if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
2047 mDigit(false);
2048 }
2049 else {
2050 if ( _cnt407>=1 ) { break _loop407; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2051 }
2052
2053 _cnt407++;
2054 } while (true);
2055 }
2056 if ( inputState.guessing==0 ) {
2057 _ttype = IntHexConst;
2058 }
2059 {
2060 if ((LA(1)=='L'||LA(1)=='l') && (true) && (true)) {
2061 mLongSuffix(false);
2062 if ( inputState.guessing==0 ) {
2063 _ttype = LongHexConst;
2064 }
2065 }
2066 else if ((LA(1)=='U'||LA(1)=='u') && (true) && (true)) {
2067 mUnsignedSuffix(false);
2068 if ( inputState.guessing==0 ) {
2069 _ttype = UnsignedHexConst;
2070 }
2071 }
2072 else {
2073 }
2074
2075 }
2076 }
2077 else {
2078 boolean synPredMatched384 = false;
2079 if ((((LA(1) >= '0' && LA(1) <= '9')) && (_tokenSet_17.member(LA(2))) && (true))) {
2080 int _m384 = mark();
2081 synPredMatched384 = true;
2082 inputState.guessing++;
2083 try {
2084 {
2085 {
2086 int _cnt382=0;
2087 _loop382:
2088 do {
2089 if (((LA(1) >= '0' && LA(1) <= '9'))) {
2090 mDigit(false);
2091 }
2092 else {
2093 if ( _cnt382>=1 ) { break _loop382; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2094 }
2095
2096 _cnt382++;
2097 } while (true);
2098 }
2099 {
2100 switch ( LA(1)) {
2101 case '.':
2102 {
2103 match('.');
2104 break;
2105 }
2106 case 'e':
2107 {
2108 match('e');
2109 break;
2110 }
2111 case 'E':
2112 {
2113 match('E');
2114 break;
2115 }
2116 default:
2117 {
2118 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2119 }
2120 }
2121 }
2122 }
2123 }
2124 catch (RecognitionException pe) {
2125 synPredMatched384 = false;
2126 }
2127 rewind(_m384);
2128inputState.guessing--;
2129 }
2130 if ( synPredMatched384 ) {
2131 {
2132 int _cnt386=0;
2133 _loop386:
2134 do {
2135 if (((LA(1) >= '0' && LA(1) <= '9'))) {
2136 mDigit(false);
2137 }
2138 else {
2139 if ( _cnt386>=1 ) { break _loop386; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2140 }
2141
2142 _cnt386++;
2143 } while (true);
2144 }
2145 {
2146 switch ( LA(1)) {
2147 case '.':
2148 {
2149 match('.');
2150 {
2151 _loop389:
2152 do {
2153 if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
2154 mDigit(false);
2155 }
2156 else {
2157 break _loop389;
2158 }
2159
2160 } while (true);
2161 }
2162 {
2163 if ((LA(1)=='E'||LA(1)=='e') && (_tokenSet_18.member(LA(2))) && (true)) {
2164 mExponent(false);
2165 }
2166 else {
2167 }
2168
2169 }
2170 break;
2171 }
2172 case 'E': case 'e':
2173 {
2174 mExponent(false);
2175 break;
2176 }
2177 default:
2178 {
2179 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2180 }
2181 }
2182 }
2183 if ( inputState.guessing==0 ) {
2184 _ttype = DoubleDoubleConst;
2185 }
2186 {
2187 if ((LA(1)=='F'||LA(1)=='f') && (true) && (true)) {
2188 mFloatSuffix(false);
2189 if ( inputState.guessing==0 ) {
2190 _ttype = FloatDoubleConst;
2191 }
2192 }
2193 else if ((LA(1)=='L'||LA(1)=='l') && (true) && (true)) {
2194 mLongSuffix(false);
2195 if ( inputState.guessing==0 ) {
2196 _ttype = LongDoubleConst;
2197 }
2198 }
2199 else {
2200 }
2201
2202 }
2203 }
2204 else if ((LA(1)=='.') && (true) && (true)) {
2205 match('.');
2206 if ( inputState.guessing==0 ) {
2207 _ttype = DOT;
2208 }
2209 {
2210 if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
2211 {
2212 int _cnt396=0;
2213 _loop396:
2214 do {
2215 if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
2216 mDigit(false);
2217 }
2218 else {
2219 if ( _cnt396>=1 ) { break _loop396; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2220 }
2221
2222 _cnt396++;
2223 } while (true);
2224 }
2225 {
2226 if ((LA(1)=='E'||LA(1)=='e') && (_tokenSet_18.member(LA(2))) && (true)) {
2227 mExponent(false);
2228 }
2229 else {
2230 }
2231
2232 }
2233 if ( inputState.guessing==0 ) {
2234 _ttype = DoubleDoubleConst;
2235 }
2236 {
2237 if ((LA(1)=='F'||LA(1)=='f') && (true) && (true)) {
2238 mFloatSuffix(false);
2239 if ( inputState.guessing==0 ) {
2240 _ttype = FloatDoubleConst;
2241 }
2242 }
2243 else if ((LA(1)=='L'||LA(1)=='l') && (true) && (true)) {
2244 mLongSuffix(false);
2245 if ( inputState.guessing==0 ) {
2246 _ttype = LongDoubleConst;
2247 }
2248 }
2249 else {
2250 }
2251
2252 }
2253 }
2254 else {
2255 }
2256
2257 }
2258 }
2259 else if ((LA(1)=='0') && (true) && (true)) {
2260 match('0');
2261 {
2262 _loop400:
2263 do {
2264 if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true)) {
2265 matchRange('0','7');
2266 }
2267 else {
2268 break _loop400;
2269 }
2270
2271 } while (true);
2272 }
2273 if ( inputState.guessing==0 ) {
2274 _ttype = IntOctalConst;
2275 }
2276 {
2277 if ((LA(1)=='L'||LA(1)=='l') && (true) && (true)) {
2278 mLongSuffix(false);
2279 if ( inputState.guessing==0 ) {
2280 _ttype = LongOctalConst;
2281 }
2282 }
2283 else if ((LA(1)=='U'||LA(1)=='u') && (true) && (true)) {
2284 mUnsignedSuffix(false);
2285 if ( inputState.guessing==0 ) {
2286 _ttype = UnsignedOctalConst;
2287 }
2288 }
2289 else {
2290 }
2291
2292 }
2293 }
2294 else if (((LA(1) >= '1' && LA(1) <= '9')) && (true) && (true)) {
2295 matchRange('1','9');
2296 {
2297 _loop403:
2298 do {
2299 if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
2300 mDigit(false);
2301 }
2302 else {
2303 break _loop403;
2304 }
2305
2306 } while (true);
2307 }
2308 if ( inputState.guessing==0 ) {
2309 _ttype = IntIntConst;
2310 }
2311 {
2312 if ((LA(1)=='L'||LA(1)=='l') && (true) && (true)) {
2313 mLongSuffix(false);
2314 if ( inputState.guessing==0 ) {
2315 _ttype = LongIntConst;
2316 }
2317 }
2318 else if ((LA(1)=='U'||LA(1)=='u') && (true) && (true)) {
2319 mUnsignedSuffix(false);
2320 if ( inputState.guessing==0 ) {
2321 _ttype = UnsignedIntConst;
2322 }
2323 }
2324 else {
2325 }
2326
2327 }
2328 }
2329 else {
2330 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2331 }
2332 }
2333 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2334 _token = makeToken(_ttype);
2335 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2336 }
2337 _returnToken = _token;
2338 }
2339
2340 public final void mStringLiteral(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2341 int _ttype; Token _token=null; int _begin=text.length();
2342 _ttype = StringLiteral;
2343 int _saveIndex;
2344
2345 match('"');
2346 {
2347 _loop347:
2348 do {
2349 if ((LA(1)=='\\') && (_tokenSet_19.member(LA(2))) && ((LA(3) >= '\u0000' && LA(3) <= '\u00ff'))) {
2350 mEscape(false);
2351 }
2352 else if ((LA(1)=='\n'||LA(1)=='\r'||LA(1)=='\\') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2353 {
2354 switch ( LA(1)) {
2355 case '\r':
2356 {
2357 match('\r');
2358 if ( inputState.guessing==0 ) {
2359 deferredNewline();
2360 }
2361 break;
2362 }
2363 case '\n':
2364 {
2365 match('\n');
2366 if ( inputState.guessing==0 ) {
2367
2368 deferredNewline();
2369 _ttype = BadStringLiteral;
2370
2371 }
2372 break;
2373 }
2374 case '\\':
2375 {
2376 match('\\');
2377 match('\n');
2378 if ( inputState.guessing==0 ) {
2379
2380 deferredNewline();
2381
2382 }
2383 break;
2384 }
2385 default:
2386 {
2387 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2388 }
2389 }
2390 }
2391 }
2392 else if ((_tokenSet_20.member(LA(1)))) {
2393 {
2394 match(_tokenSet_20);
2395 }
2396 }
2397 else {
2398 break _loop347;
2399 }
2400
2401 } while (true);
2402 }
2403 match('"');
2404 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2405 _token = makeToken(_ttype);
2406 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2407 }
2408 _returnToken = _token;
2409 }
2410
2411 public final void mCharLiteral(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2412 int _ttype; Token _token=null; int _begin=text.length();
2413 _ttype = CharLiteral;
2414 int _saveIndex;
2415
2416 match('\'');
2417 {
2418 if ((LA(1)=='\\') && (_tokenSet_19.member(LA(2))) && (_tokenSet_21.member(LA(3)))) {
2419 mEscape(false);
2420 }
2421 else if ((_tokenSet_22.member(LA(1))) && (LA(2)=='\'') && (true)) {
2422 {
2423 match(_tokenSet_22);
2424 }
2425 }
2426 else {
2427 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2428 }
2429
2430 }
2431 match('\'');
2432 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2433 _token = makeToken(_ttype);
2434 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2435 }
2436 _returnToken = _token;
2437 }
2438
2439 protected final void mEscape(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2440 int _ttype; Token _token=null; int _begin=text.length();
2441 _ttype = Escape;
2442 int _saveIndex;
2443
2444 match('\\');
2445 {
2446 switch ( LA(1)) {
2447 case 'a':
2448 {
2449 match('a');
2450 break;
2451 }
2452 case 'b':
2453 {
2454 match('b');
2455 break;
2456 }
2457 case 'f':
2458 {
2459 match('f');
2460 break;
2461 }
2462 case 'n':
2463 {
2464 match('n');
2465 break;
2466 }
2467 case 'r':
2468 {
2469 match('r');
2470 break;
2471 }
2472 case 't':
2473 {
2474 match('t');
2475 break;
2476 }
2477 case 'v':
2478 {
2479 match('v');
2480 break;
2481 }
2482 case '"':
2483 {
2484 match('"');
2485 break;
2486 }
2487 case '\'':
2488 {
2489 match('\'');
2490 break;
2491 }
2492 case '\\':
2493 {
2494 match('\\');
2495 break;
2496 }
2497 case '?':
2498 {
2499 match('?');
2500 break;
2501 }
2502 case '0': case '1': case '2': case '3':
2503 {
2504 {
2505 matchRange('0','3');
2506 }
2507 {
2508 if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2509 mDigit(false);
2510 {
2511 if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2512 mDigit(false);
2513 }
2514 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
2515 }
2516 else {
2517 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2518 }
2519
2520 }
2521 }
2522 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
2523 }
2524 else {
2525 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2526 }
2527
2528 }
2529 break;
2530 }
2531 case '4': case '5': case '6': case '7':
2532 {
2533 {
2534 matchRange('4','7');
2535 }
2536 {
2537 if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2538 mDigit(false);
2539 }
2540 else if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && (true) && (true)) {
2541 }
2542 else {
2543 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2544 }
2545
2546 }
2547 break;
2548 }
2549 case 'x':
2550 {
2551 match('x');
2552 {
2553 int _cnt357=0;
2554 _loop357:
2555 do {
2556 if (((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2557 mDigit(false);
2558 }
2559 else if (((LA(1) >= 'a' && LA(1) <= 'f')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2560 matchRange('a','f');
2561 }
2562 else if (((LA(1) >= 'A' && LA(1) <= 'F')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff')) && (true)) {
2563 matchRange('A','F');
2564 }
2565 else {
2566 if ( _cnt357>=1 ) { break _loop357; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2567 }
2568
2569 _cnt357++;
2570 } while (true);
2571 }
2572 break;
2573 }
2574 default:
2575 {
2576 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2577 }
2578 }
2579 }
2580 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2581 _token = makeToken(_ttype);
2582 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2583 }
2584 _returnToken = _token;
2585 }
2586
2587 protected final void mBadStringLiteral(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2588 int _ttype; Token _token=null; int _begin=text.length();
2589 _ttype = BadStringLiteral;
2590 int _saveIndex;
2591
2592 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2593 _token = makeToken(_ttype);
2594 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2595 }
2596 _returnToken = _token;
2597 }
2598
2599 protected final void mDigit(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2600 int _ttype; Token _token=null; int _begin=text.length();
2601 _ttype = Digit;
2602 int _saveIndex;
2603
2604 matchRange('0','9');
2605 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2606 _token = makeToken(_ttype);
2607 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2608 }
2609 _returnToken = _token;
2610 }
2611
2612 protected final void mLongSuffix(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2613 int _ttype; Token _token=null; int _begin=text.length();
2614 _ttype = LongSuffix;
2615 int _saveIndex;
2616
2617 switch ( LA(1)) {
2618 case 'l':
2619 {
2620 match('l');
2621 break;
2622 }
2623 case 'L':
2624 {
2625 match('L');
2626 break;
2627 }
2628 default:
2629 {
2630 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2631 }
2632 }
2633 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2634 _token = makeToken(_ttype);
2635 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2636 }
2637 _returnToken = _token;
2638 }
2639
2640 protected final void mUnsignedSuffix(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2641 int _ttype; Token _token=null; int _begin=text.length();
2642 _ttype = UnsignedSuffix;
2643 int _saveIndex;
2644
2645 switch ( LA(1)) {
2646 case 'u':
2647 {
2648 match('u');
2649 break;
2650 }
2651 case 'U':
2652 {
2653 match('U');
2654 break;
2655 }
2656 default:
2657 {
2658 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2659 }
2660 }
2661 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2662 _token = makeToken(_ttype);
2663 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2664 }
2665 _returnToken = _token;
2666 }
2667
2668 protected final void mFloatSuffix(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2669 int _ttype; Token _token=null; int _begin=text.length();
2670 _ttype = FloatSuffix;
2671 int _saveIndex;
2672
2673 switch ( LA(1)) {
2674 case 'f':
2675 {
2676 match('f');
2677 break;
2678 }
2679 case 'F':
2680 {
2681 match('F');
2682 break;
2683 }
2684 default:
2685 {
2686 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2687 }
2688 }
2689 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2690 _token = makeToken(_ttype);
2691 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2692 }
2693 _returnToken = _token;
2694 }
2695
2696 protected final void mExponent(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2697 int _ttype; Token _token=null; int _begin=text.length();
2698 _ttype = Exponent;
2699 int _saveIndex;
2700
2701 {
2702 switch ( LA(1)) {
2703 case 'e':
2704 {
2705 match('e');
2706 break;
2707 }
2708 case 'E':
2709 {
2710 match('E');
2711 break;
2712 }
2713 default:
2714 {
2715 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2716 }
2717 }
2718 }
2719 {
2720 switch ( LA(1)) {
2721 case '+':
2722 {
2723 match('+');
2724 break;
2725 }
2726 case '-':
2727 {
2728 match('-');
2729 break;
2730 }
2731 case '0': case '1': case '2': case '3':
2732 case '4': case '5': case '6': case '7':
2733 case '8': case '9':
2734 {
2735 break;
2736 }
2737 default:
2738 {
2739 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2740 }
2741 }
2742 }
2743 {
2744 int _cnt366=0;
2745 _loop366:
2746 do {
2747 if (((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true)) {
2748 mDigit(false);
2749 }
2750 else {
2751 if ( _cnt366>=1 ) { break _loop366; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2752 }
2753
2754 _cnt366++;
2755 } while (true);
2756 }
2757 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2758 _token = makeToken(_ttype);
2759 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2760 }
2761 _returnToken = _token;
2762 }
2763
2764 protected final void mDoubleDoubleConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2765 int _ttype; Token _token=null; int _begin=text.length();
2766 _ttype = DoubleDoubleConst;
2767 int _saveIndex;
2768
2769 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2770 _token = makeToken(_ttype);
2771 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2772 }
2773 _returnToken = _token;
2774 }
2775
2776 protected final void mFloatDoubleConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2777 int _ttype; Token _token=null; int _begin=text.length();
2778 _ttype = FloatDoubleConst;
2779 int _saveIndex;
2780
2781 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2782 _token = makeToken(_ttype);
2783 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2784 }
2785 _returnToken = _token;
2786 }
2787
2788 protected final void mLongDoubleConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2789 int _ttype; Token _token=null; int _begin=text.length();
2790 _ttype = LongDoubleConst;
2791 int _saveIndex;
2792
2793 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2794 _token = makeToken(_ttype);
2795 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2796 }
2797 _returnToken = _token;
2798 }
2799
2800 protected final void mIntOctalConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2801 int _ttype; Token _token=null; int _begin=text.length();
2802 _ttype = IntOctalConst;
2803 int _saveIndex;
2804
2805 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2806 _token = makeToken(_ttype);
2807 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2808 }
2809 _returnToken = _token;
2810 }
2811
2812 protected final void mLongOctalConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2813 int _ttype; Token _token=null; int _begin=text.length();
2814 _ttype = LongOctalConst;
2815 int _saveIndex;
2816
2817 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2818 _token = makeToken(_ttype);
2819 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2820 }
2821 _returnToken = _token;
2822 }
2823
2824 protected final void mUnsignedOctalConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2825 int _ttype; Token _token=null; int _begin=text.length();
2826 _ttype = UnsignedOctalConst;
2827 int _saveIndex;
2828
2829 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2830 _token = makeToken(_ttype);
2831 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2832 }
2833 _returnToken = _token;
2834 }
2835
2836 protected final void mIntIntConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2837 int _ttype; Token _token=null; int _begin=text.length();
2838 _ttype = IntIntConst;
2839 int _saveIndex;
2840
2841 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2842 _token = makeToken(_ttype);
2843 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2844 }
2845 _returnToken = _token;
2846 }
2847
2848 protected final void mLongIntConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2849 int _ttype; Token _token=null; int _begin=text.length();
2850 _ttype = LongIntConst;
2851 int _saveIndex;
2852
2853 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2854 _token = makeToken(_ttype);
2855 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2856 }
2857 _returnToken = _token;
2858 }
2859
2860 protected final void mUnsignedIntConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2861 int _ttype; Token _token=null; int _begin=text.length();
2862 _ttype = UnsignedIntConst;
2863 int _saveIndex;
2864
2865 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2866 _token = makeToken(_ttype);
2867 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2868 }
2869 _returnToken = _token;
2870 }
2871
2872 protected final void mIntHexConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2873 int _ttype; Token _token=null; int _begin=text.length();
2874 _ttype = IntHexConst;
2875 int _saveIndex;
2876
2877 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2878 _token = makeToken(_ttype);
2879 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2880 }
2881 _returnToken = _token;
2882 }
2883
2884 protected final void mLongHexConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2885 int _ttype; Token _token=null; int _begin=text.length();
2886 _ttype = LongHexConst;
2887 int _saveIndex;
2888
2889 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2890 _token = makeToken(_ttype);
2891 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2892 }
2893 _returnToken = _token;
2894 }
2895
2896 protected final void mUnsignedHexConst(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2897 int _ttype; Token _token=null; int _begin=text.length();
2898 _ttype = UnsignedHexConst;
2899 int _saveIndex;
2900
2901 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2902 _token = makeToken(_ttype);
2903 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2904 }
2905 _returnToken = _token;
2906 }
2907
2908
2909 private static final long[] mk_tokenSet_0() {
2910 long[] data = new long[8];
2911 data[0]=8589934584L;
2912 data[1]=-9223372036854775808L;
2913 for (int i = 2; i<=3; i++) { data[i]=-1L; }
2914 return data;
2915 }
2916 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
2917 private static final long[] mk_tokenSet_1() {
2918 long[] data = { 288020369430806528L, 0L, 0L, 0L, 0L};
2919 return data;
2920 }
2921 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
2922 private static final long[] mk_tokenSet_2() {
2923 long[] data = { 288019269919178752L, 0L, 0L, 0L, 0L};
2924 return data;
2925 }
2926 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
2927 private static final long[] mk_tokenSet_3() {
2928 long[] data = new long[8];
2929 data[0]=8589925368L;
2930 data[1]=-9223372036854775808L;
2931 for (int i = 2; i<=3; i++) { data[i]=-1L; }
2932 return data;
2933 }
2934 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
2935 private static final long[] mk_tokenSet_4() {
2936 long[] data = new long[8];
2937 data[0]=-4398046520321L;
2938 for (int i = 1; i<=3; i++) { data[i]=-1L; }
2939 return data;
2940 }
2941 public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
2942 private static final long[] mk_tokenSet_5() {
2943 long[] data = new long[8];
2944 data[0]=-1025L;
2945 for (int i = 1; i<=3; i++) { data[i]=-1L; }
2946 return data;
2947 }
2948 public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
2949 private static final long[] mk_tokenSet_6() {
2950 long[] data = new long[8];
2951 data[0]=-9217L;
2952 for (int i = 1; i<=3; i++) { data[i]=-1L; }
2953 return data;
2954 }
2955 public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
2956 private static final long[] mk_tokenSet_7() {
2957 long[] data = { 4294971904L, 17592186044416L, 0L, 0L, 0L};
2958 return data;
2959 }
2960 public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
2961 private static final long[] mk_tokenSet_8() {
2962 long[] data = { 288019274214150656L, 2199023255552L, 0L, 0L, 0L};
2963 return data;
2964 }
2965 public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
2966 private static final long[] mk_tokenSet_9() {
2967 long[] data = { 288019274214150656L, 81152891680722976L, 0L, 0L, 0L};
2968 return data;
2969 }
2970 public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
2971 private static final long[] mk_tokenSet_10() {
2972 long[] data = { 4294971904L, 68719476736L, 0L, 0L, 0L};
2973 return data;
2974 }
2975 public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
2976 private static final long[] mk_tokenSet_11() {
2977 long[] data = { 4294971904L, 206158430208L, 0L, 0L, 0L};
2978 return data;
2979 }
2980 public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
2981 private static final long[] mk_tokenSet_12() {
2982 long[] data = { 4294971904L, 481036337152L, 0L, 0L, 0L};
2983 return data;
2984 }
2985 public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
2986 private static final long[] mk_tokenSet_13() {
2987 long[] data = { 0L, 576460745995190270L, 0L, 0L, 0L};
2988 return data;
2989 }
2990 public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
2991 private static final long[] mk_tokenSet_14() {
2992 long[] data = { 5764796780768137728L, 0L, 0L, 0L, 0L};
2993 return data;
2994 }
2995 public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
2996 private static final long[] mk_tokenSet_15() {
2997 long[] data = { 6052817150198944256L, 0L, 0L, 0L, 0L};
2998 return data;
2999 }
3000 public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
3001 private static final long[] mk_tokenSet_16() {
3002 long[] data = { 287948901175001088L, 541165879422L, 0L, 0L, 0L};
3003 return data;
3004 }
3005 public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
3006 private static final long[] mk_tokenSet_17() {
3007 long[] data = { 288019269919178752L, 137438953504L, 0L, 0L, 0L};
3008 return data;
3009 }
3010 public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
3011 private static final long[] mk_tokenSet_18() {
3012 long[] data = { 287992881640112128L, 0L, 0L, 0L, 0L};
3013 return data;
3014 }
3015 public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
3016 private static final long[] mk_tokenSet_19() {
3017 long[] data = { -9151595350857875456L, 95772161741946880L, 0L, 0L, 0L};
3018 return data;
3019 }
3020 public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
3021 private static final long[] mk_tokenSet_20() {
3022 long[] data = new long[8];
3023 data[0]=-17179878401L;
3024 data[1]=-268435457L;
3025 for (int i = 2; i<=3; i++) { data[i]=-1L; }
3026 return data;
3027 }
3028 public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
3029 private static final long[] mk_tokenSet_21() {
3030 long[] data = { 287949450930814976L, 541165879422L, 0L, 0L, 0L};
3031 return data;
3032 }
3033 public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
3034 private static final long[] mk_tokenSet_22() {
3035 long[] data = new long[8];
3036 data[0]=-549755813889L;
3037 for (int i = 1; i<=3; i++) { data[i]=-1L; }
3038 return data;
3039 }
3040 public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
3041
3042 }
com.jogamp.gluegen.cgram.CToken
Definition: CToken.java:3
com.jogamp.gluegen.cgram.CToken.setTokenNumber
void setTokenNumber(final int i)
Definition: CToken.java:22
com.jogamp.gluegen.cgram.CToken.setSource
void setSource(final String src)
Definition: CToken.java:12
com.jogamp.gluegen.cgram.PreprocessorInfoChannel
Definition: PreprocessorInfoChannel.java:6
com.jogamp.gluegen.cgram.PreprocessorInfoChannel.addLineForTokenNumber
void addLineForTokenNumber(final Object line, final Integer toknum)
Definition: PreprocessorInfoChannel.java:11
com.jogamp.gluegen.cgram.StdCLexer
Definition: StdCLexer.java:38
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_10
static final BitSet _tokenSet_10
Definition: StdCLexer.java:2975
com.jogamp.gluegen.cgram.StdCLexer.mCharLiteral
final void mCharLiteral(boolean _createToken)
Definition: StdCLexer.java:2411
com.jogamp.gluegen.cgram.StdCLexer.StdCLexer
StdCLexer(LexerSharedInputState state)
Definition: StdCLexer.java:119
com.jogamp.gluegen.cgram.StdCLexer.mDefineExpr2
final void mDefineExpr2(boolean _createToken)
Definition: StdCLexer.java:1897
com.jogamp.gluegen.cgram.StdCLexer.mLongSuffix
final void mLongSuffix(boolean _createToken)
Definition: StdCLexer.java:2612
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_12
static final BitSet _tokenSet_12
Definition: StdCLexer.java:2985
com.jogamp.gluegen.cgram.StdCLexer.mStringLiteral
final void mStringLiteral(boolean _createToken)
Definition: StdCLexer.java:2340
com.jogamp.gluegen.cgram.StdCLexer.mSEMI
final void mSEMI(boolean _createToken)
Definition: StdCLexer.java:532
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_1
static final BitSet _tokenSet_1
Definition: StdCLexer.java:2921
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_9
static final BitSet _tokenSet_9
Definition: StdCLexer.java:2970
com.jogamp.gluegen.cgram.StdCLexer.mVocabulary
final void mVocabulary(boolean _createToken)
Definition: StdCLexer.java:467
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_19
static final BitSet _tokenSet_19
Definition: StdCLexer.java:3020
com.jogamp.gluegen.cgram.StdCLexer.mLT
final void mLT(boolean _createToken)
Definition: StdCLexer.java:699
com.jogamp.gluegen.cgram.StdCLexer.mCPPComment
final void mCPPComment(boolean _createToken)
Definition: StdCLexer.java:1238
com.jogamp.gluegen.cgram.StdCLexer.setCountingTokens
void setCountingTokens(boolean ct)
Definition: StdCLexer.java:47
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_11
static final BitSet _tokenSet_11
Definition: StdCLexer.java:2980
com.jogamp.gluegen.cgram.StdCLexer.mMOD_ASSIGN
final void mMOD_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:881
com.jogamp.gluegen.cgram.StdCLexer.mDEC
final void mDEC(boolean _createToken)
Definition: StdCLexer.java:829
com.jogamp.gluegen.cgram.StdCLexer.StdCLexer
StdCLexer(InputStream in)
Definition: StdCLexer.java:110
com.jogamp.gluegen.cgram.StdCLexer.mIntOctalConst
final void mIntOctalConst(boolean _createToken)
Definition: StdCLexer.java:2800
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_8
static final BitSet _tokenSet_8
Definition: StdCLexer.java:2965
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_13
static final BitSet _tokenSet_13
Definition: StdCLexer.java:2990
com.jogamp.gluegen.cgram.StdCLexer.mLBRACKET
final void mLBRACKET(boolean _createToken)
Definition: StdCLexer.java:608
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_14
static final BitSet _tokenSet_14
Definition: StdCLexer.java:2995
com.jogamp.gluegen.cgram.StdCLexer.mRSHIFT
final void mRSHIFT(boolean _createToken)
Definition: StdCLexer.java:894
com.jogamp.gluegen.cgram.StdCLexer.mGT
final void mGT(boolean _createToken)
Definition: StdCLexer.java:725
com.jogamp.gluegen.cgram.StdCLexer.setOriginalSource
void setOriginalSource(String src)
Definition: StdCLexer.java:58
com.jogamp.gluegen.cgram.StdCLexer.mBXOR
final void mBXOR(boolean _createToken)
Definition: StdCLexer.java:1050
com.jogamp.gluegen.cgram.StdCLexer.mIntIntConst
final void mIntIntConst(boolean _createToken)
Definition: StdCLexer.java:2836
com.jogamp.gluegen.cgram.StdCLexer.getPreprocessorInfoChannel
PreprocessorInfoChannel getPreprocessorInfoChannel()
Definition: StdCLexer.java:68
com.jogamp.gluegen.cgram.StdCLexer.mLSHIFT_ASSIGN
final void mLSHIFT_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:933
com.jogamp.gluegen.cgram.StdCLexer.mLongDoubleConst
final void mLongDoubleConst(boolean _createToken)
Definition: StdCLexer.java:2788
com.jogamp.gluegen.cgram.StdCLexer.mSTAR
final void mSTAR(boolean _createToken)
Definition: StdCLexer.java:842
com.jogamp.gluegen.cgram.StdCLexer.mINC
final void mINC(boolean _createToken)
Definition: StdCLexer.java:790
com.jogamp.gluegen.cgram.StdCLexer.mLineDirective
final void mLineDirective(boolean _createToken)
Definition: StdCLexer.java:1483
com.jogamp.gluegen.cgram.StdCLexer.mGTE
final void mGTE(boolean _createToken)
Definition: StdCLexer.java:712
com.jogamp.gluegen.cgram.StdCLexer.mWhitespace
final void mWhitespace(boolean _createToken)
Definition: StdCLexer.java:1076
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_6
static final BitSet _tokenSet_6
Definition: StdCLexer.java:2955
com.jogamp.gluegen.cgram.StdCLexer.mPTR
final void mPTR(boolean _createToken)
Definition: StdCLexer.java:545
com.jogamp.gluegen.cgram.StdCLexer.mLCURLY
final void mLCURLY(boolean _createToken)
Definition: StdCLexer.java:634
com.jogamp.gluegen.cgram.StdCLexer.mUnsignedIntConst
final void mUnsignedIntConst(boolean _createToken)
Definition: StdCLexer.java:2860
com.jogamp.gluegen.cgram.StdCLexer.mCOLON
final void mCOLON(boolean _createToken)
Definition: StdCLexer.java:493
com.jogamp.gluegen.cgram.StdCLexer.newline
void newline()
Definition: StdCLexer.java:101
com.jogamp.gluegen.cgram.StdCLexer.nextToken
Token nextToken()
Definition: StdCLexer.java:174
com.jogamp.gluegen.cgram.StdCLexer.mLOR
final void mLOR(boolean _createToken)
Definition: StdCLexer.java:972
com.jogamp.gluegen.cgram.StdCLexer.mBOR_ASSIGN
final void mBOR_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:1037
com.jogamp.gluegen.cgram.StdCLexer.mDigit
final void mDigit(boolean _createToken)
Definition: StdCLexer.java:2599
com.jogamp.gluegen.cgram.StdCLexer.mMINUS_ASSIGN
final void mMINUS_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:816
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_15
static final BitSet _tokenSet_15
Definition: StdCLexer.java:3000
com.jogamp.gluegen.cgram.StdCLexer.mNonWhitespace
final void mNonWhitespace(boolean _createToken)
Definition: StdCLexer.java:1270
com.jogamp.gluegen.cgram.StdCLexer.mIntHexConst
final void mIntHexConst(boolean _createToken)
Definition: StdCLexer.java:2872
com.jogamp.gluegen.cgram.StdCLexer.mUnsignedHexConst
final void mUnsignedHexConst(boolean _createToken)
Definition: StdCLexer.java:2896
com.jogamp.gluegen.cgram.StdCLexer.mLTE
final void mLTE(boolean _createToken)
Definition: StdCLexer.java:686
com.jogamp.gluegen.cgram.StdCLexer.mRCURLY
final void mRCURLY(boolean _createToken)
Definition: StdCLexer.java:647
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_5
static final BitSet _tokenSet_5
Definition: StdCLexer.java:2948
com.jogamp.gluegen.cgram.StdCLexer.mCOMMA
final void mCOMMA(boolean _createToken)
Definition: StdCLexer.java:506
com.jogamp.gluegen.cgram.StdCLexer.mPREPROC_DIRECTIVE
final void mPREPROC_DIRECTIVE(boolean _createToken)
Definition: StdCLexer.java:1296
com.jogamp.gluegen.cgram.StdCLexer.mEQUAL
final void mEQUAL(boolean _createToken)
Definition: StdCLexer.java:660
com.jogamp.gluegen.cgram.StdCLexer.mVARARGS
final void mVARARGS(boolean _createToken)
Definition: StdCLexer.java:570
com.jogamp.gluegen.cgram.StdCLexer.mBAND
final void mBAND(boolean _createToken)
Definition: StdCLexer.java:985
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_20
static final BitSet _tokenSet_20
Definition: StdCLexer.java:3028
com.jogamp.gluegen.cgram.StdCLexer.setPreprocessingDirective
void setPreprocessingDirective(String pre)
Definition: StdCLexer.java:73
com.jogamp.gluegen.cgram.StdCLexer.mBOR
final void mBOR(boolean _createToken)
Definition: StdCLexer.java:1024
com.jogamp.gluegen.cgram.StdCLexer.mDoubleDoubleConst
final void mDoubleDoubleConst(boolean _createToken)
Definition: StdCLexer.java:2764
com.jogamp.gluegen.cgram.StdCLexer.mRSHIFT_ASSIGN
final void mRSHIFT_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:907
com.jogamp.gluegen.cgram.StdCLexer.mDOT
final void mDOT(boolean _createToken)
Definition: StdCLexer.java:558
com.jogamp.gluegen.cgram.StdCLexer.mMOD
final void mMOD(boolean _createToken)
Definition: StdCLexer.java:868
com.jogamp.gluegen.cgram.StdCLexer.mExponent
final void mExponent(boolean _createToken)
Definition: StdCLexer.java:2696
com.jogamp.gluegen.cgram.StdCLexer.mBAND_ASSIGN
final void mBAND_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:998
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_7
static final BitSet _tokenSet_7
Definition: StdCLexer.java:2960
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_0
static final BitSet _tokenSet_0
Definition: StdCLexer.java:2916
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_21
static final BitSet _tokenSet_21
Definition: StdCLexer.java:3033
com.jogamp.gluegen.cgram.StdCLexer.mLSHIFT
final void mLSHIFT(boolean _createToken)
Definition: StdCLexer.java:920
com.jogamp.gluegen.cgram.StdCLexer.mComment
final void mComment(boolean _createToken)
Definition: StdCLexer.java:1174
com.jogamp.gluegen.cgram.StdCLexer.mDefineExpr
final void mDefineExpr(boolean _createToken)
Definition: StdCLexer.java:1831
com.jogamp.gluegen.cgram.StdCLexer.setSource
void setSource(String src)
Definition: StdCLexer.java:63
com.jogamp.gluegen.cgram.StdCLexer.mSTAR_ASSIGN
final void mSTAR_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:855
com.jogamp.gluegen.cgram.StdCLexer.mID
final void mID(boolean _createToken)
Definition: StdCLexer.java:1762
com.jogamp.gluegen.cgram.StdCLexer.mQUESTION
final void mQUESTION(boolean _createToken)
Definition: StdCLexer.java:519
com.jogamp.gluegen.cgram.StdCLexer.mNumber
final void mNumber(boolean _createToken)
Definition: StdCLexer.java:1989
com.jogamp.gluegen.cgram.StdCLexer.mDIV_ASSIGN
final void mDIV_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:751
com.jogamp.gluegen.cgram.StdCLexer.addDefine
void addDefine(String name, String value)
Definition: StdCLexer.java:78
com.jogamp.gluegen.cgram.StdCLexer.mLAND
final void mLAND(boolean _createToken)
Definition: StdCLexer.java:946
com.jogamp.gluegen.cgram.StdCLexer.mRBRACKET
final void mRBRACKET(boolean _createToken)
Definition: StdCLexer.java:621
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_3
static final BitSet _tokenSet_3
Definition: StdCLexer.java:2934
com.jogamp.gluegen.cgram.StdCLexer.mPLUS_ASSIGN
final void mPLUS_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:777
com.jogamp.gluegen.cgram.StdCLexer.StdCLexer
StdCLexer(InputBuffer ib)
Definition: StdCLexer.java:116
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_17
static final BitSet _tokenSet_17
Definition: StdCLexer.java:3010
com.jogamp.gluegen.cgram.StdCLexer.mLongIntConst
final void mLongIntConst(boolean _createToken)
Definition: StdCLexer.java:2848
com.jogamp.gluegen.cgram.StdCLexer.mBadStringLiteral
final void mBadStringLiteral(boolean _createToken)
Definition: StdCLexer.java:2587
com.jogamp.gluegen.cgram.StdCLexer.mEscape
final void mEscape(boolean _createToken)
Definition: StdCLexer.java:2439
com.jogamp.gluegen.cgram.StdCLexer.mUnsignedOctalConst
final void mUnsignedOctalConst(boolean _createToken)
Definition: StdCLexer.java:2824
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_2
static final BitSet _tokenSet_2
Definition: StdCLexer.java:2926
com.jogamp.gluegen.cgram.StdCLexer.mLPAREN
final void mLPAREN(boolean _createToken)
Definition: StdCLexer.java:582
com.jogamp.gluegen.cgram.StdCLexer.mRPAREN
final void mRPAREN(boolean _createToken)
Definition: StdCLexer.java:595
com.jogamp.gluegen.cgram.StdCLexer.StdCLexer
StdCLexer(Reader in)
Definition: StdCLexer.java:113
com.jogamp.gluegen.cgram.StdCLexer.makeToken
Token makeToken(int t)
Definition: StdCLexer.java:82
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_4
static final BitSet _tokenSet_4
Definition: StdCLexer.java:2941
com.jogamp.gluegen.cgram.StdCLexer.mUnsignedSuffix
final void mUnsignedSuffix(boolean _createToken)
Definition: StdCLexer.java:2640
com.jogamp.gluegen.cgram.StdCLexer.mPLUS
final void mPLUS(boolean _createToken)
Definition: StdCLexer.java:764
com.jogamp.gluegen.cgram.StdCLexer.mASSIGN
final void mASSIGN(boolean _createToken)
Definition: StdCLexer.java:480
com.jogamp.gluegen.cgram.StdCLexer.mFloatDoubleConst
final void mFloatDoubleConst(boolean _createToken)
Definition: StdCLexer.java:2776
com.jogamp.gluegen.cgram.StdCLexer.mMINUS
final void mMINUS(boolean _createToken)
Definition: StdCLexer.java:803
com.jogamp.gluegen.cgram.StdCLexer.mLongHexConst
final void mLongHexConst(boolean _createToken)
Definition: StdCLexer.java:2884
com.jogamp.gluegen.cgram.StdCLexer.mFloatSuffix
final void mFloatSuffix(boolean _createToken)
Definition: StdCLexer.java:2668
com.jogamp.gluegen.cgram.StdCLexer.mLongOctalConst
final void mLongOctalConst(boolean _createToken)
Definition: StdCLexer.java:2812
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_22
static final BitSet _tokenSet_22
Definition: StdCLexer.java:3040
com.jogamp.gluegen.cgram.StdCLexer.deferredNewline
void deferredNewline()
Definition: StdCLexer.java:97
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_18
static final BitSet _tokenSet_18
Definition: StdCLexer.java:3015
com.jogamp.gluegen.cgram.StdCLexer._tokenSet_16
static final BitSet _tokenSet_16
Definition: StdCLexer.java:3005
com.jogamp.gluegen.cgram.StdCLexer.mSpace
final void mSpace(boolean _createToken)
Definition: StdCLexer.java:1727
com.jogamp.gluegen.cgram.StdCLexer.mDIV
final void mDIV(boolean _createToken)
Definition: StdCLexer.java:738
com.jogamp.gluegen.cgram.StdCLexer.mNOT_EQUAL
final void mNOT_EQUAL(boolean _createToken)
Definition: StdCLexer.java:673
com.jogamp.gluegen.cgram.StdCLexer.mBXOR_ASSIGN
final void mBXOR_ASSIGN(boolean _createToken)
Definition: StdCLexer.java:1063
com.jogamp.gluegen.cgram.StdCLexer.mBNOT
final void mBNOT(boolean _createToken)
Definition: StdCLexer.java:1011
com.jogamp.gluegen.cgram.StdCLexer.mLNOT
final void mLNOT(boolean _createToken)
Definition: StdCLexer.java:959
com.jogamp.gluegen.cgram.STDCTokenTypes
Definition: STDCTokenTypes.java:10
com.jogamp.gluegen.cgram.STDCTokenTypes.BAND_ASSIGN
int BAND_ASSIGN
Definition: STDCTokenTypes.java:80
com.jogamp.gluegen.cgram.STDCTokenTypes.MOD
int MOD
Definition: STDCTokenTypes.java:100
com.jogamp.gluegen.cgram.STDCTokenTypes.GTE
int GTE
Definition: STDCTokenTypes.java:94
com.jogamp.gluegen.cgram.STDCTokenTypes.CharLiteral
int CharLiteral
Definition: STDCTokenTypes.java:108
com.jogamp.gluegen.cgram.STDCTokenTypes.ID
int ID
Definition: STDCTokenTypes.java:51
com.jogamp.gluegen.cgram.STDCTokenTypes.Digit
int Digit
Definition: STDCTokenTypes.java:162
com.jogamp.gluegen.cgram.STDCTokenTypes.PLUS_ASSIGN
int PLUS_ASSIGN
Definition: STDCTokenTypes.java:74
com.jogamp.gluegen.cgram.STDCTokenTypes.BOR
int BOR
Definition: STDCTokenTypes.java:86
com.jogamp.gluegen.cgram.STDCTokenTypes.VARARGS
int VARARGS
Definition: STDCTokenTypes.java:60
com.jogamp.gluegen.cgram.STDCTokenTypes.IntHexConst
int IntHexConst
Definition: STDCTokenTypes.java:116
com.jogamp.gluegen.cgram.STDCTokenTypes.FloatDoubleConst
int FloatDoubleConst
Definition: STDCTokenTypes.java:119
com.jogamp.gluegen.cgram.STDCTokenTypes.Escape
int Escape
Definition: STDCTokenTypes.java:161
com.jogamp.gluegen.cgram.STDCTokenTypes.Vocabulary
int Vocabulary
Definition: STDCTokenTypes.java:150
com.jogamp.gluegen.cgram.STDCTokenTypes.UnsignedIntConst
int UnsignedIntConst
Definition: STDCTokenTypes.java:115
com.jogamp.gluegen.cgram.STDCTokenTypes.BXOR
int BXOR
Definition: STDCTokenTypes.java:87
com.jogamp.gluegen.cgram.STDCTokenTypes.FloatSuffix
int FloatSuffix
Definition: STDCTokenTypes.java:165
com.jogamp.gluegen.cgram.STDCTokenTypes.DEC
int DEC
Definition: STDCTokenTypes.java:102
com.jogamp.gluegen.cgram.STDCTokenTypes.MOD_ASSIGN
int MOD_ASSIGN
Definition: STDCTokenTypes.java:77
com.jogamp.gluegen.cgram.STDCTokenTypes.BadStringLiteral
int BadStringLiteral
Definition: STDCTokenTypes.java:160
com.jogamp.gluegen.cgram.STDCTokenTypes.DoubleDoubleConst
int DoubleDoubleConst
Definition: STDCTokenTypes.java:120
com.jogamp.gluegen.cgram.STDCTokenTypes.NonWhitespace
int NonWhitespace
Definition: STDCTokenTypes.java:154
com.jogamp.gluegen.cgram.STDCTokenTypes.DefineExpr
int DefineExpr
Definition: STDCTokenTypes.java:156
com.jogamp.gluegen.cgram.STDCTokenTypes.INC
int INC
Definition: STDCTokenTypes.java:101
com.jogamp.gluegen.cgram.STDCTokenTypes.Whitespace
int Whitespace
Definition: STDCTokenTypes.java:151
com.jogamp.gluegen.cgram.STDCTokenTypes.RPAREN
int RPAREN
Definition: STDCTokenTypes.java:57
com.jogamp.gluegen.cgram.STDCTokenTypes.LT
int LT
Definition: STDCTokenTypes.java:91
com.jogamp.gluegen.cgram.STDCTokenTypes.LongIntConst
int LongIntConst
Definition: STDCTokenTypes.java:114
com.jogamp.gluegen.cgram.STDCTokenTypes.RSHIFT
int RSHIFT
Definition: STDCTokenTypes.java:96
com.jogamp.gluegen.cgram.STDCTokenTypes.QUESTION
int QUESTION
Definition: STDCTokenTypes.java:83
com.jogamp.gluegen.cgram.STDCTokenTypes.NOT_EQUAL
int NOT_EQUAL
Definition: STDCTokenTypes.java:90
com.jogamp.gluegen.cgram.STDCTokenTypes.StringLiteral
int StringLiteral
Definition: STDCTokenTypes.java:109
com.jogamp.gluegen.cgram.STDCTokenTypes.EQUAL
int EQUAL
Definition: STDCTokenTypes.java:89
com.jogamp.gluegen.cgram.STDCTokenTypes.BAND
int BAND
Definition: STDCTokenTypes.java:88
com.jogamp.gluegen.cgram.STDCTokenTypes.PTR
int PTR
Definition: STDCTokenTypes.java:106
com.jogamp.gluegen.cgram.STDCTokenTypes.LongDoubleConst
int LongDoubleConst
Definition: STDCTokenTypes.java:121
com.jogamp.gluegen.cgram.STDCTokenTypes.IntIntConst
int IntIntConst
Definition: STDCTokenTypes.java:113
com.jogamp.gluegen.cgram.STDCTokenTypes.LPAREN
int LPAREN
Definition: STDCTokenTypes.java:56
com.jogamp.gluegen.cgram.STDCTokenTypes.MINUS_ASSIGN
int MINUS_ASSIGN
Definition: STDCTokenTypes.java:75
com.jogamp.gluegen.cgram.STDCTokenTypes.UnsignedHexConst
int UnsignedHexConst
Definition: STDCTokenTypes.java:118
com.jogamp.gluegen.cgram.STDCTokenTypes.DIV_ASSIGN
int DIV_ASSIGN
Definition: STDCTokenTypes.java:73
com.jogamp.gluegen.cgram.STDCTokenTypes.PLUS
int PLUS
Definition: STDCTokenTypes.java:97
com.jogamp.gluegen.cgram.STDCTokenTypes.BNOT
int BNOT
Definition: STDCTokenTypes.java:104
com.jogamp.gluegen.cgram.STDCTokenTypes.MINUS
int MINUS
Definition: STDCTokenTypes.java:98
com.jogamp.gluegen.cgram.STDCTokenTypes.Exponent
int Exponent
Definition: STDCTokenTypes.java:166
com.jogamp.gluegen.cgram.STDCTokenTypes.PREPROC_DIRECTIVE
int PREPROC_DIRECTIVE
Definition: STDCTokenTypes.java:155
com.jogamp.gluegen.cgram.STDCTokenTypes.COLON
int COLON
Definition: STDCTokenTypes.java:53
com.jogamp.gluegen.cgram.STDCTokenTypes.DIV
int DIV
Definition: STDCTokenTypes.java:99
com.jogamp.gluegen.cgram.STDCTokenTypes.UnsignedSuffix
int UnsignedSuffix
Definition: STDCTokenTypes.java:164
com.jogamp.gluegen.cgram.STDCTokenTypes.COMMA
int COMMA
Definition: STDCTokenTypes.java:52
com.jogamp.gluegen.cgram.STDCTokenTypes.Number
int Number
Definition: STDCTokenTypes.java:167
com.jogamp.gluegen.cgram.STDCTokenTypes.RCURLY
int RCURLY
Definition: STDCTokenTypes.java:17
com.jogamp.gluegen.cgram.STDCTokenTypes.BOR_ASSIGN
int BOR_ASSIGN
Definition: STDCTokenTypes.java:81
com.jogamp.gluegen.cgram.STDCTokenTypes.Comment
int Comment
Definition: STDCTokenTypes.java:152
com.jogamp.gluegen.cgram.STDCTokenTypes.STAR
int STAR
Definition: STDCTokenTypes.java:55
com.jogamp.gluegen.cgram.STDCTokenTypes.RSHIFT_ASSIGN
int RSHIFT_ASSIGN
Definition: STDCTokenTypes.java:78
com.jogamp.gluegen.cgram.STDCTokenTypes.LineDirective
int LineDirective
Definition: STDCTokenTypes.java:159
com.jogamp.gluegen.cgram.STDCTokenTypes.LongHexConst
int LongHexConst
Definition: STDCTokenTypes.java:117
com.jogamp.gluegen.cgram.STDCTokenTypes.IntOctalConst
int IntOctalConst
Definition: STDCTokenTypes.java:110
com.jogamp.gluegen.cgram.STDCTokenTypes.SEMI
int SEMI
Definition: STDCTokenTypes.java:18
com.jogamp.gluegen.cgram.STDCTokenTypes.STAR_ASSIGN
int STAR_ASSIGN
Definition: STDCTokenTypes.java:76
com.jogamp.gluegen.cgram.STDCTokenTypes.LTE
int LTE
Definition: STDCTokenTypes.java:92
com.jogamp.gluegen.cgram.STDCTokenTypes.LCURLY
int LCURLY
Definition: STDCTokenTypes.java:16
com.jogamp.gluegen.cgram.STDCTokenTypes.LongSuffix
int LongSuffix
Definition: STDCTokenTypes.java:163
com.jogamp.gluegen.cgram.STDCTokenTypes.LBRACKET
int LBRACKET
Definition: STDCTokenTypes.java:58
com.jogamp.gluegen.cgram.STDCTokenTypes.BXOR_ASSIGN
int BXOR_ASSIGN
Definition: STDCTokenTypes.java:82
com.jogamp.gluegen.cgram.STDCTokenTypes.RBRACKET
int RBRACKET
Definition: STDCTokenTypes.java:59
com.jogamp.gluegen.cgram.STDCTokenTypes.CPPComment
int CPPComment
Definition: STDCTokenTypes.java:153
com.jogamp.gluegen.cgram.STDCTokenTypes.Space
int Space
Definition: STDCTokenTypes.java:158
com.jogamp.gluegen.cgram.STDCTokenTypes.ASSIGN
int ASSIGN
Definition: STDCTokenTypes.java:54
com.jogamp.gluegen.cgram.STDCTokenTypes.LSHIFT
int LSHIFT
Definition: STDCTokenTypes.java:95
com.jogamp.gluegen.cgram.STDCTokenTypes.GT
int GT
Definition: STDCTokenTypes.java:93
com.jogamp.gluegen.cgram.STDCTokenTypes.LongOctalConst
int LongOctalConst
Definition: STDCTokenTypes.java:111
com.jogamp.gluegen.cgram.STDCTokenTypes.LAND
int LAND
Definition: STDCTokenTypes.java:85
com.jogamp.gluegen.cgram.STDCTokenTypes.LOR
int LOR
Definition: STDCTokenTypes.java:84
com.jogamp.gluegen.cgram.STDCTokenTypes.LSHIFT_ASSIGN
int LSHIFT_ASSIGN
Definition: STDCTokenTypes.java:79
com.jogamp.gluegen.cgram.STDCTokenTypes.DOT
int DOT
Definition: STDCTokenTypes.java:107
com.jogamp.gluegen.cgram.STDCTokenTypes.UnsignedOctalConst
int UnsignedOctalConst
Definition: STDCTokenTypes.java:112
com.jogamp.gluegen.cgram.STDCTokenTypes.LNOT
int LNOT
Definition: STDCTokenTypes.java:105
com.jogamp.gluegen.cgram.STDCTokenTypes.DefineExpr2
int DefineExpr2
Definition: STDCTokenTypes.java:157