1/** \file 2 * This C source file was generated by $ANTLR version 3.2 debian-5 3 * 4 * - From the grammar source file : RSP.g 5 * - On : 2011-09-11 15:48:51 6 * - for the lexer : RSPLexerLexer * 7 * Editing it, at least manually, is not wise. 8 * 9 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws. 10 * 11 * 12*/ 13// [The "BSD licence"] 14// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC 15// http://www.temporal-wave.com 16// http://www.linkedin.com/in/jimidle 17// 18// All rights reserved. 19// 20// Redistribution and use in source and binary forms, with or without 21// modification, are permitted provided that the following conditions 22// are met: 23// 1. Redistributions of source code must retain the above copyright 24// notice, this list of conditions and the following disclaimer. 25// 2. Redistributions in binary form must reproduce the above copyright 26// notice, this list of conditions and the following disclaimer in the 27// documentation and/or other materials provided with the distribution. 28// 3. The name of the author may not be used to endorse or promote products 29// derived from this software without specific prior written permission. 30// 31// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 32// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 33// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 34// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 35// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 36// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 37// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 38// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 39// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 40// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 41 42/* ----------------------------------------- 43 * Include the ANTLR3 generated header file. 44 */ 45#include "RSPLexer.h" 46/* ----------------------------------------- */ 47 48 49/** String literals used by RSPLexer that we must do things like MATCHS() with. 50 * C will normally just lay down 8 bit characters, and you can use L"xxx" to 51 * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so 52 * we perform this little trick of defining the literals as arrays of UINT32 53 * and passing in the address of these. 54 */ 55static ANTLR3_UCHAR lit_1[] = { 0x61, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR}; 56static ANTLR3_UCHAR lit_2[] = { 0x6F, 0x72, ANTLR3_STRING_TERMINATOR}; 57static ANTLR3_UCHAR lit_3[] = { 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65, 0x73, ANTLR3_STRING_TERMINATOR}; 58static ANTLR3_UCHAR lit_4[] = { 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x77, 0x69, 0x74, 0x68, ANTLR3_STRING_TERMINATOR}; 59static ANTLR3_UCHAR lit_5[] = { 0x65, 0x6E, 0x64, 0x73, 0x77, 0x69, 0x74, 0x68, ANTLR3_STRING_TERMINATOR}; 60static ANTLR3_UCHAR lit_6[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR}; 61static ANTLR3_UCHAR lit_7[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR}; 62static ANTLR3_UCHAR lit_8[] = { 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, ANTLR3_STRING_TERMINATOR}; 63static ANTLR3_UCHAR lit_9[] = { 0x61, 0x66, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR}; 64static ANTLR3_UCHAR lit_10[] = { 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR}; 65static ANTLR3_UCHAR lit_11[] = { 0x64, 0x61, 0x79, 0x73, ANTLR3_STRING_TERMINATOR}; 66static ANTLR3_UCHAR lit_12[] = { 0x77, 0x65, 0x65, 0x6B, ANTLR3_STRING_TERMINATOR}; 67static ANTLR3_UCHAR lit_13[] = { 0x77, 0x65, 0x65, 0x6B, 0x73, ANTLR3_STRING_TERMINATOR}; 68static ANTLR3_UCHAR lit_14[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, ANTLR3_STRING_TERMINATOR}; 69static ANTLR3_UCHAR lit_15[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x73, ANTLR3_STRING_TERMINATOR}; 70static ANTLR3_UCHAR lit_16[] = { 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR}; 71static ANTLR3_UCHAR lit_17[] = { 0x79, 0x65, 0x61, 0x72, 0x73, ANTLR3_STRING_TERMINATOR}; 72static ANTLR3_UCHAR lit_18[] = { 0x74, 0x6F, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR}; 73 74 75 76 77/* MACROS that hide the C interface implementations from the 78 * generated code, which makes it a little more understandable to the human eye. 79 * I am very much against using C pre-processor macros for function calls and bits 80 * of code as you cannot see what is happening when single stepping in debuggers 81 * and so on. The exception (in my book at least) is for generated code, where you are 82 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input() 83 * hides some indirect calls, but is always referring to the input stream. This is 84 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig 85 * the runtime interfaces without changing the generated code too often, without 86 * confusing the reader of the generated output, who may not wish to know the gory 87 * details of the interface inheritance. 88 */ 89 90#define CTX ctx 91 92/* Aids in accessing scopes for grammar programmers 93 */ 94#undef SCOPE_TYPE 95#undef SCOPE_STACK 96#undef SCOPE_TOP 97#define SCOPE_TYPE(scope) pRSPLexer_##scope##_SCOPE 98#define SCOPE_STACK(scope) pRSPLexer_##scope##Stack 99#define SCOPE_TOP(scope) ctx->pRSPLexer_##scope##Top 100#define SCOPE_SIZE(scope) ctx->pRSPLexer_##scope##Stack_limit 101#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i)) 102 103 104/* Macros for accessing things in a lexer 105 */ 106#undef LEXER 107#undef RECOGNIZER 108#undef RULEMEMO 109#undef GETCHARINDEX 110#undef GETLINE 111#undef GETCHARPOSITIONINLINE 112#undef EMIT 113#undef EMITNEW 114#undef MATCHC 115#undef MATCHS 116#undef MATCHRANGE 117#undef LTOKEN 118#undef HASFAILED 119#undef FAILEDFLAG 120#undef INPUT 121#undef STRSTREAM 122#undef LA 123#undef HASEXCEPTION 124#undef EXCEPTION 125#undef CONSTRUCTEX 126#undef CONSUME 127#undef LRECOVER 128#undef MARK 129#undef REWIND 130#undef REWINDLAST 131#undef BACKTRACKING 132#undef MATCHANY 133#undef MEMOIZE 134#undef HAVEPARSEDRULE 135#undef GETTEXT 136#undef INDEX 137#undef SEEK 138#undef PUSHSTREAM 139#undef POPSTREAM 140#undef SETTEXT 141#undef SETTEXT8 142 143#define LEXER ctx->pLexer 144#define RECOGNIZER LEXER->rec 145#define LEXSTATE RECOGNIZER->state 146#define TOKSOURCE LEXSTATE->tokSource 147#define GETCHARINDEX() LEXER->getCharIndex(LEXER) 148#define GETLINE() LEXER->getLine(LEXER) 149#define GETTEXT() LEXER->getText(LEXER) 150#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER) 151#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER) 152#define EMITNEW(t) LEXER->emitNew(LEXER, t) 153#define MATCHC(c) LEXER->matchc(LEXER, c) 154#define MATCHS(s) LEXER->matchs(LEXER, s) 155#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2) 156#define MATCHANY() LEXER->matchAny(LEXER) 157#define LTOKEN LEXSTATE->token 158#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE) 159#define BACKTRACKING LEXSTATE->backtracking 160#define FAILEDFLAG LEXSTATE->failed 161#define INPUT LEXER->input 162#define STRSTREAM INPUT 163#define ISTREAM INPUT->istream 164#define INDEX() ISTREAM->index(ISTREAM) 165#define SEEK(n) ISTREAM->seek(ISTREAM, n) 166#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken) 167#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE) 168#define EXCEPTION LEXSTATE->exception 169#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER) 170#define LRECOVER() LEXER->recover(LEXER) 171#define MARK() ISTREAM->mark(ISTREAM) 172#define REWIND(m) ISTREAM->rewind(ISTREAM, m) 173#define REWINDLAST() ISTREAM->rewindLast(ISTREAM) 174#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si) 175#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r) 176#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str) 177#define POPSTREAM() LEXER->popCharStream(LEXER) 178#define SETTEXT(str) LEXSTATE->text = str 179#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken) 180#define USER1 LEXSTATE->user1 181#define USER2 LEXSTATE->user2 182#define USER3 LEXSTATE->user3 183#define CUSTOM LEXSTATE->custom 184#define RULEMEMO LEXSTATE->ruleMemo 185#define DBG RECOGNIZER->debugger 186 187/* If we have been told we can rely on the standard 8 bit or 16 bit input 188 * stream, then we can define our macros to use the direct pointers 189 * in the input object, which is much faster than indirect calls. This 190 * is really only significant to lexers with a lot of fragment rules (which 191 * do not place LA(1) in a temporary at the moment) and even then 192 * only if there is a lot of input (order of say 1M or so). 193 */ 194#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16) 195 196# ifdef ANTLR3_INLINE_INPUT_ASCII 197 198/* 8 bit "ASCII" (actually any 8 bit character set) */ 199 200# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar)) 201# define DATAP ((pANTLR3_UINT8)(INPUT->data)) 202 203# else 204 205# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar)) 206# define DATAP ((pANTLR3_UINT16)(INPUT->data)) 207 208# endif 209 210# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1))) 211# define CONSUME() \ 212{ \ 213 if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \ 214 { \ 215 INPUT->charPositionInLine++; \ 216 if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \ 217 { \ 218 INPUT->line++; \ 219 INPUT->charPositionInLine = 0; \ 220 INPUT->currentLine = (void *)(NEXTCHAR + 1); \ 221 } \ 222 INPUT->nextChar = (void *)(NEXTCHAR + 1); \ 223 } \ 224} 225 226#else 227 228// Pick up the input character by calling the input stream implementation. 229// 230#define CONSUME() INPUT->istream->consume(INPUT->istream) 231#define LA(n) INPUT->istream->_LA(INPUT->istream, n) 232 233#endif 234#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt 235 236/* The 4 tokens defined below may well clash with your own #defines or token types. If so 237 * then for the present you must use different names for your defines as these are hard coded 238 * in the code generator. It would be better not to use such names internally, and maybe 239 * we can change this in a forthcoming release. I deliberately do not #undef these 240 * here as this will at least give you a redefined error somewhere if they clash. 241 */ 242#define UP ANTLR3_TOKEN_UP 243#define DOWN ANTLR3_TOKEN_DOWN 244#define EOR ANTLR3_TOKEN_EOR 245#define INVALID ANTLR3_TOKEN_INVALID 246 247 248/* ============================================================================= 249 * Functions to create and destroy scopes. First come the rule scopes, followed 250 * by the global declared scopes. 251 */ 252 253 254 255/* ============================================================================= */ 256 257/* ============================================================================= 258 * Start of recognizer 259 */ 260 261 262/* Forward declare the locally static matching functions we have generated and any predicate functions. 263 */ 264static ANTLR3_INLINE void mQUOTE (pRSPLexer ctx); 265static ANTLR3_INLINE void mLPAR (pRSPLexer ctx); 266static ANTLR3_INLINE void mRPAR (pRSPLexer ctx); 267static ANTLR3_INLINE void mAND (pRSPLexer ctx); 268static ANTLR3_INLINE void mOR (pRSPLexer ctx); 269static ANTLR3_INLINE void mNOT (pRSPLexer ctx); 270static ANTLR3_INLINE void mEQUAL (pRSPLexer ctx); 271static ANTLR3_INLINE void mINCLUDES (pRSPLexer ctx); 272static ANTLR3_INLINE void mSTARTSW (pRSPLexer ctx); 273static ANTLR3_INLINE void mENDSW (pRSPLexer ctx); 274static ANTLR3_INLINE void mGREATER (pRSPLexer ctx); 275static ANTLR3_INLINE void mLESS (pRSPLexer ctx); 276static ANTLR3_INLINE void mGTE (pRSPLexer ctx); 277static ANTLR3_INLINE void mLTE (pRSPLexer ctx); 278static ANTLR3_INLINE void mBEFORE (pRSPLexer ctx); 279static ANTLR3_INLINE void mAFTER (pRSPLexer ctx); 280static ANTLR3_INLINE void mDAY (pRSPLexer ctx); 281static ANTLR3_INLINE void mWEEK (pRSPLexer ctx); 282static ANTLR3_INLINE void mMONTH (pRSPLexer ctx); 283static ANTLR3_INLINE void mYEAR (pRSPLexer ctx); 284static ANTLR3_INLINE void mTODAY (pRSPLexer ctx); 285static ANTLR3_INLINE void mNEWLINE (pRSPLexer ctx); 286static ANTLR3_INLINE void mWS (pRSPLexer ctx); 287static ANTLR3_INLINE void mFIELD (pRSPLexer ctx); 288static ANTLR3_INLINE void mINT (pRSPLexer ctx); 289static ANTLR3_INLINE void mDATE (pRSPLexer ctx); 290static ANTLR3_INLINE void mSTR (pRSPLexer ctx); 291static ANTLR3_INLINE void mESCAPED (pRSPLexer ctx); 292static ANTLR3_INLINE void mDIGIT09 (pRSPLexer ctx); 293static ANTLR3_INLINE void mDIGIT19 (pRSPLexer ctx); 294static ANTLR3_INLINE void mTokens (pRSPLexer ctx); 295static void RSPLexerFree(pRSPLexer ctx); 296 297/* ========================================================================= 298 * Lexer matching rules end. 299 * ========================================================================= 300 */ 301 302 303 304static void 305RSPLexerFree (pRSPLexer ctx) 306{ 307 LEXER->free(LEXER); 308 309 ANTLR3_FREE(ctx); 310} 311 312/** \brief Name of the grammar file that generated this code 313 */ 314static const char fileName[] = "RSP.g"; 315 316/** \brief Return the name of the grammar file that generated this code. 317 */ 318static const char * getGrammarFileName() 319{ 320 return fileName; 321} 322 323/** \brief Create a new lexer called RSPLexer 324 * 325 * \param[in] instream Pointer to an initialized input stream 326 * \return 327 * - Success pRSPLexer initialized for the lex start 328 * - Fail NULL 329 */ 330ANTLR3_API pRSPLexer RSPLexerNew 331(pANTLR3_INPUT_STREAM instream) 332{ 333 // See if we can create a new lexer with the standard constructor 334 // 335 return RSPLexerNewSSD(instream, NULL); 336} 337 338/** \brief Create a new lexer called RSPLexer 339 * 340 * \param[in] instream Pointer to an initialized input stream 341 * \param[state] state Previously created shared recognizer stat 342 * \return 343 * - Success pRSPLexer initialized for the lex start 344 * - Fail NULL 345 */ 346ANTLR3_API pRSPLexer RSPLexerNewSSD 347(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) 348{ 349 pRSPLexer ctx; // Context structure we will build and return 350 351 ctx = (pRSPLexer) ANTLR3_CALLOC(1, sizeof(RSPLexer)); 352 353 if (ctx == NULL) 354 { 355 // Failed to allocate memory for lexer context 356 return NULL; 357 } 358 359 /* ------------------------------------------------------------------- 360 * Memory for basic structure is allocated, now to fill in 361 * in base ANTLR3 structures. We initialize the function pointers 362 * for the standard ANTLR3 lexer function set, but upon return 363 * from here, the programmer may set the pointers to provide custom 364 * implementations of each function. 365 * 366 * We don't use the macros defined in RSPLexer.h here so you can get a sense 367 * of what goes where. 368 */ 369 370 /* Create a base lexer, using the supplied input stream 371 */ 372 ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state); 373 374 /* Check that we allocated the memory correctly 375 */ 376 if (ctx->pLexer == NULL) 377 { 378 ANTLR3_FREE(ctx); 379 return NULL; 380 } 381 /* Install the implementation of our RSPLexer interface 382 */ 383 ctx->mQUOTE = mQUOTE; 384 ctx->mLPAR = mLPAR; 385 ctx->mRPAR = mRPAR; 386 ctx->mAND = mAND; 387 ctx->mOR = mOR; 388 ctx->mNOT = mNOT; 389 ctx->mEQUAL = mEQUAL; 390 ctx->mINCLUDES = mINCLUDES; 391 ctx->mSTARTSW = mSTARTSW; 392 ctx->mENDSW = mENDSW; 393 ctx->mGREATER = mGREATER; 394 ctx->mLESS = mLESS; 395 ctx->mGTE = mGTE; 396 ctx->mLTE = mLTE; 397 ctx->mBEFORE = mBEFORE; 398 ctx->mAFTER = mAFTER; 399 ctx->mDAY = mDAY; 400 ctx->mWEEK = mWEEK; 401 ctx->mMONTH = mMONTH; 402 ctx->mYEAR = mYEAR; 403 ctx->mTODAY = mTODAY; 404 ctx->mNEWLINE = mNEWLINE; 405 ctx->mWS = mWS; 406 ctx->mFIELD = mFIELD; 407 ctx->mINT = mINT; 408 ctx->mDATE = mDATE; 409 ctx->mSTR = mSTR; 410 ctx->mESCAPED = mESCAPED; 411 ctx->mDIGIT09 = mDIGIT09; 412 ctx->mDIGIT19 = mDIGIT19; 413 ctx->mTokens = mTokens; 414 415 /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE 416 * it will call mTokens() in this generated code, and will pass it the ctx 417 * pointer of this lexer, not the context of the base lexer, so store that now. 418 */ 419 ctx->pLexer->ctx = ctx; 420 421 /**Install the token matching function 422 */ 423 ctx->pLexer->mTokens = (void (*) (void *))(mTokens); 424 425 ctx->getGrammarFileName = getGrammarFileName; 426 ctx->free = RSPLexerFree; 427 428 429 430 431 432 /* Return the newly built lexer to the caller 433 */ 434 return ctx; 435} 436 437 438/* ========================================================================= 439 * Functions to match the lexer grammar defined tokens from the input stream 440 */ 441 442// Comes from: 85:7: ( '\"' ) 443/** \brief Lexer rule generated by ANTLR3 444 * 445 * $ANTLR start QUOTE 446 * 447 * Looks to match the characters the constitute the token QUOTE 448 * from the attached input stream. 449 * 450 * 451 * \remark 452 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 453 */ 454static ANTLR3_INLINE 455void mQUOTE(pRSPLexer ctx) 456{ 457 ANTLR3_UINT32 _type; 458 459 _type = QUOTE; 460 461 462 // RSP.g:85:7: ( '\"' ) 463 // RSP.g:85:9: '\"' 464 { 465 MATCHC('"'); 466 if (HASEXCEPTION()) 467 { 468 goto ruleQUOTEEx; 469 } 470 471 472 } 473 474 LEXSTATE->type = _type; 475 476 // This is where rules clean up and exit 477 // 478 goto ruleQUOTEEx; /* Prevent compiler warnings */ 479 ruleQUOTEEx: ; 480 481} 482// $ANTLR end QUOTE 483 484// Comes from: 86:6: ( '(' ) 485/** \brief Lexer rule generated by ANTLR3 486 * 487 * $ANTLR start LPAR 488 * 489 * Looks to match the characters the constitute the token LPAR 490 * from the attached input stream. 491 * 492 * 493 * \remark 494 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 495 */ 496static ANTLR3_INLINE 497void mLPAR(pRSPLexer ctx) 498{ 499 ANTLR3_UINT32 _type; 500 501 _type = LPAR; 502 503 504 // RSP.g:86:6: ( '(' ) 505 // RSP.g:86:8: '(' 506 { 507 MATCHC('('); 508 if (HASEXCEPTION()) 509 { 510 goto ruleLPAREx; 511 } 512 513 514 } 515 516 LEXSTATE->type = _type; 517 518 // This is where rules clean up and exit 519 // 520 goto ruleLPAREx; /* Prevent compiler warnings */ 521 ruleLPAREx: ; 522 523} 524// $ANTLR end LPAR 525 526// Comes from: 87:6: ( ')' ) 527/** \brief Lexer rule generated by ANTLR3 528 * 529 * $ANTLR start RPAR 530 * 531 * Looks to match the characters the constitute the token RPAR 532 * from the attached input stream. 533 * 534 * 535 * \remark 536 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 537 */ 538static ANTLR3_INLINE 539void mRPAR(pRSPLexer ctx) 540{ 541 ANTLR3_UINT32 _type; 542 543 _type = RPAR; 544 545 546 // RSP.g:87:6: ( ')' ) 547 // RSP.g:87:8: ')' 548 { 549 MATCHC(')'); 550 if (HASEXCEPTION()) 551 { 552 goto ruleRPAREx; 553 } 554 555 556 } 557 558 LEXSTATE->type = _type; 559 560 // This is where rules clean up and exit 561 // 562 goto ruleRPAREx; /* Prevent compiler warnings */ 563 ruleRPAREx: ; 564 565} 566// $ANTLR end RPAR 567 568// Comes from: 89:5: ( 'and' ) 569/** \brief Lexer rule generated by ANTLR3 570 * 571 * $ANTLR start AND 572 * 573 * Looks to match the characters the constitute the token AND 574 * from the attached input stream. 575 * 576 * 577 * \remark 578 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 579 */ 580static ANTLR3_INLINE 581void mAND(pRSPLexer ctx) 582{ 583 ANTLR3_UINT32 _type; 584 585 _type = AND; 586 587 588 // RSP.g:89:5: ( 'and' ) 589 // RSP.g:89:7: 'and' 590 { 591 MATCHS(lit_1); 592 if (HASEXCEPTION()) 593 { 594 goto ruleANDEx; 595 } 596 597 598 599 } 600 601 LEXSTATE->type = _type; 602 603 // This is where rules clean up and exit 604 // 605 goto ruleANDEx; /* Prevent compiler warnings */ 606 ruleANDEx: ; 607 608} 609// $ANTLR end AND 610 611// Comes from: 90:4: ( 'or' ) 612/** \brief Lexer rule generated by ANTLR3 613 * 614 * $ANTLR start OR 615 * 616 * Looks to match the characters the constitute the token OR 617 * from the attached input stream. 618 * 619 * 620 * \remark 621 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 622 */ 623static ANTLR3_INLINE 624void mOR(pRSPLexer ctx) 625{ 626 ANTLR3_UINT32 _type; 627 628 _type = OR; 629 630 631 // RSP.g:90:4: ( 'or' ) 632 // RSP.g:90:6: 'or' 633 { 634 MATCHS(lit_2); 635 if (HASEXCEPTION()) 636 { 637 goto ruleOREx; 638 } 639 640 641 642 } 643 644 LEXSTATE->type = _type; 645 646 // This is where rules clean up and exit 647 // 648 goto ruleOREx; /* Prevent compiler warnings */ 649 ruleOREx: ; 650 651} 652// $ANTLR end OR 653 654// Comes from: 91:5: ( '!' ) 655/** \brief Lexer rule generated by ANTLR3 656 * 657 * $ANTLR start NOT 658 * 659 * Looks to match the characters the constitute the token NOT 660 * from the attached input stream. 661 * 662 * 663 * \remark 664 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 665 */ 666static ANTLR3_INLINE 667void mNOT(pRSPLexer ctx) 668{ 669 ANTLR3_UINT32 _type; 670 671 _type = NOT; 672 673 674 // RSP.g:91:5: ( '!' ) 675 // RSP.g:91:7: '!' 676 { 677 MATCHC('!'); 678 if (HASEXCEPTION()) 679 { 680 goto ruleNOTEx; 681 } 682 683 684 } 685 686 LEXSTATE->type = _type; 687 688 // This is where rules clean up and exit 689 // 690 goto ruleNOTEx; /* Prevent compiler warnings */ 691 ruleNOTEx: ; 692 693} 694// $ANTLR end NOT 695 696// Comes from: 94:7: ( '=' ) 697/** \brief Lexer rule generated by ANTLR3 698 * 699 * $ANTLR start EQUAL 700 * 701 * Looks to match the characters the constitute the token EQUAL 702 * from the attached input stream. 703 * 704 * 705 * \remark 706 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 707 */ 708static ANTLR3_INLINE 709void mEQUAL(pRSPLexer ctx) 710{ 711 ANTLR3_UINT32 _type; 712 713 _type = EQUAL; 714 715 716 // RSP.g:94:7: ( '=' ) 717 // RSP.g:94:9: '=' 718 { 719 MATCHC('='); 720 if (HASEXCEPTION()) 721 { 722 goto ruleEQUALEx; 723 } 724 725 726 } 727 728 LEXSTATE->type = _type; 729 730 // This is where rules clean up and exit 731 // 732 goto ruleEQUALEx; /* Prevent compiler warnings */ 733 ruleEQUALEx: ; 734 735} 736// $ANTLR end EQUAL 737 738// Comes from: 97:9: ( 'includes' ) 739/** \brief Lexer rule generated by ANTLR3 740 * 741 * $ANTLR start INCLUDES 742 * 743 * Looks to match the characters the constitute the token INCLUDES 744 * from the attached input stream. 745 * 746 * 747 * \remark 748 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 749 */ 750static ANTLR3_INLINE 751void mINCLUDES(pRSPLexer ctx) 752{ 753 ANTLR3_UINT32 _type; 754 755 _type = INCLUDES; 756 757 758 // RSP.g:97:9: ( 'includes' ) 759 // RSP.g:97:11: 'includes' 760 { 761 MATCHS(lit_3); 762 if (HASEXCEPTION()) 763 { 764 goto ruleINCLUDESEx; 765 } 766 767 768 769 } 770 771 LEXSTATE->type = _type; 772 773 // This is where rules clean up and exit 774 // 775 goto ruleINCLUDESEx; /* Prevent compiler warnings */ 776 ruleINCLUDESEx: ; 777 778} 779// $ANTLR end INCLUDES 780 781// Comes from: 98:9: ( 'startswith' ) 782/** \brief Lexer rule generated by ANTLR3 783 * 784 * $ANTLR start STARTSW 785 * 786 * Looks to match the characters the constitute the token STARTSW 787 * from the attached input stream. 788 * 789 * 790 * \remark 791 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 792 */ 793static ANTLR3_INLINE 794void mSTARTSW(pRSPLexer ctx) 795{ 796 ANTLR3_UINT32 _type; 797 798 _type = STARTSW; 799 800 801 // RSP.g:98:9: ( 'startswith' ) 802 // RSP.g:98:11: 'startswith' 803 { 804 MATCHS(lit_4); 805 if (HASEXCEPTION()) 806 { 807 goto ruleSTARTSWEx; 808 } 809 810 811 812 } 813 814 LEXSTATE->type = _type; 815 816 // This is where rules clean up and exit 817 // 818 goto ruleSTARTSWEx; /* Prevent compiler warnings */ 819 ruleSTARTSWEx: ; 820 821} 822// $ANTLR end STARTSW 823 824// Comes from: 99:7: ( 'endswith' ) 825/** \brief Lexer rule generated by ANTLR3 826 * 827 * $ANTLR start ENDSW 828 * 829 * Looks to match the characters the constitute the token ENDSW 830 * from the attached input stream. 831 * 832 * 833 * \remark 834 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 835 */ 836static ANTLR3_INLINE 837void mENDSW(pRSPLexer ctx) 838{ 839 ANTLR3_UINT32 _type; 840 841 _type = ENDSW; 842 843 844 // RSP.g:99:7: ( 'endswith' ) 845 // RSP.g:99:9: 'endswith' 846 { 847 MATCHS(lit_5); 848 if (HASEXCEPTION()) 849 { 850 goto ruleENDSWEx; 851 } 852 853 854 855 } 856 857 LEXSTATE->type = _type; 858 859 // This is where rules clean up and exit 860 // 861 goto ruleENDSWEx; /* Prevent compiler warnings */ 862 ruleENDSWEx: ; 863 864} 865// $ANTLR end ENDSW 866 867// Comes from: 102:9: ( '>' ) 868/** \brief Lexer rule generated by ANTLR3 869 * 870 * $ANTLR start GREATER 871 * 872 * Looks to match the characters the constitute the token GREATER 873 * from the attached input stream. 874 * 875 * 876 * \remark 877 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 878 */ 879static ANTLR3_INLINE 880void mGREATER(pRSPLexer ctx) 881{ 882 ANTLR3_UINT32 _type; 883 884 _type = GREATER; 885 886 887 // RSP.g:102:9: ( '>' ) 888 // RSP.g:102:11: '>' 889 { 890 MATCHC('>'); 891 if (HASEXCEPTION()) 892 { 893 goto ruleGREATEREx; 894 } 895 896 897 } 898 899 LEXSTATE->type = _type; 900 901 // This is where rules clean up and exit 902 // 903 goto ruleGREATEREx; /* Prevent compiler warnings */ 904 ruleGREATEREx: ; 905 906} 907// $ANTLR end GREATER 908 909// Comes from: 103:6: ( '<' ) 910/** \brief Lexer rule generated by ANTLR3 911 * 912 * $ANTLR start LESS 913 * 914 * Looks to match the characters the constitute the token LESS 915 * from the attached input stream. 916 * 917 * 918 * \remark 919 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 920 */ 921static ANTLR3_INLINE 922void mLESS(pRSPLexer ctx) 923{ 924 ANTLR3_UINT32 _type; 925 926 _type = LESS; 927 928 929 // RSP.g:103:6: ( '<' ) 930 // RSP.g:103:8: '<' 931 { 932 MATCHC('<'); 933 if (HASEXCEPTION()) 934 { 935 goto ruleLESSEx; 936 } 937 938 939 } 940 941 LEXSTATE->type = _type; 942 943 // This is where rules clean up and exit 944 // 945 goto ruleLESSEx; /* Prevent compiler warnings */ 946 ruleLESSEx: ; 947 948} 949// $ANTLR end LESS 950 951// Comes from: 104:5: ( '>=' ) 952/** \brief Lexer rule generated by ANTLR3 953 * 954 * $ANTLR start GTE 955 * 956 * Looks to match the characters the constitute the token GTE 957 * from the attached input stream. 958 * 959 * 960 * \remark 961 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 962 */ 963static ANTLR3_INLINE 964void mGTE(pRSPLexer ctx) 965{ 966 ANTLR3_UINT32 _type; 967 968 _type = GTE; 969 970 971 // RSP.g:104:5: ( '>=' ) 972 // RSP.g:104:7: '>=' 973 { 974 MATCHS(lit_6); 975 if (HASEXCEPTION()) 976 { 977 goto ruleGTEEx; 978 } 979 980 981 982 } 983 984 LEXSTATE->type = _type; 985 986 // This is where rules clean up and exit 987 // 988 goto ruleGTEEx; /* Prevent compiler warnings */ 989 ruleGTEEx: ; 990 991} 992// $ANTLR end GTE 993 994// Comes from: 105:5: ( '<=' ) 995/** \brief Lexer rule generated by ANTLR3 996 * 997 * $ANTLR start LTE 998 * 999 * Looks to match the characters the constitute the token LTE 1000 * from the attached input stream. 1001 * 1002 * 1003 * \remark 1004 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1005 */ 1006static ANTLR3_INLINE 1007void mLTE(pRSPLexer ctx) 1008{ 1009 ANTLR3_UINT32 _type; 1010 1011 _type = LTE; 1012 1013 1014 // RSP.g:105:5: ( '<=' ) 1015 // RSP.g:105:7: '<=' 1016 { 1017 MATCHS(lit_7); 1018 if (HASEXCEPTION()) 1019 { 1020 goto ruleLTEEx; 1021 } 1022 1023 1024 1025 } 1026 1027 LEXSTATE->type = _type; 1028 1029 // This is where rules clean up and exit 1030 // 1031 goto ruleLTEEx; /* Prevent compiler warnings */ 1032 ruleLTEEx: ; 1033 1034} 1035// $ANTLR end LTE 1036 1037// Comes from: 108:8: ( 'before' ) 1038/** \brief Lexer rule generated by ANTLR3 1039 * 1040 * $ANTLR start BEFORE 1041 * 1042 * Looks to match the characters the constitute the token BEFORE 1043 * from the attached input stream. 1044 * 1045 * 1046 * \remark 1047 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1048 */ 1049static ANTLR3_INLINE 1050void mBEFORE(pRSPLexer ctx) 1051{ 1052 ANTLR3_UINT32 _type; 1053 1054 _type = BEFORE; 1055 1056 1057 // RSP.g:108:8: ( 'before' ) 1058 // RSP.g:108:10: 'before' 1059 { 1060 MATCHS(lit_8); 1061 if (HASEXCEPTION()) 1062 { 1063 goto ruleBEFOREEx; 1064 } 1065 1066 1067 1068 } 1069 1070 LEXSTATE->type = _type; 1071 1072 // This is where rules clean up and exit 1073 // 1074 goto ruleBEFOREEx; /* Prevent compiler warnings */ 1075 ruleBEFOREEx: ; 1076 1077} 1078// $ANTLR end BEFORE 1079 1080// Comes from: 109:7: ( 'after' ) 1081/** \brief Lexer rule generated by ANTLR3 1082 * 1083 * $ANTLR start AFTER 1084 * 1085 * Looks to match the characters the constitute the token AFTER 1086 * from the attached input stream. 1087 * 1088 * 1089 * \remark 1090 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1091 */ 1092static ANTLR3_INLINE 1093void mAFTER(pRSPLexer ctx) 1094{ 1095 ANTLR3_UINT32 _type; 1096 1097 _type = AFTER; 1098 1099 1100 // RSP.g:109:7: ( 'after' ) 1101 // RSP.g:109:9: 'after' 1102 { 1103 MATCHS(lit_9); 1104 if (HASEXCEPTION()) 1105 { 1106 goto ruleAFTEREx; 1107 } 1108 1109 1110 1111 } 1112 1113 LEXSTATE->type = _type; 1114 1115 // This is where rules clean up and exit 1116 // 1117 goto ruleAFTEREx; /* Prevent compiler warnings */ 1118 ruleAFTEREx: ; 1119 1120} 1121// $ANTLR end AFTER 1122 1123// Comes from: 110:5: ( 'day' | 'days' ) 1124/** \brief Lexer rule generated by ANTLR3 1125 * 1126 * $ANTLR start DAY 1127 * 1128 * Looks to match the characters the constitute the token DAY 1129 * from the attached input stream. 1130 * 1131 * 1132 * \remark 1133 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1134 */ 1135static ANTLR3_INLINE 1136void mDAY(pRSPLexer ctx) 1137{ 1138 ANTLR3_UINT32 _type; 1139 1140 _type = DAY; 1141 1142 1143 { 1144 // RSP.g:110:5: ( 'day' | 'days' ) 1145 1146 ANTLR3_UINT32 alt1; 1147 1148 alt1=2; 1149 1150 switch ( LA(1) ) 1151 { 1152 case 'd': 1153 { 1154 switch ( LA(2) ) 1155 { 1156 case 'a': 1157 { 1158 switch ( LA(3) ) 1159 { 1160 case 'y': 1161 { 1162 switch ( LA(4) ) 1163 { 1164 case 's': 1165 { 1166 alt1=2; 1167 } 1168 break; 1169 1170 default: 1171 alt1=1;} 1172 1173 } 1174 break; 1175 1176 default: 1177 CONSTRUCTEX(); 1178 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1179 EXCEPTION->message = (void *)""; 1180 EXCEPTION->decisionNum = 1; 1181 EXCEPTION->state = 2; 1182 1183 1184 goto ruleDAYEx; 1185 } 1186 1187 } 1188 break; 1189 1190 default: 1191 CONSTRUCTEX(); 1192 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1193 EXCEPTION->message = (void *)""; 1194 EXCEPTION->decisionNum = 1; 1195 EXCEPTION->state = 1; 1196 1197 1198 goto ruleDAYEx; 1199 } 1200 1201 } 1202 break; 1203 1204 default: 1205 CONSTRUCTEX(); 1206 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1207 EXCEPTION->message = (void *)""; 1208 EXCEPTION->decisionNum = 1; 1209 EXCEPTION->state = 0; 1210 1211 1212 goto ruleDAYEx; 1213 } 1214 1215 switch (alt1) 1216 { 1217 case 1: 1218 // RSP.g:110:7: 'day' 1219 { 1220 MATCHS(lit_10); 1221 if (HASEXCEPTION()) 1222 { 1223 goto ruleDAYEx; 1224 } 1225 1226 1227 1228 } 1229 break; 1230 case 2: 1231 // RSP.g:110:15: 'days' 1232 { 1233 MATCHS(lit_11); 1234 if (HASEXCEPTION()) 1235 { 1236 goto ruleDAYEx; 1237 } 1238 1239 1240 1241 } 1242 break; 1243 1244 } 1245 } 1246 LEXSTATE->type = _type; 1247 1248 // This is where rules clean up and exit 1249 // 1250 goto ruleDAYEx; /* Prevent compiler warnings */ 1251 ruleDAYEx: ; 1252 1253} 1254// $ANTLR end DAY 1255 1256// Comes from: 111:6: ( 'week' | 'weeks' ) 1257/** \brief Lexer rule generated by ANTLR3 1258 * 1259 * $ANTLR start WEEK 1260 * 1261 * Looks to match the characters the constitute the token WEEK 1262 * from the attached input stream. 1263 * 1264 * 1265 * \remark 1266 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1267 */ 1268static ANTLR3_INLINE 1269void mWEEK(pRSPLexer ctx) 1270{ 1271 ANTLR3_UINT32 _type; 1272 1273 _type = WEEK; 1274 1275 1276 { 1277 // RSP.g:111:6: ( 'week' | 'weeks' ) 1278 1279 ANTLR3_UINT32 alt2; 1280 1281 alt2=2; 1282 1283 switch ( LA(1) ) 1284 { 1285 case 'w': 1286 { 1287 switch ( LA(2) ) 1288 { 1289 case 'e': 1290 { 1291 switch ( LA(3) ) 1292 { 1293 case 'e': 1294 { 1295 switch ( LA(4) ) 1296 { 1297 case 'k': 1298 { 1299 switch ( LA(5) ) 1300 { 1301 case 's': 1302 { 1303 alt2=2; 1304 } 1305 break; 1306 1307 default: 1308 alt2=1;} 1309 1310 } 1311 break; 1312 1313 default: 1314 CONSTRUCTEX(); 1315 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1316 EXCEPTION->message = (void *)""; 1317 EXCEPTION->decisionNum = 2; 1318 EXCEPTION->state = 3; 1319 1320 1321 goto ruleWEEKEx; 1322 } 1323 1324 } 1325 break; 1326 1327 default: 1328 CONSTRUCTEX(); 1329 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1330 EXCEPTION->message = (void *)""; 1331 EXCEPTION->decisionNum = 2; 1332 EXCEPTION->state = 2; 1333 1334 1335 goto ruleWEEKEx; 1336 } 1337 1338 } 1339 break; 1340 1341 default: 1342 CONSTRUCTEX(); 1343 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1344 EXCEPTION->message = (void *)""; 1345 EXCEPTION->decisionNum = 2; 1346 EXCEPTION->state = 1; 1347 1348 1349 goto ruleWEEKEx; 1350 } 1351 1352 } 1353 break; 1354 1355 default: 1356 CONSTRUCTEX(); 1357 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1358 EXCEPTION->message = (void *)""; 1359 EXCEPTION->decisionNum = 2; 1360 EXCEPTION->state = 0; 1361 1362 1363 goto ruleWEEKEx; 1364 } 1365 1366 switch (alt2) 1367 { 1368 case 1: 1369 // RSP.g:111:8: 'week' 1370 { 1371 MATCHS(lit_12); 1372 if (HASEXCEPTION()) 1373 { 1374 goto ruleWEEKEx; 1375 } 1376 1377 1378 1379 } 1380 break; 1381 case 2: 1382 // RSP.g:111:17: 'weeks' 1383 { 1384 MATCHS(lit_13); 1385 if (HASEXCEPTION()) 1386 { 1387 goto ruleWEEKEx; 1388 } 1389 1390 1391 1392 } 1393 break; 1394 1395 } 1396 } 1397 LEXSTATE->type = _type; 1398 1399 // This is where rules clean up and exit 1400 // 1401 goto ruleWEEKEx; /* Prevent compiler warnings */ 1402 ruleWEEKEx: ; 1403 1404} 1405// $ANTLR end WEEK 1406 1407// Comes from: 112:7: ( 'month' | 'months' ) 1408/** \brief Lexer rule generated by ANTLR3 1409 * 1410 * $ANTLR start MONTH 1411 * 1412 * Looks to match the characters the constitute the token MONTH 1413 * from the attached input stream. 1414 * 1415 * 1416 * \remark 1417 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1418 */ 1419static ANTLR3_INLINE 1420void mMONTH(pRSPLexer ctx) 1421{ 1422 ANTLR3_UINT32 _type; 1423 1424 _type = MONTH; 1425 1426 1427 { 1428 // RSP.g:112:7: ( 'month' | 'months' ) 1429 1430 ANTLR3_UINT32 alt3; 1431 1432 alt3=2; 1433 1434 switch ( LA(1) ) 1435 { 1436 case 'm': 1437 { 1438 switch ( LA(2) ) 1439 { 1440 case 'o': 1441 { 1442 switch ( LA(3) ) 1443 { 1444 case 'n': 1445 { 1446 switch ( LA(4) ) 1447 { 1448 case 't': 1449 { 1450 switch ( LA(5) ) 1451 { 1452 case 'h': 1453 { 1454 switch ( LA(6) ) 1455 { 1456 case 's': 1457 { 1458 alt3=2; 1459 } 1460 break; 1461 1462 default: 1463 alt3=1;} 1464 1465 } 1466 break; 1467 1468 default: 1469 CONSTRUCTEX(); 1470 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1471 EXCEPTION->message = (void *)""; 1472 EXCEPTION->decisionNum = 3; 1473 EXCEPTION->state = 4; 1474 1475 1476 goto ruleMONTHEx; 1477 } 1478 1479 } 1480 break; 1481 1482 default: 1483 CONSTRUCTEX(); 1484 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1485 EXCEPTION->message = (void *)""; 1486 EXCEPTION->decisionNum = 3; 1487 EXCEPTION->state = 3; 1488 1489 1490 goto ruleMONTHEx; 1491 } 1492 1493 } 1494 break; 1495 1496 default: 1497 CONSTRUCTEX(); 1498 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1499 EXCEPTION->message = (void *)""; 1500 EXCEPTION->decisionNum = 3; 1501 EXCEPTION->state = 2; 1502 1503 1504 goto ruleMONTHEx; 1505 } 1506 1507 } 1508 break; 1509 1510 default: 1511 CONSTRUCTEX(); 1512 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1513 EXCEPTION->message = (void *)""; 1514 EXCEPTION->decisionNum = 3; 1515 EXCEPTION->state = 1; 1516 1517 1518 goto ruleMONTHEx; 1519 } 1520 1521 } 1522 break; 1523 1524 default: 1525 CONSTRUCTEX(); 1526 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1527 EXCEPTION->message = (void *)""; 1528 EXCEPTION->decisionNum = 3; 1529 EXCEPTION->state = 0; 1530 1531 1532 goto ruleMONTHEx; 1533 } 1534 1535 switch (alt3) 1536 { 1537 case 1: 1538 // RSP.g:112:9: 'month' 1539 { 1540 MATCHS(lit_14); 1541 if (HASEXCEPTION()) 1542 { 1543 goto ruleMONTHEx; 1544 } 1545 1546 1547 1548 } 1549 break; 1550 case 2: 1551 // RSP.g:112:19: 'months' 1552 { 1553 MATCHS(lit_15); 1554 if (HASEXCEPTION()) 1555 { 1556 goto ruleMONTHEx; 1557 } 1558 1559 1560 1561 } 1562 break; 1563 1564 } 1565 } 1566 LEXSTATE->type = _type; 1567 1568 // This is where rules clean up and exit 1569 // 1570 goto ruleMONTHEx; /* Prevent compiler warnings */ 1571 ruleMONTHEx: ; 1572 1573} 1574// $ANTLR end MONTH 1575 1576// Comes from: 113:6: ( 'year' | 'years' ) 1577/** \brief Lexer rule generated by ANTLR3 1578 * 1579 * $ANTLR start YEAR 1580 * 1581 * Looks to match the characters the constitute the token YEAR 1582 * from the attached input stream. 1583 * 1584 * 1585 * \remark 1586 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1587 */ 1588static ANTLR3_INLINE 1589void mYEAR(pRSPLexer ctx) 1590{ 1591 ANTLR3_UINT32 _type; 1592 1593 _type = YEAR; 1594 1595 1596 { 1597 // RSP.g:113:6: ( 'year' | 'years' ) 1598 1599 ANTLR3_UINT32 alt4; 1600 1601 alt4=2; 1602 1603 switch ( LA(1) ) 1604 { 1605 case 'y': 1606 { 1607 switch ( LA(2) ) 1608 { 1609 case 'e': 1610 { 1611 switch ( LA(3) ) 1612 { 1613 case 'a': 1614 { 1615 switch ( LA(4) ) 1616 { 1617 case 'r': 1618 { 1619 switch ( LA(5) ) 1620 { 1621 case 's': 1622 { 1623 alt4=2; 1624 } 1625 break; 1626 1627 default: 1628 alt4=1;} 1629 1630 } 1631 break; 1632 1633 default: 1634 CONSTRUCTEX(); 1635 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1636 EXCEPTION->message = (void *)""; 1637 EXCEPTION->decisionNum = 4; 1638 EXCEPTION->state = 3; 1639 1640 1641 goto ruleYEAREx; 1642 } 1643 1644 } 1645 break; 1646 1647 default: 1648 CONSTRUCTEX(); 1649 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1650 EXCEPTION->message = (void *)""; 1651 EXCEPTION->decisionNum = 4; 1652 EXCEPTION->state = 2; 1653 1654 1655 goto ruleYEAREx; 1656 } 1657 1658 } 1659 break; 1660 1661 default: 1662 CONSTRUCTEX(); 1663 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1664 EXCEPTION->message = (void *)""; 1665 EXCEPTION->decisionNum = 4; 1666 EXCEPTION->state = 1; 1667 1668 1669 goto ruleYEAREx; 1670 } 1671 1672 } 1673 break; 1674 1675 default: 1676 CONSTRUCTEX(); 1677 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1678 EXCEPTION->message = (void *)""; 1679 EXCEPTION->decisionNum = 4; 1680 EXCEPTION->state = 0; 1681 1682 1683 goto ruleYEAREx; 1684 } 1685 1686 switch (alt4) 1687 { 1688 case 1: 1689 // RSP.g:113:8: 'year' 1690 { 1691 MATCHS(lit_16); 1692 if (HASEXCEPTION()) 1693 { 1694 goto ruleYEAREx; 1695 } 1696 1697 1698 1699 } 1700 break; 1701 case 2: 1702 // RSP.g:113:17: 'years' 1703 { 1704 MATCHS(lit_17); 1705 if (HASEXCEPTION()) 1706 { 1707 goto ruleYEAREx; 1708 } 1709 1710 1711 1712 } 1713 break; 1714 1715 } 1716 } 1717 LEXSTATE->type = _type; 1718 1719 // This is where rules clean up and exit 1720 // 1721 goto ruleYEAREx; /* Prevent compiler warnings */ 1722 ruleYEAREx: ; 1723 1724} 1725// $ANTLR end YEAR 1726 1727// Comes from: 114:7: ( 'today' ) 1728/** \brief Lexer rule generated by ANTLR3 1729 * 1730 * $ANTLR start TODAY 1731 * 1732 * Looks to match the characters the constitute the token TODAY 1733 * from the attached input stream. 1734 * 1735 * 1736 * \remark 1737 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1738 */ 1739static ANTLR3_INLINE 1740void mTODAY(pRSPLexer ctx) 1741{ 1742 ANTLR3_UINT32 _type; 1743 1744 _type = TODAY; 1745 1746 1747 // RSP.g:114:7: ( 'today' ) 1748 // RSP.g:114:9: 'today' 1749 { 1750 MATCHS(lit_18); 1751 if (HASEXCEPTION()) 1752 { 1753 goto ruleTODAYEx; 1754 } 1755 1756 1757 1758 } 1759 1760 LEXSTATE->type = _type; 1761 1762 // This is where rules clean up and exit 1763 // 1764 goto ruleTODAYEx; /* Prevent compiler warnings */ 1765 ruleTODAYEx: ; 1766 1767} 1768// $ANTLR end TODAY 1769 1770// Comes from: 116:9: ( ( '\\r' )? '\\n' ) 1771/** \brief Lexer rule generated by ANTLR3 1772 * 1773 * $ANTLR start NEWLINE 1774 * 1775 * Looks to match the characters the constitute the token NEWLINE 1776 * from the attached input stream. 1777 * 1778 * 1779 * \remark 1780 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1781 */ 1782static ANTLR3_INLINE 1783void mNEWLINE(pRSPLexer ctx) 1784{ 1785 ANTLR3_UINT32 _type; 1786 1787 _type = NEWLINE; 1788 1789 1790 // RSP.g:116:9: ( ( '\\r' )? '\\n' ) 1791 // RSP.g:116:11: ( '\\r' )? '\\n' 1792 { 1793 1794 // RSP.g:116:11: ( '\\r' )? 1795 { 1796 int alt5=2; 1797 switch ( LA(1) ) 1798 { 1799 case '\r': 1800 { 1801 alt5=1; 1802 } 1803 break; 1804 } 1805 1806 switch (alt5) 1807 { 1808 case 1: 1809 // RSP.g:116:11: '\\r' 1810 { 1811 MATCHC('\r'); 1812 if (HASEXCEPTION()) 1813 { 1814 goto ruleNEWLINEEx; 1815 } 1816 1817 1818 } 1819 break; 1820 1821 } 1822 } 1823 MATCHC('\n'); 1824 if (HASEXCEPTION()) 1825 { 1826 goto ruleNEWLINEEx; 1827 } 1828 1829 1830 } 1831 1832 LEXSTATE->type = _type; 1833 1834 // This is where rules clean up and exit 1835 // 1836 goto ruleNEWLINEEx; /* Prevent compiler warnings */ 1837 ruleNEWLINEEx: ; 1838 1839} 1840// $ANTLR end NEWLINE 1841 1842// Comes from: 118:4: ( ( ' ' | '\\t' ) ) 1843/** \brief Lexer rule generated by ANTLR3 1844 * 1845 * $ANTLR start WS 1846 * 1847 * Looks to match the characters the constitute the token WS 1848 * from the attached input stream. 1849 * 1850 * 1851 * \remark 1852 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1853 */ 1854static ANTLR3_INLINE 1855void mWS(pRSPLexer ctx) 1856{ 1857 ANTLR3_UINT32 _type; 1858 1859 _type = WS; 1860 1861 1862 // RSP.g:118:4: ( ( ' ' | '\\t' ) ) 1863 // RSP.g:118:6: ( ' ' | '\\t' ) 1864 { 1865 if ( LA(1) == '\t' || LA(1) == ' ' ) 1866 { 1867 CONSUME(); 1868 1869 } 1870 else 1871 { 1872 CONSTRUCTEX(); 1873 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 1874 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 1875 1876 LRECOVER(); goto ruleWSEx; 1877 } 1878 1879 { 1880 LEXSTATE->channel = HIDDEN; 1881 } 1882 1883 } 1884 1885 LEXSTATE->type = _type; 1886 1887 // This is where rules clean up and exit 1888 // 1889 goto ruleWSEx; /* Prevent compiler warnings */ 1890 ruleWSEx: ; 1891 1892} 1893// $ANTLR end WS 1894 1895// Comes from: 120:7: ( 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' ) 1896/** \brief Lexer rule generated by ANTLR3 1897 * 1898 * $ANTLR start FIELD 1899 * 1900 * Looks to match the characters the constitute the token FIELD 1901 * from the attached input stream. 1902 * 1903 * 1904 * \remark 1905 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 1906 */ 1907static ANTLR3_INLINE 1908void mFIELD(pRSPLexer ctx) 1909{ 1910 ANTLR3_UINT32 _type; 1911 1912 _type = FIELD; 1913 1914 1915 // RSP.g:120:7: ( 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' ) 1916 // RSP.g:120:9: 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' 1917 { 1918 MATCHRANGE('a', 'z'); 1919 if (HASEXCEPTION()) 1920 { 1921 goto ruleFIELDEx; 1922 } 1923 1924 1925 // RSP.g:120:18: ( 'a' .. 'z' | '_' )* 1926 1927 for (;;) 1928 { 1929 int alt6=2; 1930 switch ( LA(1) ) 1931 { 1932 case 'a': 1933 case 'b': 1934 case 'c': 1935 case 'd': 1936 case 'e': 1937 case 'f': 1938 case 'g': 1939 case 'h': 1940 case 'i': 1941 case 'j': 1942 case 'k': 1943 case 'l': 1944 case 'm': 1945 case 'n': 1946 case 'o': 1947 case 'p': 1948 case 'q': 1949 case 'r': 1950 case 's': 1951 case 't': 1952 case 'u': 1953 case 'v': 1954 case 'w': 1955 case 'x': 1956 case 'y': 1957 case 'z': 1958 { 1959 switch ( LA(2) ) 1960 { 1961 case '_': 1962 case 'a': 1963 case 'b': 1964 case 'c': 1965 case 'd': 1966 case 'e': 1967 case 'f': 1968 case 'g': 1969 case 'h': 1970 case 'i': 1971 case 'j': 1972 case 'k': 1973 case 'l': 1974 case 'm': 1975 case 'n': 1976 case 'o': 1977 case 'p': 1978 case 'q': 1979 case 'r': 1980 case 's': 1981 case 't': 1982 case 'u': 1983 case 'v': 1984 case 'w': 1985 case 'x': 1986 case 'y': 1987 case 'z': 1988 { 1989 alt6=1; 1990 } 1991 break; 1992 1993 } 1994 1995 } 1996 break; 1997 case '_': 1998 { 1999 alt6=1; 2000 } 2001 break; 2002 2003 } 2004 2005 switch (alt6) 2006 { 2007 case 1: 2008 // RSP.g: 2009 { 2010 if ( LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) ) 2011 { 2012 CONSUME(); 2013 2014 } 2015 else 2016 { 2017 CONSTRUCTEX(); 2018 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 2019 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 2020 2021 LRECOVER(); goto ruleFIELDEx; 2022 } 2023 2024 2025 } 2026 break; 2027 2028 default: 2029 goto loop6; /* break out of the loop */ 2030 break; 2031 } 2032 } 2033 loop6: ; /* Jump out to here if this rule does not match */ 2034 2035 MATCHRANGE('a', 'z'); 2036 if (HASEXCEPTION()) 2037 { 2038 goto ruleFIELDEx; 2039 } 2040 2041 2042 } 2043 2044 LEXSTATE->type = _type; 2045 2046 // This is where rules clean up and exit 2047 // 2048 goto ruleFIELDEx; /* Prevent compiler warnings */ 2049 ruleFIELDEx: ; 2050 2051} 2052// $ANTLR end FIELD 2053 2054// Comes from: 122:5: ( DIGIT19 ( DIGIT09 )* ) 2055/** \brief Lexer rule generated by ANTLR3 2056 * 2057 * $ANTLR start INT 2058 * 2059 * Looks to match the characters the constitute the token INT 2060 * from the attached input stream. 2061 * 2062 * 2063 * \remark 2064 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 2065 */ 2066static ANTLR3_INLINE 2067void mINT(pRSPLexer ctx) 2068{ 2069 ANTLR3_UINT32 _type; 2070 2071 _type = INT; 2072 2073 2074 // RSP.g:122:5: ( DIGIT19 ( DIGIT09 )* ) 2075 // RSP.g:122:7: DIGIT19 ( DIGIT09 )* 2076 { 2077 /* 122:7: DIGIT19 ( DIGIT09 )* */ 2078 mDIGIT19(ctx ); 2079 if (HASEXCEPTION()) 2080 { 2081 goto ruleINTEx; 2082 } 2083 2084 2085 // RSP.g:122:15: ( DIGIT09 )* 2086 2087 for (;;) 2088 { 2089 int alt7=2; 2090 switch ( LA(1) ) 2091 { 2092 case '0': 2093 case '1': 2094 case '2': 2095 case '3': 2096 case '4': 2097 case '5': 2098 case '6': 2099 case '7': 2100 case '8': 2101 case '9': 2102 { 2103 alt7=1; 2104 } 2105 break; 2106 2107 } 2108 2109 switch (alt7) 2110 { 2111 case 1: 2112 // RSP.g:122:15: DIGIT09 2113 { 2114 /* 122:15: DIGIT09 */ 2115 mDIGIT09(ctx ); 2116 if (HASEXCEPTION()) 2117 { 2118 goto ruleINTEx; 2119 } 2120 2121 2122 } 2123 break; 2124 2125 default: 2126 goto loop7; /* break out of the loop */ 2127 break; 2128 } 2129 } 2130 loop7: ; /* Jump out to here if this rule does not match */ 2131 2132 2133 } 2134 2135 LEXSTATE->type = _type; 2136 2137 // This is where rules clean up and exit 2138 // 2139 goto ruleINTEx; /* Prevent compiler warnings */ 2140 ruleINTEx: ; 2141 2142} 2143// $ANTLR end INT 2144 2145// Comes from: 125:6: ( DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) ) 2146/** \brief Lexer rule generated by ANTLR3 2147 * 2148 * $ANTLR start DATE 2149 * 2150 * Looks to match the characters the constitute the token DATE 2151 * from the attached input stream. 2152 * 2153 * 2154 * \remark 2155 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 2156 */ 2157static ANTLR3_INLINE 2158void mDATE(pRSPLexer ctx) 2159{ 2160 ANTLR3_UINT32 _type; 2161 2162 _type = DATE; 2163 2164 2165 // RSP.g:125:6: ( DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) ) 2166 // RSP.g:125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) 2167 { 2168 /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */ 2169 mDIGIT19(ctx ); 2170 if (HASEXCEPTION()) 2171 { 2172 goto ruleDATEEx; 2173 } 2174 2175 /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */ 2176 mDIGIT09(ctx ); 2177 if (HASEXCEPTION()) 2178 { 2179 goto ruleDATEEx; 2180 } 2181 2182 /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */ 2183 mDIGIT09(ctx ); 2184 if (HASEXCEPTION()) 2185 { 2186 goto ruleDATEEx; 2187 } 2188 2189 /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */ 2190 mDIGIT09(ctx ); 2191 if (HASEXCEPTION()) 2192 { 2193 goto ruleDATEEx; 2194 } 2195 2196 MATCHC('-'); 2197 if (HASEXCEPTION()) 2198 { 2199 goto ruleDATEEx; 2200 } 2201 2202 2203 // RSP.g:125:44: ( '0' DIGIT19 | '1' '0' .. '2' ) 2204 { 2205 int alt8=2; 2206 switch ( LA(1) ) 2207 { 2208 case '0': 2209 { 2210 alt8=1; 2211 } 2212 break; 2213 case '1': 2214 { 2215 alt8=2; 2216 } 2217 break; 2218 2219 default: 2220 CONSTRUCTEX(); 2221 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 2222 EXCEPTION->message = (void *)""; 2223 EXCEPTION->decisionNum = 8; 2224 EXCEPTION->state = 0; 2225 2226 2227 goto ruleDATEEx; 2228 } 2229 2230 switch (alt8) 2231 { 2232 case 1: 2233 // RSP.g:125:45: '0' DIGIT19 2234 { 2235 MATCHC('0'); 2236 if (HASEXCEPTION()) 2237 { 2238 goto ruleDATEEx; 2239 } 2240 2241 /* 125:45: '0' DIGIT19 */ 2242 mDIGIT19(ctx ); 2243 if (HASEXCEPTION()) 2244 { 2245 goto ruleDATEEx; 2246 } 2247 2248 2249 } 2250 break; 2251 case 2: 2252 // RSP.g:125:59: '1' '0' .. '2' 2253 { 2254 MATCHC('1'); 2255 if (HASEXCEPTION()) 2256 { 2257 goto ruleDATEEx; 2258 } 2259 2260 MATCHRANGE('0', '2'); 2261 if (HASEXCEPTION()) 2262 { 2263 goto ruleDATEEx; 2264 } 2265 2266 2267 } 2268 break; 2269 2270 } 2271 } 2272 MATCHC('-'); 2273 if (HASEXCEPTION()) 2274 { 2275 goto ruleDATEEx; 2276 } 2277 2278 2279 // RSP.g:125:77: ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) 2280 { 2281 int alt9=3; 2282 switch ( LA(1) ) 2283 { 2284 case '0': 2285 { 2286 alt9=1; 2287 } 2288 break; 2289 case '1': 2290 case '2': 2291 { 2292 alt9=2; 2293 } 2294 break; 2295 case '3': 2296 { 2297 alt9=3; 2298 } 2299 break; 2300 2301 default: 2302 CONSTRUCTEX(); 2303 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 2304 EXCEPTION->message = (void *)""; 2305 EXCEPTION->decisionNum = 9; 2306 EXCEPTION->state = 0; 2307 2308 2309 goto ruleDATEEx; 2310 } 2311 2312 switch (alt9) 2313 { 2314 case 1: 2315 // RSP.g:125:78: '0' DIGIT19 2316 { 2317 MATCHC('0'); 2318 if (HASEXCEPTION()) 2319 { 2320 goto ruleDATEEx; 2321 } 2322 2323 /* 125:78: '0' DIGIT19 */ 2324 mDIGIT19(ctx ); 2325 if (HASEXCEPTION()) 2326 { 2327 goto ruleDATEEx; 2328 } 2329 2330 2331 } 2332 break; 2333 case 2: 2334 // RSP.g:125:92: '1' .. '2' DIGIT09 2335 { 2336 MATCHRANGE('1', '2'); 2337 if (HASEXCEPTION()) 2338 { 2339 goto ruleDATEEx; 2340 } 2341 2342 /* 125:92: '1' .. '2' DIGIT09 */ 2343 mDIGIT09(ctx ); 2344 if (HASEXCEPTION()) 2345 { 2346 goto ruleDATEEx; 2347 } 2348 2349 2350 } 2351 break; 2352 case 3: 2353 // RSP.g:125:111: '3' '0' .. '1' 2354 { 2355 MATCHC('3'); 2356 if (HASEXCEPTION()) 2357 { 2358 goto ruleDATEEx; 2359 } 2360 2361 MATCHRANGE('0', '1'); 2362 if (HASEXCEPTION()) 2363 { 2364 goto ruleDATEEx; 2365 } 2366 2367 2368 } 2369 break; 2370 2371 } 2372 } 2373 2374 } 2375 2376 LEXSTATE->type = _type; 2377 2378 // This is where rules clean up and exit 2379 // 2380 goto ruleDATEEx; /* Prevent compiler warnings */ 2381 ruleDATEEx: ; 2382 2383} 2384// $ANTLR end DATE 2385 2386// Comes from: 133:2: ( QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE ) 2387/** \brief Lexer rule generated by ANTLR3 2388 * 2389 * $ANTLR start STR 2390 * 2391 * Looks to match the characters the constitute the token STR 2392 * from the attached input stream. 2393 * 2394 * 2395 * \remark 2396 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 2397 */ 2398static ANTLR3_INLINE 2399void mSTR(pRSPLexer ctx) 2400{ 2401 ANTLR3_UINT32 _type; 2402 pANTLR3_COMMON_TOKEN esc; 2403 ANTLR3_UINT32 reg; 2404 2405 2406 esc = NULL; 2407 2408 _type = STR; 2409 2410 pANTLR3_STRING unesc = GETTEXT()->factory->newRaw(GETTEXT()->factory); 2411 2412 // RSP.g:133:2: ( QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE ) 2413 // RSP.g:133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE 2414 { 2415 /* 133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE */ 2416 mQUOTE(ctx ); 2417 if (HASEXCEPTION()) 2418 { 2419 goto ruleSTREx; 2420 } 2421 2422 // RSP.g:133:10: (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ 2423 { 2424 int cnt10=0; 2425 2426 for (;;) 2427 { 2428 int alt10=3; 2429 { 2430 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) 2431 */ 2432 int LA10_0 = LA(1); 2433 if ( (((LA10_0 >= 0x0000) && (LA10_0 <= '!')) || ((LA10_0 >= '#') && (LA10_0 <= '[')) || ((LA10_0 >= ']') && (LA10_0 <= 0xFFFF))) ) 2434 { 2435 alt10=1; 2436 } 2437 else if ( (LA10_0 == '\\') ) 2438 { 2439 alt10=2; 2440 } 2441 2442 } 2443 switch (alt10) 2444 { 2445 case 1: 2446 // RSP.g:133:12: reg=~ ( '\\\\' | '\"' ) 2447 { 2448 reg= LA(1); 2449 if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) ) 2450 { 2451 CONSUME(); 2452 2453 } 2454 else 2455 { 2456 CONSTRUCTEX(); 2457 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 2458 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 2459 2460 LRECOVER(); goto ruleSTREx; 2461 } 2462 2463 { 2464 unesc->addc(unesc, reg); 2465 } 2466 2467 } 2468 break; 2469 case 2: 2470 // RSP.g:134:6: esc= ESCAPED 2471 { 2472 /* 134:6: esc= ESCAPED */ 2473 { 2474 ANTLR3_MARKER escStart381 = GETCHARINDEX(); 2475 mESCAPED(ctx ); 2476 if (HASEXCEPTION()) 2477 { 2478 goto ruleSTREx; 2479 } 2480 2481 esc = LEXSTATE->tokFactory->newToken(LEXSTATE->tokFactory); 2482 esc->setType(esc, ANTLR3_TOKEN_INVALID); 2483 esc->setStartIndex(esc, escStart381); 2484 esc->setStopIndex(esc, GETCHARINDEX()-1); 2485 esc->input = INPUT; 2486 } 2487 { 2488 unesc->appendS(unesc, GETTEXT()); 2489 } 2490 2491 } 2492 break; 2493 2494 default: 2495 2496 if ( cnt10 >= 1 ) 2497 { 2498 goto loop10; 2499 } 2500 /* mismatchedSetEx() 2501 */ 2502 CONSTRUCTEX(); 2503 EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; 2504 EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; 2505 2506 2507 goto ruleSTREx; 2508 } 2509 cnt10++; 2510 } 2511 loop10: ; /* Jump to here if this rule does not match */ 2512 } 2513 /* 133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE */ 2514 mQUOTE(ctx ); 2515 if (HASEXCEPTION()) 2516 { 2517 goto ruleSTREx; 2518 } 2519 2520 { 2521 SETTEXT(unesc); 2522 } 2523 2524 } 2525 2526 LEXSTATE->type = _type; 2527 2528 // This is where rules clean up and exit 2529 // 2530 goto ruleSTREx; /* Prevent compiler warnings */ 2531 ruleSTREx: ; 2532 2533 esc = NULL; 2534 2535} 2536// $ANTLR end STR 2537 2538// Comes from: 138:9: ( '\\\\' ( '\\\\' | '\"' ) ) 2539/** \brief Lexer rule generated by ANTLR3 2540 * 2541 * $ANTLR start ESCAPED 2542 * 2543 * Looks to match the characters the constitute the token ESCAPED 2544 * from the attached input stream. 2545 * 2546 * 2547 * \remark 2548 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 2549 */ 2550static ANTLR3_INLINE 2551void mESCAPED(pRSPLexer ctx) 2552{ 2553 ANTLR3_UINT32 _type; 2554 2555 2556 // RSP.g:138:9: ( '\\\\' ( '\\\\' | '\"' ) ) 2557 // RSP.g:138:11: '\\\\' ( '\\\\' | '\"' ) 2558 { 2559 MATCHC('\\'); 2560 if (HASEXCEPTION()) 2561 { 2562 goto ruleESCAPEDEx; 2563 } 2564 2565 2566 // RSP.g:139:3: ( '\\\\' | '\"' ) 2567 { 2568 int alt11=2; 2569 switch ( LA(1) ) 2570 { 2571 case '\\': 2572 { 2573 alt11=1; 2574 } 2575 break; 2576 case '"': 2577 { 2578 alt11=2; 2579 } 2580 break; 2581 2582 default: 2583 CONSTRUCTEX(); 2584 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 2585 EXCEPTION->message = (void *)""; 2586 EXCEPTION->decisionNum = 11; 2587 EXCEPTION->state = 0; 2588 2589 2590 goto ruleESCAPEDEx; 2591 } 2592 2593 switch (alt11) 2594 { 2595 case 1: 2596 // RSP.g:139:5: '\\\\' 2597 { 2598 MATCHC('\\'); 2599 if (HASEXCEPTION()) 2600 { 2601 goto ruleESCAPEDEx; 2602 } 2603 2604 { 2605 SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\\")); 2606 } 2607 2608 } 2609 break; 2610 case 2: 2611 // RSP.g:140:5: '\"' 2612 { 2613 MATCHC('"'); 2614 if (HASEXCEPTION()) 2615 { 2616 goto ruleESCAPEDEx; 2617 } 2618 2619 { 2620 SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\"")); 2621 } 2622 2623 } 2624 break; 2625 2626 } 2627 } 2628 2629 } 2630 2631 2632 2633 // This is where rules clean up and exit 2634 // 2635 goto ruleESCAPEDEx; /* Prevent compiler warnings */ 2636 ruleESCAPEDEx: ; 2637 2638} 2639// $ANTLR end ESCAPED 2640 2641// Comes from: 145:9: ( '0' .. '9' ) 2642/** \brief Lexer rule generated by ANTLR3 2643 * 2644 * $ANTLR start DIGIT09 2645 * 2646 * Looks to match the characters the constitute the token DIGIT09 2647 * from the attached input stream. 2648 * 2649 * 2650 * \remark 2651 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 2652 */ 2653static ANTLR3_INLINE 2654void mDIGIT09(pRSPLexer ctx) 2655{ 2656 ANTLR3_UINT32 _type; 2657 2658 2659 // RSP.g:145:9: ( '0' .. '9' ) 2660 // RSP.g:145:11: '0' .. '9' 2661 { 2662 MATCHRANGE('0', '9'); 2663 if (HASEXCEPTION()) 2664 { 2665 goto ruleDIGIT09Ex; 2666 } 2667 2668 2669 } 2670 2671 2672 2673 // This is where rules clean up and exit 2674 // 2675 goto ruleDIGIT09Ex; /* Prevent compiler warnings */ 2676 ruleDIGIT09Ex: ; 2677 2678} 2679// $ANTLR end DIGIT09 2680 2681// Comes from: 148:9: ( '1' .. '9' ) 2682/** \brief Lexer rule generated by ANTLR3 2683 * 2684 * $ANTLR start DIGIT19 2685 * 2686 * Looks to match the characters the constitute the token DIGIT19 2687 * from the attached input stream. 2688 * 2689 * 2690 * \remark 2691 * - lexer->error == ANTLR3_TRUE if an exception was thrown. 2692 */ 2693static ANTLR3_INLINE 2694void mDIGIT19(pRSPLexer ctx) 2695{ 2696 ANTLR3_UINT32 _type; 2697 2698 2699 // RSP.g:148:9: ( '1' .. '9' ) 2700 // RSP.g:148:11: '1' .. '9' 2701 { 2702 MATCHRANGE('1', '9'); 2703 if (HASEXCEPTION()) 2704 { 2705 goto ruleDIGIT19Ex; 2706 } 2707 2708 2709 } 2710 2711 2712 2713 // This is where rules clean up and exit 2714 // 2715 goto ruleDIGIT19Ex; /* Prevent compiler warnings */ 2716 ruleDIGIT19Ex: ; 2717 2718} 2719// $ANTLR end DIGIT19 2720 2721/** This is the entry point in to the lexer from an object that 2722 * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM 2723 */ 2724static void 2725mTokens(pRSPLexer ctx) 2726{ 2727 { 2728 // RSP.g:1:8: ( QUOTE | LPAR | RPAR | AND | OR | NOT | EQUAL | INCLUDES | STARTSW | ENDSW | GREATER | LESS | GTE | LTE | BEFORE | AFTER | DAY | WEEK | MONTH | YEAR | TODAY | NEWLINE | WS | FIELD | INT | DATE | STR ) 2729 2730 ANTLR3_UINT32 alt12; 2731 2732 alt12=27; 2733 2734 switch ( LA(1) ) 2735 { 2736 case '"': 2737 { 2738 2739 { 2740 int LA12_1 = LA(2); 2741 if ( (((LA12_1 >= 0x0000) && (LA12_1 <= '!')) || ((LA12_1 >= '#') && (LA12_1 <= 0xFFFF))) ) 2742 { 2743 alt12=27; 2744 } 2745 else 2746 { 2747 alt12=1; } 2748 } 2749 } 2750 break; 2751 case '(': 2752 { 2753 alt12=2; 2754 } 2755 break; 2756 case ')': 2757 { 2758 alt12=3; 2759 } 2760 break; 2761 case 'a': 2762 { 2763 switch ( LA(2) ) 2764 { 2765 case 'n': 2766 { 2767 switch ( LA(3) ) 2768 { 2769 case 'd': 2770 { 2771 switch ( LA(4) ) 2772 { 2773 case '_': 2774 case 'a': 2775 case 'b': 2776 case 'c': 2777 case 'd': 2778 case 'e': 2779 case 'f': 2780 case 'g': 2781 case 'h': 2782 case 'i': 2783 case 'j': 2784 case 'k': 2785 case 'l': 2786 case 'm': 2787 case 'n': 2788 case 'o': 2789 case 'p': 2790 case 'q': 2791 case 'r': 2792 case 's': 2793 case 't': 2794 case 'u': 2795 case 'v': 2796 case 'w': 2797 case 'x': 2798 case 'y': 2799 case 'z': 2800 { 2801 alt12=24; 2802 } 2803 break; 2804 2805 default: 2806 alt12=4;} 2807 2808 } 2809 break; 2810 2811 default: 2812 alt12=24;} 2813 2814 } 2815 break; 2816 case 'f': 2817 { 2818 switch ( LA(3) ) 2819 { 2820 case 't': 2821 { 2822 switch ( LA(4) ) 2823 { 2824 case 'e': 2825 { 2826 switch ( LA(5) ) 2827 { 2828 case 'r': 2829 { 2830 switch ( LA(6) ) 2831 { 2832 case '_': 2833 case 'a': 2834 case 'b': 2835 case 'c': 2836 case 'd': 2837 case 'e': 2838 case 'f': 2839 case 'g': 2840 case 'h': 2841 case 'i': 2842 case 'j': 2843 case 'k': 2844 case 'l': 2845 case 'm': 2846 case 'n': 2847 case 'o': 2848 case 'p': 2849 case 'q': 2850 case 'r': 2851 case 's': 2852 case 't': 2853 case 'u': 2854 case 'v': 2855 case 'w': 2856 case 'x': 2857 case 'y': 2858 case 'z': 2859 { 2860 alt12=24; 2861 } 2862 break; 2863 2864 default: 2865 alt12=16;} 2866 2867 } 2868 break; 2869 2870 default: 2871 alt12=24;} 2872 2873 } 2874 break; 2875 2876 default: 2877 alt12=24;} 2878 2879 } 2880 break; 2881 2882 default: 2883 alt12=24;} 2884 2885 } 2886 break; 2887 case '_': 2888 case 'a': 2889 case 'b': 2890 case 'c': 2891 case 'd': 2892 case 'e': 2893 case 'g': 2894 case 'h': 2895 case 'i': 2896 case 'j': 2897 case 'k': 2898 case 'l': 2899 case 'm': 2900 case 'o': 2901 case 'p': 2902 case 'q': 2903 case 'r': 2904 case 's': 2905 case 't': 2906 case 'u': 2907 case 'v': 2908 case 'w': 2909 case 'x': 2910 case 'y': 2911 case 'z': 2912 { 2913 alt12=24; 2914 } 2915 break; 2916 2917 default: 2918 CONSTRUCTEX(); 2919 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 2920 EXCEPTION->message = (void *)""; 2921 EXCEPTION->decisionNum = 12; 2922 EXCEPTION->state = 4; 2923 2924 2925 goto ruleTokensEx; 2926 } 2927 2928 } 2929 break; 2930 case 'o': 2931 { 2932 switch ( LA(2) ) 2933 { 2934 case 'r': 2935 { 2936 switch ( LA(3) ) 2937 { 2938 case '_': 2939 case 'a': 2940 case 'b': 2941 case 'c': 2942 case 'd': 2943 case 'e': 2944 case 'f': 2945 case 'g': 2946 case 'h': 2947 case 'i': 2948 case 'j': 2949 case 'k': 2950 case 'l': 2951 case 'm': 2952 case 'n': 2953 case 'o': 2954 case 'p': 2955 case 'q': 2956 case 'r': 2957 case 's': 2958 case 't': 2959 case 'u': 2960 case 'v': 2961 case 'w': 2962 case 'x': 2963 case 'y': 2964 case 'z': 2965 { 2966 alt12=24; 2967 } 2968 break; 2969 2970 default: 2971 alt12=5;} 2972 2973 } 2974 break; 2975 case '_': 2976 case 'a': 2977 case 'b': 2978 case 'c': 2979 case 'd': 2980 case 'e': 2981 case 'f': 2982 case 'g': 2983 case 'h': 2984 case 'i': 2985 case 'j': 2986 case 'k': 2987 case 'l': 2988 case 'm': 2989 case 'n': 2990 case 'o': 2991 case 'p': 2992 case 'q': 2993 case 's': 2994 case 't': 2995 case 'u': 2996 case 'v': 2997 case 'w': 2998 case 'x': 2999 case 'y': 3000 case 'z': 3001 { 3002 alt12=24; 3003 } 3004 break; 3005 3006 default: 3007 CONSTRUCTEX(); 3008 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3009 EXCEPTION->message = (void *)""; 3010 EXCEPTION->decisionNum = 12; 3011 EXCEPTION->state = 5; 3012 3013 3014 goto ruleTokensEx; 3015 } 3016 3017 } 3018 break; 3019 case '!': 3020 { 3021 alt12=6; 3022 } 3023 break; 3024 case '=': 3025 { 3026 alt12=7; 3027 } 3028 break; 3029 case 'i': 3030 { 3031 switch ( LA(2) ) 3032 { 3033 case 'n': 3034 { 3035 switch ( LA(3) ) 3036 { 3037 case 'c': 3038 { 3039 switch ( LA(4) ) 3040 { 3041 case 'l': 3042 { 3043 switch ( LA(5) ) 3044 { 3045 case 'u': 3046 { 3047 switch ( LA(6) ) 3048 { 3049 case 'd': 3050 { 3051 switch ( LA(7) ) 3052 { 3053 case 'e': 3054 { 3055 switch ( LA(8) ) 3056 { 3057 case 's': 3058 { 3059 switch ( LA(9) ) 3060 { 3061 case '_': 3062 case 'a': 3063 case 'b': 3064 case 'c': 3065 case 'd': 3066 case 'e': 3067 case 'f': 3068 case 'g': 3069 case 'h': 3070 case 'i': 3071 case 'j': 3072 case 'k': 3073 case 'l': 3074 case 'm': 3075 case 'n': 3076 case 'o': 3077 case 'p': 3078 case 'q': 3079 case 'r': 3080 case 's': 3081 case 't': 3082 case 'u': 3083 case 'v': 3084 case 'w': 3085 case 'x': 3086 case 'y': 3087 case 'z': 3088 { 3089 alt12=24; 3090 } 3091 break; 3092 3093 default: 3094 alt12=8;} 3095 3096 } 3097 break; 3098 3099 default: 3100 alt12=24;} 3101 3102 } 3103 break; 3104 3105 default: 3106 alt12=24;} 3107 3108 } 3109 break; 3110 3111 default: 3112 alt12=24;} 3113 3114 } 3115 break; 3116 3117 default: 3118 alt12=24;} 3119 3120 } 3121 break; 3122 3123 default: 3124 alt12=24;} 3125 3126 } 3127 break; 3128 3129 default: 3130 alt12=24;} 3131 3132 } 3133 break; 3134 case '_': 3135 case 'a': 3136 case 'b': 3137 case 'c': 3138 case 'd': 3139 case 'e': 3140 case 'f': 3141 case 'g': 3142 case 'h': 3143 case 'i': 3144 case 'j': 3145 case 'k': 3146 case 'l': 3147 case 'm': 3148 case 'o': 3149 case 'p': 3150 case 'q': 3151 case 'r': 3152 case 's': 3153 case 't': 3154 case 'u': 3155 case 'v': 3156 case 'w': 3157 case 'x': 3158 case 'y': 3159 case 'z': 3160 { 3161 alt12=24; 3162 } 3163 break; 3164 3165 default: 3166 CONSTRUCTEX(); 3167 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3168 EXCEPTION->message = (void *)""; 3169 EXCEPTION->decisionNum = 12; 3170 EXCEPTION->state = 8; 3171 3172 3173 goto ruleTokensEx; 3174 } 3175 3176 } 3177 break; 3178 case 's': 3179 { 3180 switch ( LA(2) ) 3181 { 3182 case 't': 3183 { 3184 switch ( LA(3) ) 3185 { 3186 case 'a': 3187 { 3188 switch ( LA(4) ) 3189 { 3190 case 'r': 3191 { 3192 switch ( LA(5) ) 3193 { 3194 case 't': 3195 { 3196 switch ( LA(6) ) 3197 { 3198 case 's': 3199 { 3200 switch ( LA(7) ) 3201 { 3202 case 'w': 3203 { 3204 switch ( LA(8) ) 3205 { 3206 case 'i': 3207 { 3208 switch ( LA(9) ) 3209 { 3210 case 't': 3211 { 3212 switch ( LA(10) ) 3213 { 3214 case 'h': 3215 { 3216 switch ( LA(11) ) 3217 { 3218 case '_': 3219 case 'a': 3220 case 'b': 3221 case 'c': 3222 case 'd': 3223 case 'e': 3224 case 'f': 3225 case 'g': 3226 case 'h': 3227 case 'i': 3228 case 'j': 3229 case 'k': 3230 case 'l': 3231 case 'm': 3232 case 'n': 3233 case 'o': 3234 case 'p': 3235 case 'q': 3236 case 'r': 3237 case 's': 3238 case 't': 3239 case 'u': 3240 case 'v': 3241 case 'w': 3242 case 'x': 3243 case 'y': 3244 case 'z': 3245 { 3246 alt12=24; 3247 } 3248 break; 3249 3250 default: 3251 alt12=9;} 3252 3253 } 3254 break; 3255 3256 default: 3257 alt12=24;} 3258 3259 } 3260 break; 3261 3262 default: 3263 alt12=24;} 3264 3265 } 3266 break; 3267 3268 default: 3269 alt12=24;} 3270 3271 } 3272 break; 3273 3274 default: 3275 alt12=24;} 3276 3277 } 3278 break; 3279 3280 default: 3281 alt12=24;} 3282 3283 } 3284 break; 3285 3286 default: 3287 alt12=24;} 3288 3289 } 3290 break; 3291 3292 default: 3293 alt12=24;} 3294 3295 } 3296 break; 3297 3298 default: 3299 alt12=24;} 3300 3301 } 3302 break; 3303 case '_': 3304 case 'a': 3305 case 'b': 3306 case 'c': 3307 case 'd': 3308 case 'e': 3309 case 'f': 3310 case 'g': 3311 case 'h': 3312 case 'i': 3313 case 'j': 3314 case 'k': 3315 case 'l': 3316 case 'm': 3317 case 'n': 3318 case 'o': 3319 case 'p': 3320 case 'q': 3321 case 'r': 3322 case 's': 3323 case 'u': 3324 case 'v': 3325 case 'w': 3326 case 'x': 3327 case 'y': 3328 case 'z': 3329 { 3330 alt12=24; 3331 } 3332 break; 3333 3334 default: 3335 CONSTRUCTEX(); 3336 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3337 EXCEPTION->message = (void *)""; 3338 EXCEPTION->decisionNum = 12; 3339 EXCEPTION->state = 9; 3340 3341 3342 goto ruleTokensEx; 3343 } 3344 3345 } 3346 break; 3347 case 'e': 3348 { 3349 switch ( LA(2) ) 3350 { 3351 case 'n': 3352 { 3353 switch ( LA(3) ) 3354 { 3355 case 'd': 3356 { 3357 switch ( LA(4) ) 3358 { 3359 case 's': 3360 { 3361 switch ( LA(5) ) 3362 { 3363 case 'w': 3364 { 3365 switch ( LA(6) ) 3366 { 3367 case 'i': 3368 { 3369 switch ( LA(7) ) 3370 { 3371 case 't': 3372 { 3373 switch ( LA(8) ) 3374 { 3375 case 'h': 3376 { 3377 switch ( LA(9) ) 3378 { 3379 case '_': 3380 case 'a': 3381 case 'b': 3382 case 'c': 3383 case 'd': 3384 case 'e': 3385 case 'f': 3386 case 'g': 3387 case 'h': 3388 case 'i': 3389 case 'j': 3390 case 'k': 3391 case 'l': 3392 case 'm': 3393 case 'n': 3394 case 'o': 3395 case 'p': 3396 case 'q': 3397 case 'r': 3398 case 's': 3399 case 't': 3400 case 'u': 3401 case 'v': 3402 case 'w': 3403 case 'x': 3404 case 'y': 3405 case 'z': 3406 { 3407 alt12=24; 3408 } 3409 break; 3410 3411 default: 3412 alt12=10;} 3413 3414 } 3415 break; 3416 3417 default: 3418 alt12=24;} 3419 3420 } 3421 break; 3422 3423 default: 3424 alt12=24;} 3425 3426 } 3427 break; 3428 3429 default: 3430 alt12=24;} 3431 3432 } 3433 break; 3434 3435 default: 3436 alt12=24;} 3437 3438 } 3439 break; 3440 3441 default: 3442 alt12=24;} 3443 3444 } 3445 break; 3446 3447 default: 3448 alt12=24;} 3449 3450 } 3451 break; 3452 case '_': 3453 case 'a': 3454 case 'b': 3455 case 'c': 3456 case 'd': 3457 case 'e': 3458 case 'f': 3459 case 'g': 3460 case 'h': 3461 case 'i': 3462 case 'j': 3463 case 'k': 3464 case 'l': 3465 case 'm': 3466 case 'o': 3467 case 'p': 3468 case 'q': 3469 case 'r': 3470 case 's': 3471 case 't': 3472 case 'u': 3473 case 'v': 3474 case 'w': 3475 case 'x': 3476 case 'y': 3477 case 'z': 3478 { 3479 alt12=24; 3480 } 3481 break; 3482 3483 default: 3484 CONSTRUCTEX(); 3485 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3486 EXCEPTION->message = (void *)""; 3487 EXCEPTION->decisionNum = 12; 3488 EXCEPTION->state = 10; 3489 3490 3491 goto ruleTokensEx; 3492 } 3493 3494 } 3495 break; 3496 case '>': 3497 { 3498 switch ( LA(2) ) 3499 { 3500 case '=': 3501 { 3502 alt12=13; 3503 } 3504 break; 3505 3506 default: 3507 alt12=11;} 3508 3509 } 3510 break; 3511 case '<': 3512 { 3513 switch ( LA(2) ) 3514 { 3515 case '=': 3516 { 3517 alt12=14; 3518 } 3519 break; 3520 3521 default: 3522 alt12=12;} 3523 3524 } 3525 break; 3526 case 'b': 3527 { 3528 switch ( LA(2) ) 3529 { 3530 case 'e': 3531 { 3532 switch ( LA(3) ) 3533 { 3534 case 'f': 3535 { 3536 switch ( LA(4) ) 3537 { 3538 case 'o': 3539 { 3540 switch ( LA(5) ) 3541 { 3542 case 'r': 3543 { 3544 switch ( LA(6) ) 3545 { 3546 case 'e': 3547 { 3548 switch ( LA(7) ) 3549 { 3550 case '_': 3551 case 'a': 3552 case 'b': 3553 case 'c': 3554 case 'd': 3555 case 'e': 3556 case 'f': 3557 case 'g': 3558 case 'h': 3559 case 'i': 3560 case 'j': 3561 case 'k': 3562 case 'l': 3563 case 'm': 3564 case 'n': 3565 case 'o': 3566 case 'p': 3567 case 'q': 3568 case 'r': 3569 case 's': 3570 case 't': 3571 case 'u': 3572 case 'v': 3573 case 'w': 3574 case 'x': 3575 case 'y': 3576 case 'z': 3577 { 3578 alt12=24; 3579 } 3580 break; 3581 3582 default: 3583 alt12=15;} 3584 3585 } 3586 break; 3587 3588 default: 3589 alt12=24;} 3590 3591 } 3592 break; 3593 3594 default: 3595 alt12=24;} 3596 3597 } 3598 break; 3599 3600 default: 3601 alt12=24;} 3602 3603 } 3604 break; 3605 3606 default: 3607 alt12=24;} 3608 3609 } 3610 break; 3611 case '_': 3612 case 'a': 3613 case 'b': 3614 case 'c': 3615 case 'd': 3616 case 'f': 3617 case 'g': 3618 case 'h': 3619 case 'i': 3620 case 'j': 3621 case 'k': 3622 case 'l': 3623 case 'm': 3624 case 'n': 3625 case 'o': 3626 case 'p': 3627 case 'q': 3628 case 'r': 3629 case 's': 3630 case 't': 3631 case 'u': 3632 case 'v': 3633 case 'w': 3634 case 'x': 3635 case 'y': 3636 case 'z': 3637 { 3638 alt12=24; 3639 } 3640 break; 3641 3642 default: 3643 CONSTRUCTEX(); 3644 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3645 EXCEPTION->message = (void *)""; 3646 EXCEPTION->decisionNum = 12; 3647 EXCEPTION->state = 13; 3648 3649 3650 goto ruleTokensEx; 3651 } 3652 3653 } 3654 break; 3655 case 'd': 3656 { 3657 switch ( LA(2) ) 3658 { 3659 case 'a': 3660 { 3661 switch ( LA(3) ) 3662 { 3663 case 'y': 3664 { 3665 switch ( LA(4) ) 3666 { 3667 case 's': 3668 { 3669 switch ( LA(5) ) 3670 { 3671 case '_': 3672 case 'a': 3673 case 'b': 3674 case 'c': 3675 case 'd': 3676 case 'e': 3677 case 'f': 3678 case 'g': 3679 case 'h': 3680 case 'i': 3681 case 'j': 3682 case 'k': 3683 case 'l': 3684 case 'm': 3685 case 'n': 3686 case 'o': 3687 case 'p': 3688 case 'q': 3689 case 'r': 3690 case 's': 3691 case 't': 3692 case 'u': 3693 case 'v': 3694 case 'w': 3695 case 'x': 3696 case 'y': 3697 case 'z': 3698 { 3699 alt12=24; 3700 } 3701 break; 3702 3703 default: 3704 alt12=17;} 3705 3706 } 3707 break; 3708 case '_': 3709 case 'a': 3710 case 'b': 3711 case 'c': 3712 case 'd': 3713 case 'e': 3714 case 'f': 3715 case 'g': 3716 case 'h': 3717 case 'i': 3718 case 'j': 3719 case 'k': 3720 case 'l': 3721 case 'm': 3722 case 'n': 3723 case 'o': 3724 case 'p': 3725 case 'q': 3726 case 'r': 3727 case 't': 3728 case 'u': 3729 case 'v': 3730 case 'w': 3731 case 'x': 3732 case 'y': 3733 case 'z': 3734 { 3735 alt12=24; 3736 } 3737 break; 3738 3739 default: 3740 alt12=17;} 3741 3742 } 3743 break; 3744 3745 default: 3746 alt12=24;} 3747 3748 } 3749 break; 3750 case '_': 3751 case 'b': 3752 case 'c': 3753 case 'd': 3754 case 'e': 3755 case 'f': 3756 case 'g': 3757 case 'h': 3758 case 'i': 3759 case 'j': 3760 case 'k': 3761 case 'l': 3762 case 'm': 3763 case 'n': 3764 case 'o': 3765 case 'p': 3766 case 'q': 3767 case 'r': 3768 case 's': 3769 case 't': 3770 case 'u': 3771 case 'v': 3772 case 'w': 3773 case 'x': 3774 case 'y': 3775 case 'z': 3776 { 3777 alt12=24; 3778 } 3779 break; 3780 3781 default: 3782 CONSTRUCTEX(); 3783 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3784 EXCEPTION->message = (void *)""; 3785 EXCEPTION->decisionNum = 12; 3786 EXCEPTION->state = 14; 3787 3788 3789 goto ruleTokensEx; 3790 } 3791 3792 } 3793 break; 3794 case 'w': 3795 { 3796 switch ( LA(2) ) 3797 { 3798 case 'e': 3799 { 3800 switch ( LA(3) ) 3801 { 3802 case 'e': 3803 { 3804 switch ( LA(4) ) 3805 { 3806 case 'k': 3807 { 3808 switch ( LA(5) ) 3809 { 3810 case 's': 3811 { 3812 switch ( LA(6) ) 3813 { 3814 case '_': 3815 case 'a': 3816 case 'b': 3817 case 'c': 3818 case 'd': 3819 case 'e': 3820 case 'f': 3821 case 'g': 3822 case 'h': 3823 case 'i': 3824 case 'j': 3825 case 'k': 3826 case 'l': 3827 case 'm': 3828 case 'n': 3829 case 'o': 3830 case 'p': 3831 case 'q': 3832 case 'r': 3833 case 's': 3834 case 't': 3835 case 'u': 3836 case 'v': 3837 case 'w': 3838 case 'x': 3839 case 'y': 3840 case 'z': 3841 { 3842 alt12=24; 3843 } 3844 break; 3845 3846 default: 3847 alt12=18;} 3848 3849 } 3850 break; 3851 case '_': 3852 case 'a': 3853 case 'b': 3854 case 'c': 3855 case 'd': 3856 case 'e': 3857 case 'f': 3858 case 'g': 3859 case 'h': 3860 case 'i': 3861 case 'j': 3862 case 'k': 3863 case 'l': 3864 case 'm': 3865 case 'n': 3866 case 'o': 3867 case 'p': 3868 case 'q': 3869 case 'r': 3870 case 't': 3871 case 'u': 3872 case 'v': 3873 case 'w': 3874 case 'x': 3875 case 'y': 3876 case 'z': 3877 { 3878 alt12=24; 3879 } 3880 break; 3881 3882 default: 3883 alt12=18;} 3884 3885 } 3886 break; 3887 3888 default: 3889 alt12=24;} 3890 3891 } 3892 break; 3893 3894 default: 3895 alt12=24;} 3896 3897 } 3898 break; 3899 case '_': 3900 case 'a': 3901 case 'b': 3902 case 'c': 3903 case 'd': 3904 case 'f': 3905 case 'g': 3906 case 'h': 3907 case 'i': 3908 case 'j': 3909 case 'k': 3910 case 'l': 3911 case 'm': 3912 case 'n': 3913 case 'o': 3914 case 'p': 3915 case 'q': 3916 case 'r': 3917 case 's': 3918 case 't': 3919 case 'u': 3920 case 'v': 3921 case 'w': 3922 case 'x': 3923 case 'y': 3924 case 'z': 3925 { 3926 alt12=24; 3927 } 3928 break; 3929 3930 default: 3931 CONSTRUCTEX(); 3932 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 3933 EXCEPTION->message = (void *)""; 3934 EXCEPTION->decisionNum = 12; 3935 EXCEPTION->state = 15; 3936 3937 3938 goto ruleTokensEx; 3939 } 3940 3941 } 3942 break; 3943 case 'm': 3944 { 3945 switch ( LA(2) ) 3946 { 3947 case 'o': 3948 { 3949 switch ( LA(3) ) 3950 { 3951 case 'n': 3952 { 3953 switch ( LA(4) ) 3954 { 3955 case 't': 3956 { 3957 switch ( LA(5) ) 3958 { 3959 case 'h': 3960 { 3961 switch ( LA(6) ) 3962 { 3963 case 's': 3964 { 3965 switch ( LA(7) ) 3966 { 3967 case '_': 3968 case 'a': 3969 case 'b': 3970 case 'c': 3971 case 'd': 3972 case 'e': 3973 case 'f': 3974 case 'g': 3975 case 'h': 3976 case 'i': 3977 case 'j': 3978 case 'k': 3979 case 'l': 3980 case 'm': 3981 case 'n': 3982 case 'o': 3983 case 'p': 3984 case 'q': 3985 case 'r': 3986 case 's': 3987 case 't': 3988 case 'u': 3989 case 'v': 3990 case 'w': 3991 case 'x': 3992 case 'y': 3993 case 'z': 3994 { 3995 alt12=24; 3996 } 3997 break; 3998 3999 default: 4000 alt12=19;} 4001 4002 } 4003 break; 4004 case '_': 4005 case 'a': 4006 case 'b': 4007 case 'c': 4008 case 'd': 4009 case 'e': 4010 case 'f': 4011 case 'g': 4012 case 'h': 4013 case 'i': 4014 case 'j': 4015 case 'k': 4016 case 'l': 4017 case 'm': 4018 case 'n': 4019 case 'o': 4020 case 'p': 4021 case 'q': 4022 case 'r': 4023 case 't': 4024 case 'u': 4025 case 'v': 4026 case 'w': 4027 case 'x': 4028 case 'y': 4029 case 'z': 4030 { 4031 alt12=24; 4032 } 4033 break; 4034 4035 default: 4036 alt12=19;} 4037 4038 } 4039 break; 4040 4041 default: 4042 alt12=24;} 4043 4044 } 4045 break; 4046 4047 default: 4048 alt12=24;} 4049 4050 } 4051 break; 4052 4053 default: 4054 alt12=24;} 4055 4056 } 4057 break; 4058 case '_': 4059 case 'a': 4060 case 'b': 4061 case 'c': 4062 case 'd': 4063 case 'e': 4064 case 'f': 4065 case 'g': 4066 case 'h': 4067 case 'i': 4068 case 'j': 4069 case 'k': 4070 case 'l': 4071 case 'm': 4072 case 'n': 4073 case 'p': 4074 case 'q': 4075 case 'r': 4076 case 's': 4077 case 't': 4078 case 'u': 4079 case 'v': 4080 case 'w': 4081 case 'x': 4082 case 'y': 4083 case 'z': 4084 { 4085 alt12=24; 4086 } 4087 break; 4088 4089 default: 4090 CONSTRUCTEX(); 4091 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 4092 EXCEPTION->message = (void *)""; 4093 EXCEPTION->decisionNum = 12; 4094 EXCEPTION->state = 16; 4095 4096 4097 goto ruleTokensEx; 4098 } 4099 4100 } 4101 break; 4102 case 'y': 4103 { 4104 switch ( LA(2) ) 4105 { 4106 case 'e': 4107 { 4108 switch ( LA(3) ) 4109 { 4110 case 'a': 4111 { 4112 switch ( LA(4) ) 4113 { 4114 case 'r': 4115 { 4116 switch ( LA(5) ) 4117 { 4118 case 's': 4119 { 4120 switch ( LA(6) ) 4121 { 4122 case '_': 4123 case 'a': 4124 case 'b': 4125 case 'c': 4126 case 'd': 4127 case 'e': 4128 case 'f': 4129 case 'g': 4130 case 'h': 4131 case 'i': 4132 case 'j': 4133 case 'k': 4134 case 'l': 4135 case 'm': 4136 case 'n': 4137 case 'o': 4138 case 'p': 4139 case 'q': 4140 case 'r': 4141 case 's': 4142 case 't': 4143 case 'u': 4144 case 'v': 4145 case 'w': 4146 case 'x': 4147 case 'y': 4148 case 'z': 4149 { 4150 alt12=24; 4151 } 4152 break; 4153 4154 default: 4155 alt12=20;} 4156 4157 } 4158 break; 4159 case '_': 4160 case 'a': 4161 case 'b': 4162 case 'c': 4163 case 'd': 4164 case 'e': 4165 case 'f': 4166 case 'g': 4167 case 'h': 4168 case 'i': 4169 case 'j': 4170 case 'k': 4171 case 'l': 4172 case 'm': 4173 case 'n': 4174 case 'o': 4175 case 'p': 4176 case 'q': 4177 case 'r': 4178 case 't': 4179 case 'u': 4180 case 'v': 4181 case 'w': 4182 case 'x': 4183 case 'y': 4184 case 'z': 4185 { 4186 alt12=24; 4187 } 4188 break; 4189 4190 default: 4191 alt12=20;} 4192 4193 } 4194 break; 4195 4196 default: 4197 alt12=24;} 4198 4199 } 4200 break; 4201 4202 default: 4203 alt12=24;} 4204 4205 } 4206 break; 4207 case '_': 4208 case 'a': 4209 case 'b': 4210 case 'c': 4211 case 'd': 4212 case 'f': 4213 case 'g': 4214 case 'h': 4215 case 'i': 4216 case 'j': 4217 case 'k': 4218 case 'l': 4219 case 'm': 4220 case 'n': 4221 case 'o': 4222 case 'p': 4223 case 'q': 4224 case 'r': 4225 case 's': 4226 case 't': 4227 case 'u': 4228 case 'v': 4229 case 'w': 4230 case 'x': 4231 case 'y': 4232 case 'z': 4233 { 4234 alt12=24; 4235 } 4236 break; 4237 4238 default: 4239 CONSTRUCTEX(); 4240 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 4241 EXCEPTION->message = (void *)""; 4242 EXCEPTION->decisionNum = 12; 4243 EXCEPTION->state = 17; 4244 4245 4246 goto ruleTokensEx; 4247 } 4248 4249 } 4250 break; 4251 case 't': 4252 { 4253 switch ( LA(2) ) 4254 { 4255 case 'o': 4256 { 4257 switch ( LA(3) ) 4258 { 4259 case 'd': 4260 { 4261 switch ( LA(4) ) 4262 { 4263 case 'a': 4264 { 4265 switch ( LA(5) ) 4266 { 4267 case 'y': 4268 { 4269 switch ( LA(6) ) 4270 { 4271 case '_': 4272 case 'a': 4273 case 'b': 4274 case 'c': 4275 case 'd': 4276 case 'e': 4277 case 'f': 4278 case 'g': 4279 case 'h': 4280 case 'i': 4281 case 'j': 4282 case 'k': 4283 case 'l': 4284 case 'm': 4285 case 'n': 4286 case 'o': 4287 case 'p': 4288 case 'q': 4289 case 'r': 4290 case 's': 4291 case 't': 4292 case 'u': 4293 case 'v': 4294 case 'w': 4295 case 'x': 4296 case 'y': 4297 case 'z': 4298 { 4299 alt12=24; 4300 } 4301 break; 4302 4303 default: 4304 alt12=21;} 4305 4306 } 4307 break; 4308 4309 default: 4310 alt12=24;} 4311 4312 } 4313 break; 4314 4315 default: 4316 alt12=24;} 4317 4318 } 4319 break; 4320 4321 default: 4322 alt12=24;} 4323 4324 } 4325 break; 4326 case '_': 4327 case 'a': 4328 case 'b': 4329 case 'c': 4330 case 'd': 4331 case 'e': 4332 case 'f': 4333 case 'g': 4334 case 'h': 4335 case 'i': 4336 case 'j': 4337 case 'k': 4338 case 'l': 4339 case 'm': 4340 case 'n': 4341 case 'p': 4342 case 'q': 4343 case 'r': 4344 case 's': 4345 case 't': 4346 case 'u': 4347 case 'v': 4348 case 'w': 4349 case 'x': 4350 case 'y': 4351 case 'z': 4352 { 4353 alt12=24; 4354 } 4355 break; 4356 4357 default: 4358 CONSTRUCTEX(); 4359 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 4360 EXCEPTION->message = (void *)""; 4361 EXCEPTION->decisionNum = 12; 4362 EXCEPTION->state = 18; 4363 4364 4365 goto ruleTokensEx; 4366 } 4367 4368 } 4369 break; 4370 case '\n': 4371 case '\r': 4372 { 4373 alt12=22; 4374 } 4375 break; 4376 case '\t': 4377 case ' ': 4378 { 4379 alt12=23; 4380 } 4381 break; 4382 case 'c': 4383 case 'f': 4384 case 'g': 4385 case 'h': 4386 case 'j': 4387 case 'k': 4388 case 'l': 4389 case 'n': 4390 case 'p': 4391 case 'q': 4392 case 'r': 4393 case 'u': 4394 case 'v': 4395 case 'x': 4396 case 'z': 4397 { 4398 alt12=24; 4399 } 4400 break; 4401 case '1': 4402 case '2': 4403 case '3': 4404 case '4': 4405 case '5': 4406 case '6': 4407 case '7': 4408 case '8': 4409 case '9': 4410 { 4411 switch ( LA(2) ) 4412 { 4413 case '0': 4414 case '1': 4415 case '2': 4416 case '3': 4417 case '4': 4418 case '5': 4419 case '6': 4420 case '7': 4421 case '8': 4422 case '9': 4423 { 4424 switch ( LA(3) ) 4425 { 4426 case '0': 4427 case '1': 4428 case '2': 4429 case '3': 4430 case '4': 4431 case '5': 4432 case '6': 4433 case '7': 4434 case '8': 4435 case '9': 4436 { 4437 switch ( LA(4) ) 4438 { 4439 case '0': 4440 case '1': 4441 case '2': 4442 case '3': 4443 case '4': 4444 case '5': 4445 case '6': 4446 case '7': 4447 case '8': 4448 case '9': 4449 { 4450 switch ( LA(5) ) 4451 { 4452 case '-': 4453 { 4454 alt12=26; 4455 } 4456 break; 4457 4458 default: 4459 alt12=25;} 4460 4461 } 4462 break; 4463 4464 default: 4465 alt12=25;} 4466 4467 } 4468 break; 4469 4470 default: 4471 alt12=25;} 4472 4473 } 4474 break; 4475 4476 default: 4477 alt12=25;} 4478 4479 } 4480 break; 4481 4482 default: 4483 CONSTRUCTEX(); 4484 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 4485 EXCEPTION->message = (void *)""; 4486 EXCEPTION->decisionNum = 12; 4487 EXCEPTION->state = 0; 4488 4489 4490 goto ruleTokensEx; 4491 } 4492 4493 switch (alt12) 4494 { 4495 case 1: 4496 // RSP.g:1:10: QUOTE 4497 { 4498 /* 1:10: QUOTE */ 4499 mQUOTE(ctx ); 4500 if (HASEXCEPTION()) 4501 { 4502 goto ruleTokensEx; 4503 } 4504 4505 4506 } 4507 break; 4508 case 2: 4509 // RSP.g:1:16: LPAR 4510 { 4511 /* 1:16: LPAR */ 4512 mLPAR(ctx ); 4513 if (HASEXCEPTION()) 4514 { 4515 goto ruleTokensEx; 4516 } 4517 4518 4519 } 4520 break; 4521 case 3: 4522 // RSP.g:1:21: RPAR 4523 { 4524 /* 1:21: RPAR */ 4525 mRPAR(ctx ); 4526 if (HASEXCEPTION()) 4527 { 4528 goto ruleTokensEx; 4529 } 4530 4531 4532 } 4533 break; 4534 case 4: 4535 // RSP.g:1:26: AND 4536 { 4537 /* 1:26: AND */ 4538 mAND(ctx ); 4539 if (HASEXCEPTION()) 4540 { 4541 goto ruleTokensEx; 4542 } 4543 4544 4545 } 4546 break; 4547 case 5: 4548 // RSP.g:1:30: OR 4549 { 4550 /* 1:30: OR */ 4551 mOR(ctx ); 4552 if (HASEXCEPTION()) 4553 { 4554 goto ruleTokensEx; 4555 } 4556 4557 4558 } 4559 break; 4560 case 6: 4561 // RSP.g:1:33: NOT 4562 { 4563 /* 1:33: NOT */ 4564 mNOT(ctx ); 4565 if (HASEXCEPTION()) 4566 { 4567 goto ruleTokensEx; 4568 } 4569 4570 4571 } 4572 break; 4573 case 7: 4574 // RSP.g:1:37: EQUAL 4575 { 4576 /* 1:37: EQUAL */ 4577 mEQUAL(ctx ); 4578 if (HASEXCEPTION()) 4579 { 4580 goto ruleTokensEx; 4581 } 4582 4583 4584 } 4585 break; 4586 case 8: 4587 // RSP.g:1:43: INCLUDES 4588 { 4589 /* 1:43: INCLUDES */ 4590 mINCLUDES(ctx ); 4591 if (HASEXCEPTION()) 4592 { 4593 goto ruleTokensEx; 4594 } 4595 4596 4597 } 4598 break; 4599 case 9: 4600 // RSP.g:1:52: STARTSW 4601 { 4602 /* 1:52: STARTSW */ 4603 mSTARTSW(ctx ); 4604 if (HASEXCEPTION()) 4605 { 4606 goto ruleTokensEx; 4607 } 4608 4609 4610 } 4611 break; 4612 case 10: 4613 // RSP.g:1:60: ENDSW 4614 { 4615 /* 1:60: ENDSW */ 4616 mENDSW(ctx ); 4617 if (HASEXCEPTION()) 4618 { 4619 goto ruleTokensEx; 4620 } 4621 4622 4623 } 4624 break; 4625 case 11: 4626 // RSP.g:1:66: GREATER 4627 { 4628 /* 1:66: GREATER */ 4629 mGREATER(ctx ); 4630 if (HASEXCEPTION()) 4631 { 4632 goto ruleTokensEx; 4633 } 4634 4635 4636 } 4637 break; 4638 case 12: 4639 // RSP.g:1:74: LESS 4640 { 4641 /* 1:74: LESS */ 4642 mLESS(ctx ); 4643 if (HASEXCEPTION()) 4644 { 4645 goto ruleTokensEx; 4646 } 4647 4648 4649 } 4650 break; 4651 case 13: 4652 // RSP.g:1:79: GTE 4653 { 4654 /* 1:79: GTE */ 4655 mGTE(ctx ); 4656 if (HASEXCEPTION()) 4657 { 4658 goto ruleTokensEx; 4659 } 4660 4661 4662 } 4663 break; 4664 case 14: 4665 // RSP.g:1:83: LTE 4666 { 4667 /* 1:83: LTE */ 4668 mLTE(ctx ); 4669 if (HASEXCEPTION()) 4670 { 4671 goto ruleTokensEx; 4672 } 4673 4674 4675 } 4676 break; 4677 case 15: 4678 // RSP.g:1:87: BEFORE 4679 { 4680 /* 1:87: BEFORE */ 4681 mBEFORE(ctx ); 4682 if (HASEXCEPTION()) 4683 { 4684 goto ruleTokensEx; 4685 } 4686 4687 4688 } 4689 break; 4690 case 16: 4691 // RSP.g:1:94: AFTER 4692 { 4693 /* 1:94: AFTER */ 4694 mAFTER(ctx ); 4695 if (HASEXCEPTION()) 4696 { 4697 goto ruleTokensEx; 4698 } 4699 4700 4701 } 4702 break; 4703 case 17: 4704 // RSP.g:1:100: DAY 4705 { 4706 /* 1:100: DAY */ 4707 mDAY(ctx ); 4708 if (HASEXCEPTION()) 4709 { 4710 goto ruleTokensEx; 4711 } 4712 4713 4714 } 4715 break; 4716 case 18: 4717 // RSP.g:1:104: WEEK 4718 { 4719 /* 1:104: WEEK */ 4720 mWEEK(ctx ); 4721 if (HASEXCEPTION()) 4722 { 4723 goto ruleTokensEx; 4724 } 4725 4726 4727 } 4728 break; 4729 case 19: 4730 // RSP.g:1:109: MONTH 4731 { 4732 /* 1:109: MONTH */ 4733 mMONTH(ctx ); 4734 if (HASEXCEPTION()) 4735 { 4736 goto ruleTokensEx; 4737 } 4738 4739 4740 } 4741 break; 4742 case 20: 4743 // RSP.g:1:115: YEAR 4744 { 4745 /* 1:115: YEAR */ 4746 mYEAR(ctx ); 4747 if (HASEXCEPTION()) 4748 { 4749 goto ruleTokensEx; 4750 } 4751 4752 4753 } 4754 break; 4755 case 21: 4756 // RSP.g:1:120: TODAY 4757 { 4758 /* 1:120: TODAY */ 4759 mTODAY(ctx ); 4760 if (HASEXCEPTION()) 4761 { 4762 goto ruleTokensEx; 4763 } 4764 4765 4766 } 4767 break; 4768 case 22: 4769 // RSP.g:1:126: NEWLINE 4770 { 4771 /* 1:126: NEWLINE */ 4772 mNEWLINE(ctx ); 4773 if (HASEXCEPTION()) 4774 { 4775 goto ruleTokensEx; 4776 } 4777 4778 4779 } 4780 break; 4781 case 23: 4782 // RSP.g:1:134: WS 4783 { 4784 /* 1:134: WS */ 4785 mWS(ctx ); 4786 if (HASEXCEPTION()) 4787 { 4788 goto ruleTokensEx; 4789 } 4790 4791 4792 } 4793 break; 4794 case 24: 4795 // RSP.g:1:137: FIELD 4796 { 4797 /* 1:137: FIELD */ 4798 mFIELD(ctx ); 4799 if (HASEXCEPTION()) 4800 { 4801 goto ruleTokensEx; 4802 } 4803 4804 4805 } 4806 break; 4807 case 25: 4808 // RSP.g:1:143: INT 4809 { 4810 /* 1:143: INT */ 4811 mINT(ctx ); 4812 if (HASEXCEPTION()) 4813 { 4814 goto ruleTokensEx; 4815 } 4816 4817 4818 } 4819 break; 4820 case 26: 4821 // RSP.g:1:147: DATE 4822 { 4823 /* 1:147: DATE */ 4824 mDATE(ctx ); 4825 if (HASEXCEPTION()) 4826 { 4827 goto ruleTokensEx; 4828 } 4829 4830 4831 } 4832 break; 4833 case 27: 4834 // RSP.g:1:152: STR 4835 { 4836 /* 1:152: STR */ 4837 mSTR(ctx ); 4838 if (HASEXCEPTION()) 4839 { 4840 goto ruleTokensEx; 4841 } 4842 4843 4844 } 4845 break; 4846 4847 } 4848 } 4849 4850 4851 goto ruleTokensEx; /* Prevent compiler warnings */ 4852ruleTokensEx: ; 4853} 4854 4855/* ========================================================================= 4856 * Lexer matching rules end. 4857 * ========================================================================= 4858 */ 4859/* End of Lexer code 4860 * ================================================ 4861 * ================================================ 4862 */ 4863 4864 4865/* End of code 4866 * ============================================================================= 4867 */ 4868