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