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

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

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