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 parser : RSPParserParser * 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 "RSPParser.h" 46/* ----------------------------------------- */ 47 48 49 50 51 52/* MACROS that hide the C interface implementations from the 53 * generated code, which makes it a little more understandable to the human eye. 54 * I am very much against using C pre-processor macros for function calls and bits 55 * of code as you cannot see what is happening when single stepping in debuggers 56 * and so on. The exception (in my book at least) is for generated code, where you are 57 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input() 58 * hides some indirect calls, but is always referring to the input stream. This is 59 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig 60 * the runtime interfaces without changing the generated code too often, without 61 * confusing the reader of the generated output, who may not wish to know the gory 62 * details of the interface inheritance. 63 */ 64 65#define CTX ctx 66 67/* Aids in accessing scopes for grammar programmers 68 */ 69#undef SCOPE_TYPE 70#undef SCOPE_STACK 71#undef SCOPE_TOP 72#define SCOPE_TYPE(scope) pRSPParser_##scope##_SCOPE 73#define SCOPE_STACK(scope) pRSPParser_##scope##Stack 74#define SCOPE_TOP(scope) ctx->pRSPParser_##scope##Top 75#define SCOPE_SIZE(scope) ctx->pRSPParser_##scope##Stack_limit 76#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i)) 77 78/* Macros for accessing things in the parser 79 */ 80 81#undef PARSER 82#undef RECOGNIZER 83#undef HAVEPARSEDRULE 84#undef MEMOIZE 85#undef INPUT 86#undef STRSTREAM 87#undef HASEXCEPTION 88#undef EXCEPTION 89#undef MATCHT 90#undef MATCHANYT 91#undef FOLLOWSTACK 92#undef FOLLOWPUSH 93#undef FOLLOWPOP 94#undef PRECOVER 95#undef PREPORTERROR 96#undef LA 97#undef LT 98#undef CONSTRUCTEX 99#undef CONSUME 100#undef MARK 101#undef REWIND 102#undef REWINDLAST 103#undef PERRORRECOVERY 104#undef HASFAILED 105#undef FAILEDFLAG 106#undef RECOVERFROMMISMATCHEDSET 107#undef RECOVERFROMMISMATCHEDELEMENT 108#undef INDEX 109#undef ADAPTOR 110#undef SEEK 111#undef RULEMEMO 112#undef DBG 113 114#define PARSER ctx->pParser 115#define RECOGNIZER PARSER->rec 116#define PSRSTATE RECOGNIZER->state 117#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r) 118#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si) 119#define INPUT PARSER->tstream 120#define STRSTREAM INPUT 121#define ISTREAM INPUT->istream 122#define INDEX() ISTREAM->index(INPUT->istream) 123#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE) 124#define EXCEPTION PSRSTATE->exception 125#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs) 126#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER) 127#define FOLLOWSTACK PSRSTATE->following 128#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL) 129#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK) 130#define PRECOVER() RECOGNIZER->recover(RECOGNIZER) 131#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER) 132#define LA(n) INPUT->istream->_LA(ISTREAM, n) 133#define LT(n) INPUT->_LT(INPUT, n) 134#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER) 135#define CONSUME() ISTREAM->consume(ISTREAM) 136#define MARK() ISTREAM->mark(ISTREAM) 137#define REWIND(m) ISTREAM->rewind(ISTREAM, m) 138#define REWINDLAST() ISTREAM->rewindLast(ISTREAM) 139#define SEEK(n) ISTREAM->seek(ISTREAM, n) 140#define PERRORRECOVERY PSRSTATE->errorRecovery 141#define FAILEDFLAG PSRSTATE->failed 142#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE) 143#define BACKTRACKING PSRSTATE->backtracking 144#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s) 145#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s) 146#define ADAPTOR ctx->adaptor 147#define RULEMEMO PSRSTATE->ruleMemo 148#define DBG RECOGNIZER->debugger 149 150#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt 151 152/* The 4 tokens defined below may well clash with your own #defines or token types. If so 153 * then for the present you must use different names for your defines as these are hard coded 154 * in the code generator. It would be better not to use such names internally, and maybe 155 * we can change this in a forthcoming release. I deliberately do not #undef these 156 * here as this will at least give you a redefined error somewhere if they clash. 157 */ 158#define UP ANTLR3_TOKEN_UP 159#define DOWN ANTLR3_TOKEN_DOWN 160#define EOR ANTLR3_TOKEN_EOR 161#define INVALID ANTLR3_TOKEN_INVALID 162 163 164/* ============================================================================= 165 * Functions to create and destroy scopes. First come the rule scopes, followed 166 * by the global declared scopes. 167 */ 168 169 170 171/* ============================================================================= */ 172 173/* ============================================================================= 174 * Start of recognizer 175 */ 176 177 178 179/** \brief Table of all token names in symbolic order, mainly used for 180 * error reporting. 181 */ 182pANTLR3_UINT8 RSPParserTokenNames[30+4] 183 = { 184 (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */ 185 (pANTLR3_UINT8) "<EOR>", 186 (pANTLR3_UINT8) "<DOWN>", 187 (pANTLR3_UINT8) "<UP>", 188 (pANTLR3_UINT8) "NEWLINE", 189 (pANTLR3_UINT8) "OR", 190 (pANTLR3_UINT8) "AND", 191 (pANTLR3_UINT8) "LPAR", 192 (pANTLR3_UINT8) "RPAR", 193 (pANTLR3_UINT8) "FIELD", 194 (pANTLR3_UINT8) "STR", 195 (pANTLR3_UINT8) "NOT", 196 (pANTLR3_UINT8) "EQUAL", 197 (pANTLR3_UINT8) "INCLUDES", 198 (pANTLR3_UINT8) "STARTSW", 199 (pANTLR3_UINT8) "ENDSW", 200 (pANTLR3_UINT8) "INT", 201 (pANTLR3_UINT8) "LESS", 202 (pANTLR3_UINT8) "GREATER", 203 (pANTLR3_UINT8) "LTE", 204 (pANTLR3_UINT8) "GTE", 205 (pANTLR3_UINT8) "BEFORE", 206 (pANTLR3_UINT8) "AFTER", 207 (pANTLR3_UINT8) "DATE", 208 (pANTLR3_UINT8) "TODAY", 209 (pANTLR3_UINT8) "DAY", 210 (pANTLR3_UINT8) "WEEK", 211 (pANTLR3_UINT8) "MONTH", 212 (pANTLR3_UINT8) "YEAR", 213 (pANTLR3_UINT8) "QUOTE", 214 (pANTLR3_UINT8) "WS", 215 (pANTLR3_UINT8) "DIGIT19", 216 (pANTLR3_UINT8) "DIGIT09", 217 (pANTLR3_UINT8) "ESCAPED" 218 }; 219 220 221 222// Forward declare the locally static matching functions we have generated. 223// 224static RSPParser_query_return query (pRSPParser ctx); 225static RSPParser_expr_return expr (pRSPParser ctx); 226static RSPParser_aexpr_return aexpr (pRSPParser ctx); 227static RSPParser_crit_return crit (pRSPParser ctx); 228static RSPParser_strcrit_return strcrit (pRSPParser ctx); 229static RSPParser_strop_return strop (pRSPParser ctx); 230static RSPParser_intcrit_return intcrit (pRSPParser ctx); 231static RSPParser_intop_return intop (pRSPParser ctx); 232static RSPParser_datecrit_return datecrit (pRSPParser ctx); 233static RSPParser_dateop_return dateop (pRSPParser ctx); 234static RSPParser_datespec_return datespec (pRSPParser ctx); 235static RSPParser_dateref_return dateref (pRSPParser ctx); 236static RSPParser_dateintval_return dateintval (pRSPParser ctx); 237static void RSPParserFree(pRSPParser ctx); 238/* For use in tree output where we are accumulating rule labels via label += ruleRef 239 * we need a function that knows how to free a return scope when the list is destroyed. 240 * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro. 241 */ 242static void ANTLR3_CDECL freeScope(void * scope) 243{ 244 ANTLR3_FREE(scope); 245} 246 247/** \brief Name of the grammar file that generated this code 248 */ 249static const char fileName[] = "RSP.g"; 250 251/** \brief Return the name of the grammar file that generated this code. 252 */ 253static const char * getGrammarFileName() 254{ 255 return fileName; 256} 257/** \brief Create a new RSPParser parser and return a context for it. 258 * 259 * \param[in] instream Pointer to an input stream interface. 260 * 261 * \return Pointer to new parser context upon success. 262 */ 263ANTLR3_API pRSPParser 264RSPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream) 265{ 266 // See if we can create a new parser with the standard constructor 267 // 268 return RSPParserNewSSD(instream, NULL); 269} 270 271/** \brief Create a new RSPParser parser and return a context for it. 272 * 273 * \param[in] instream Pointer to an input stream interface. 274 * 275 * \return Pointer to new parser context upon success. 276 */ 277ANTLR3_API pRSPParser 278RSPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) 279{ 280 pRSPParser ctx; /* Context structure we will build and return */ 281 282 ctx = (pRSPParser) ANTLR3_CALLOC(1, sizeof(RSPParser)); 283 284 if (ctx == NULL) 285 { 286 // Failed to allocate memory for parser context 287 // 288 return NULL; 289 } 290 291 /* ------------------------------------------------------------------- 292 * Memory for basic structure is allocated, now to fill in 293 * the base ANTLR3 structures. We initialize the function pointers 294 * for the standard ANTLR3 parser function set, but upon return 295 * from here, the programmer may set the pointers to provide custom 296 * implementations of each function. 297 * 298 * We don't use the macros defined in RSPParser.h here, in order that you can get a sense 299 * of what goes where. 300 */ 301 302 /* Create a base parser/recognizer, using the supplied token stream 303 */ 304 ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state); 305 /* Install the implementation of our RSPParser interface 306 */ 307 ctx->query = query; 308 ctx->expr = expr; 309 ctx->aexpr = aexpr; 310 ctx->crit = crit; 311 ctx->strcrit = strcrit; 312 ctx->strop = strop; 313 ctx->intcrit = intcrit; 314 ctx->intop = intop; 315 ctx->datecrit = datecrit; 316 ctx->dateop = dateop; 317 ctx->datespec = datespec; 318 ctx->dateref = dateref; 319 ctx->dateintval = dateintval; 320 ctx->free = RSPParserFree; 321 ctx->getGrammarFileName = getGrammarFileName; 322 323 /* Install the scope pushing methods. 324 */ 325 ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory); 326 ctx->vectors = antlr3VectorFactoryNew(0); 327 328 329 330 /* Install the token table 331 */ 332 PSRSTATE->tokenNames = RSPParserTokenNames; 333 334 335 /* Return the newly built parser to the caller 336 */ 337 return ctx; 338} 339 340/** Free the parser resources 341 */ 342 static void 343 RSPParserFree(pRSPParser ctx) 344 { 345 /* Free any scope memory 346 */ 347 348 ctx->vectors->close(ctx->vectors); 349 /* We created the adaptor so we must free it 350 */ 351 ADAPTOR->free(ADAPTOR); 352 // Free this parser 353 // 354 ctx->pParser->free(ctx->pParser); 355 ANTLR3_FREE(ctx); 356 357 /* Everything is released, so we can return 358 */ 359 return; 360 } 361 362/** Return token names used by this parser 363 * 364 * The returned pointer is used as an index into the token names table (using the token 365 * number as the index). 366 * 367 * \return Pointer to first char * in the table. 368 */ 369static pANTLR3_UINT8 *getTokenNames() 370{ 371 return RSPParserTokenNames; 372} 373 374 375/* Declare the bitsets 376 */ 377 378/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query42 */ 379static ANTLR3_BITWORD FOLLOW_expr_in_query42_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) }; 380static ANTLR3_BITSET_LIST FOLLOW_expr_in_query42 = { FOLLOW_expr_in_query42_bits, 1 }; 381/** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_query44 */ 382static ANTLR3_BITWORD FOLLOW_NEWLINE_in_query44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) }; 383static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_query44 = { FOLLOW_NEWLINE_in_query44_bits, 1 }; 384/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_query47 */ 385static ANTLR3_BITWORD FOLLOW_EOF_in_query47_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 386static ANTLR3_BITSET_LIST FOLLOW_EOF_in_query47 = { FOLLOW_EOF_in_query47_bits, 1 }; 387/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr63 */ 388static ANTLR3_BITWORD FOLLOW_aexpr_in_expr63_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) }; 389static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr63 = { FOLLOW_aexpr_in_expr63_bits, 1 }; 390/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expr66 */ 391static ANTLR3_BITWORD FOLLOW_OR_in_expr66_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) }; 392static ANTLR3_BITSET_LIST FOLLOW_OR_in_expr66 = { FOLLOW_OR_in_expr66_bits, 1 }; 393/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr69 */ 394static ANTLR3_BITWORD FOLLOW_aexpr_in_expr69_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) }; 395static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr69 = { FOLLOW_aexpr_in_expr69_bits, 1 }; 396/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr81 */ 397static ANTLR3_BITWORD FOLLOW_crit_in_aexpr81_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) }; 398static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr81 = { FOLLOW_crit_in_aexpr81_bits, 1 }; 399/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_aexpr84 */ 400static ANTLR3_BITWORD FOLLOW_AND_in_aexpr84_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) }; 401static ANTLR3_BITSET_LIST FOLLOW_AND_in_aexpr84 = { FOLLOW_AND_in_aexpr84_bits, 1 }; 402/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr87 */ 403static ANTLR3_BITWORD FOLLOW_crit_in_aexpr87_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) }; 404static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr87 = { FOLLOW_crit_in_aexpr87_bits, 1 }; 405/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit99 */ 406static ANTLR3_BITWORD FOLLOW_LPAR_in_crit99_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) }; 407static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit99 = { FOLLOW_LPAR_in_crit99_bits, 1 }; 408/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_crit101 */ 409static ANTLR3_BITWORD FOLLOW_expr_in_crit101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000100) }; 410static ANTLR3_BITSET_LIST FOLLOW_expr_in_crit101 = { FOLLOW_expr_in_crit101_bits, 1 }; 411/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit103 */ 412static ANTLR3_BITWORD FOLLOW_RPAR_in_crit103_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 413static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit103 = { FOLLOW_RPAR_in_crit103_bits, 1 }; 414/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_crit114 */ 415static ANTLR3_BITWORD FOLLOW_strcrit_in_crit114_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 416static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_crit114 = { FOLLOW_strcrit_in_crit114_bits, 1 }; 417/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_crit119 */ 418static ANTLR3_BITWORD FOLLOW_intcrit_in_crit119_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 419static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_crit119 = { FOLLOW_intcrit_in_crit119_bits, 1 }; 420/** Bitset defining follow set for error recovery in rule state: FOLLOW_datecrit_in_crit124 */ 421static ANTLR3_BITWORD FOLLOW_datecrit_in_crit124_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 422static ANTLR3_BITSET_LIST FOLLOW_datecrit_in_crit124 = { FOLLOW_datecrit_in_crit124_bits, 1 }; 423/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit134 */ 424static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit134_bits[] = { ANTLR3_UINT64_LIT(0x000000000000F000) }; 425static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit134 = { FOLLOW_FIELD_in_strcrit134_bits, 1 }; 426/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit136 */ 427static ANTLR3_BITWORD FOLLOW_strop_in_strcrit136_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) }; 428static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit136 = { FOLLOW_strop_in_strcrit136_bits, 1 }; 429/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit138 */ 430static ANTLR3_BITWORD FOLLOW_STR_in_strcrit138_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 431static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit138 = { FOLLOW_STR_in_strcrit138_bits, 1 }; 432/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit155 */ 433static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit155_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) }; 434static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit155 = { FOLLOW_FIELD_in_strcrit155_bits, 1 }; 435/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_strcrit157 */ 436static ANTLR3_BITWORD FOLLOW_NOT_in_strcrit157_bits[] = { ANTLR3_UINT64_LIT(0x000000000000F000) }; 437static ANTLR3_BITSET_LIST FOLLOW_NOT_in_strcrit157 = { FOLLOW_NOT_in_strcrit157_bits, 1 }; 438/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit159 */ 439static ANTLR3_BITWORD FOLLOW_strop_in_strcrit159_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) }; 440static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit159 = { FOLLOW_strop_in_strcrit159_bits, 1 }; 441/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit161 */ 442static ANTLR3_BITWORD FOLLOW_STR_in_strcrit161_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 443static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit161 = { FOLLOW_STR_in_strcrit161_bits, 1 }; 444/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_strop0 */ 445static ANTLR3_BITWORD FOLLOW_set_in_strop0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 446static ANTLR3_BITSET_LIST FOLLOW_set_in_strop0 = { FOLLOW_set_in_strop0_bits, 1 }; 447/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit211 */ 448static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit211_bits[] = { ANTLR3_UINT64_LIT(0x00000000001E1000) }; 449static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit211 = { FOLLOW_FIELD_in_intcrit211_bits, 1 }; 450/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit213 */ 451static ANTLR3_BITWORD FOLLOW_intop_in_intcrit213_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) }; 452static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit213 = { FOLLOW_intop_in_intcrit213_bits, 1 }; 453/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit215 */ 454static ANTLR3_BITWORD FOLLOW_INT_in_intcrit215_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 455static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit215 = { FOLLOW_INT_in_intcrit215_bits, 1 }; 456/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit232 */ 457static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit232_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) }; 458static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit232 = { FOLLOW_FIELD_in_intcrit232_bits, 1 }; 459/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_intcrit234 */ 460static ANTLR3_BITWORD FOLLOW_NOT_in_intcrit234_bits[] = { ANTLR3_UINT64_LIT(0x00000000001E1000) }; 461static ANTLR3_BITSET_LIST FOLLOW_NOT_in_intcrit234 = { FOLLOW_NOT_in_intcrit234_bits, 1 }; 462/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit236 */ 463static ANTLR3_BITWORD FOLLOW_intop_in_intcrit236_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) }; 464static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit236 = { FOLLOW_intop_in_intcrit236_bits, 1 }; 465/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit238 */ 466static ANTLR3_BITWORD FOLLOW_INT_in_intcrit238_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 467static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit238 = { FOLLOW_INT_in_intcrit238_bits, 1 }; 468/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_intop0 */ 469static ANTLR3_BITWORD FOLLOW_set_in_intop0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 470static ANTLR3_BITSET_LIST FOLLOW_set_in_intop0 = { FOLLOW_set_in_intop0_bits, 1 }; 471/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit292 */ 472static ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit292_bits[] = { ANTLR3_UINT64_LIT(0x0000000000600000) }; 473static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit292 = { FOLLOW_FIELD_in_datecrit292_bits, 1 }; 474/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit294 */ 475static ANTLR3_BITWORD FOLLOW_dateop_in_datecrit294_bits[] = { ANTLR3_UINT64_LIT(0x0000000001810000) }; 476static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit294 = { FOLLOW_dateop_in_datecrit294_bits, 1 }; 477/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit296 */ 478static ANTLR3_BITWORD FOLLOW_datespec_in_datecrit296_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 479static ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit296 = { FOLLOW_datespec_in_datecrit296_bits, 1 }; 480/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateop0 */ 481static ANTLR3_BITWORD FOLLOW_set_in_dateop0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 482static ANTLR3_BITSET_LIST FOLLOW_set_in_dateop0 = { FOLLOW_set_in_dateop0_bits, 1 }; 483/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec331 */ 484static ANTLR3_BITWORD FOLLOW_dateref_in_datespec331_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 485static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec331 = { FOLLOW_dateref_in_datespec331_bits, 1 }; 486/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec336 */ 487static ANTLR3_BITWORD FOLLOW_INT_in_datespec336_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) }; 488static ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec336 = { FOLLOW_INT_in_datespec336_bits, 1 }; 489/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec338 */ 490static ANTLR3_BITWORD FOLLOW_dateintval_in_datespec338_bits[] = { ANTLR3_UINT64_LIT(0x0000000000600000) }; 491static ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec338 = { FOLLOW_dateintval_in_datespec338_bits, 1 }; 492/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec340 */ 493static ANTLR3_BITWORD FOLLOW_dateop_in_datespec340_bits[] = { ANTLR3_UINT64_LIT(0x0000000001800000) }; 494static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec340 = { FOLLOW_dateop_in_datespec340_bits, 1 }; 495/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec342 */ 496static ANTLR3_BITWORD FOLLOW_dateref_in_datespec342_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 497static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec342 = { FOLLOW_dateref_in_datespec342_bits, 1 }; 498/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateref0 */ 499static ANTLR3_BITWORD FOLLOW_set_in_dateref0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 500static ANTLR3_BITSET_LIST FOLLOW_set_in_dateref0 = { FOLLOW_set_in_dateref0_bits, 1 }; 501/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateintval0 */ 502static ANTLR3_BITWORD FOLLOW_set_in_dateintval0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; 503static ANTLR3_BITSET_LIST FOLLOW_set_in_dateintval0 = { FOLLOW_set_in_dateintval0_bits, 1 }; 504 505 506 507 508/* ============================================== 509 * Parsing rules 510 */ 511/** 512 * $ANTLR start query 513 * RSP.g:27:1: query : expr ( NEWLINE )? EOF -> expr ; 514 */ 515static RSPParser_query_return 516query(pRSPParser ctx) 517{ 518 RSPParser_query_return retval; 519 520 pANTLR3_BASE_TREE root_0; 521 522 pANTLR3_COMMON_TOKEN NEWLINE2; 523 pANTLR3_COMMON_TOKEN EOF3; 524 RSPParser_expr_return expr1; 525 #undef RETURN_TYPE_expr1 526 #define RETURN_TYPE_expr1 RSPParser_expr_return 527 528 pANTLR3_BASE_TREE NEWLINE2_tree; 529 pANTLR3_BASE_TREE EOF3_tree; 530 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NEWLINE; 531 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_EOF; 532 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr; 533 /* Initialize rule variables 534 */ 535 536 537 root_0 = NULL; 538 539 NEWLINE2 = NULL; 540 EOF3 = NULL; 541 expr1.tree = NULL; 542 543 retval.start = LT(1); retval.stop = retval.start; 544 545 NEWLINE2_tree = NULL; 546 EOF3_tree = NULL; 547 548 stream_NEWLINE = NULL; 549 #define CREATE_stream_NEWLINE if (stream_NEWLINE == NULL) {stream_NEWLINE = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NEWLINE"); } 550 stream_EOF = NULL; 551 #define CREATE_stream_EOF if (stream_EOF == NULL) {stream_EOF = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token EOF"); } 552 stream_expr = NULL; 553 #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); } 554 555 retval.tree = NULL; 556 { 557 // RSP.g:27:7: ( expr ( NEWLINE )? EOF -> expr ) 558 // RSP.g:27:9: expr ( NEWLINE )? EOF 559 { 560 FOLLOWPUSH(FOLLOW_expr_in_query42); 561 expr1=expr(ctx); 562 563 FOLLOWPOP(); 564 if (HASEXCEPTION()) 565 { 566 goto rulequeryEx; 567 } 568 569 CREATE_stream_expr; stream_expr->add(stream_expr, expr1.tree, NULL); 570 571 // RSP.g:27:14: ( NEWLINE )? 572 { 573 int alt1=2; 574 switch ( LA(1) ) 575 { 576 case NEWLINE: 577 { 578 alt1=1; 579 } 580 break; 581 } 582 583 switch (alt1) 584 { 585 case 1: 586 // RSP.g:27:14: NEWLINE 587 { 588 NEWLINE2 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_query44); 589 if (HASEXCEPTION()) 590 { 591 goto rulequeryEx; 592 } 593 594 CREATE_stream_NEWLINE; stream_NEWLINE->add(stream_NEWLINE, NEWLINE2, NULL); 595 596 597 } 598 break; 599 600 } 601 } 602 EOF3 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_query47); 603 if (HASEXCEPTION()) 604 { 605 goto rulequeryEx; 606 } 607 608 CREATE_stream_EOF; stream_EOF->add(stream_EOF, EOF3, NULL); 609 610 611 612 /* AST REWRITE 613 * elements : expr 614 * token labels : 615 * rule labels : retval 616 * token list labels : 617 * rule list labels : 618 */ 619 { 620 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 621 622 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 623 624 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 625 retval.tree = root_0; 626 // 27:28: -> expr 627 { 628 ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr)); 629 630 } 631 632 retval.tree = root_0; // set result root 633 if (stream_retval != NULL) stream_retval->free(stream_retval); 634 635 636 } 637 } 638 639 } 640 641 642 // This is where rules clean up and exit 643 // 644 goto rulequeryEx; /* Prevent compiler warnings */ 645 rulequeryEx: ; 646 retval.stop = LT(-1); 647 648 retval.stop = LT(-1); 649 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 650 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 651 if (stream_NEWLINE != NULL) stream_NEWLINE->free(stream_NEWLINE); 652 if (stream_EOF != NULL) stream_EOF->free(stream_EOF); 653 if (stream_expr != NULL) stream_expr->free(stream_expr); 654 655 if (HASEXCEPTION()) 656 { 657 PREPORTERROR(); 658 PRECOVER(); 659 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 660 } 661 662 663 return retval; 664} 665/* $ANTLR end query */ 666 667/** 668 * $ANTLR start expr 669 * RSP.g:30:1: expr : aexpr ( OR aexpr )* ; 670 */ 671static RSPParser_expr_return 672expr(pRSPParser ctx) 673{ 674 RSPParser_expr_return retval; 675 676 pANTLR3_BASE_TREE root_0; 677 678 pANTLR3_COMMON_TOKEN OR5; 679 RSPParser_aexpr_return aexpr4; 680 #undef RETURN_TYPE_aexpr4 681 #define RETURN_TYPE_aexpr4 RSPParser_aexpr_return 682 683 RSPParser_aexpr_return aexpr6; 684 #undef RETURN_TYPE_aexpr6 685 #define RETURN_TYPE_aexpr6 RSPParser_aexpr_return 686 687 pANTLR3_BASE_TREE OR5_tree; 688 689 /* Initialize rule variables 690 */ 691 692 693 root_0 = NULL; 694 695 OR5 = NULL; 696 aexpr4.tree = NULL; 697 698 aexpr6.tree = NULL; 699 700 retval.start = LT(1); retval.stop = retval.start; 701 702 OR5_tree = NULL; 703 704 705 retval.tree = NULL; 706 { 707 // RSP.g:30:6: ( aexpr ( OR aexpr )* ) 708 // RSP.g:30:8: aexpr ( OR aexpr )* 709 { 710 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 711 712 FOLLOWPUSH(FOLLOW_aexpr_in_expr63); 713 aexpr4=aexpr(ctx); 714 715 FOLLOWPOP(); 716 if (HASEXCEPTION()) 717 { 718 goto ruleexprEx; 719 } 720 721 ADAPTOR->addChild(ADAPTOR, root_0, aexpr4.tree); 722 723 // RSP.g:30:14: ( OR aexpr )* 724 725 for (;;) 726 { 727 int alt2=2; 728 switch ( LA(1) ) 729 { 730 case OR: 731 { 732 alt2=1; 733 } 734 break; 735 736 } 737 738 switch (alt2) 739 { 740 case 1: 741 // RSP.g:30:15: OR aexpr 742 { 743 OR5 = (pANTLR3_COMMON_TOKEN) MATCHT(OR, &FOLLOW_OR_in_expr66); 744 if (HASEXCEPTION()) 745 { 746 goto ruleexprEx; 747 } 748 749 OR5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OR5)); 750 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OR5_tree, root_0)); 751 752 FOLLOWPUSH(FOLLOW_aexpr_in_expr69); 753 aexpr6=aexpr(ctx); 754 755 FOLLOWPOP(); 756 if (HASEXCEPTION()) 757 { 758 goto ruleexprEx; 759 } 760 761 ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree); 762 763 } 764 break; 765 766 default: 767 goto loop2; /* break out of the loop */ 768 break; 769 } 770 } 771 loop2: ; /* Jump out to here if this rule does not match */ 772 773 774 } 775 776 } 777 778 779 // This is where rules clean up and exit 780 // 781 goto ruleexprEx; /* Prevent compiler warnings */ 782 ruleexprEx: ; 783 retval.stop = LT(-1); 784 785 retval.stop = LT(-1); 786 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 787 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 788 789 if (HASEXCEPTION()) 790 { 791 PREPORTERROR(); 792 PRECOVER(); 793 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 794 } 795 796 797 return retval; 798} 799/* $ANTLR end expr */ 800 801/** 802 * $ANTLR start aexpr 803 * RSP.g:33:1: aexpr : crit ( AND crit )* ; 804 */ 805static RSPParser_aexpr_return 806aexpr(pRSPParser ctx) 807{ 808 RSPParser_aexpr_return retval; 809 810 pANTLR3_BASE_TREE root_0; 811 812 pANTLR3_COMMON_TOKEN AND8; 813 RSPParser_crit_return crit7; 814 #undef RETURN_TYPE_crit7 815 #define RETURN_TYPE_crit7 RSPParser_crit_return 816 817 RSPParser_crit_return crit9; 818 #undef RETURN_TYPE_crit9 819 #define RETURN_TYPE_crit9 RSPParser_crit_return 820 821 pANTLR3_BASE_TREE AND8_tree; 822 823 /* Initialize rule variables 824 */ 825 826 827 root_0 = NULL; 828 829 AND8 = NULL; 830 crit7.tree = NULL; 831 832 crit9.tree = NULL; 833 834 retval.start = LT(1); retval.stop = retval.start; 835 836 AND8_tree = NULL; 837 838 839 retval.tree = NULL; 840 { 841 // RSP.g:33:7: ( crit ( AND crit )* ) 842 // RSP.g:33:9: crit ( AND crit )* 843 { 844 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 845 846 FOLLOWPUSH(FOLLOW_crit_in_aexpr81); 847 crit7=crit(ctx); 848 849 FOLLOWPOP(); 850 if (HASEXCEPTION()) 851 { 852 goto ruleaexprEx; 853 } 854 855 ADAPTOR->addChild(ADAPTOR, root_0, crit7.tree); 856 857 // RSP.g:33:14: ( AND crit )* 858 859 for (;;) 860 { 861 int alt3=2; 862 switch ( LA(1) ) 863 { 864 case AND: 865 { 866 alt3=1; 867 } 868 break; 869 870 } 871 872 switch (alt3) 873 { 874 case 1: 875 // RSP.g:33:15: AND crit 876 { 877 AND8 = (pANTLR3_COMMON_TOKEN) MATCHT(AND, &FOLLOW_AND_in_aexpr84); 878 if (HASEXCEPTION()) 879 { 880 goto ruleaexprEx; 881 } 882 883 AND8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AND8)); 884 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, AND8_tree, root_0)); 885 886 FOLLOWPUSH(FOLLOW_crit_in_aexpr87); 887 crit9=crit(ctx); 888 889 FOLLOWPOP(); 890 if (HASEXCEPTION()) 891 { 892 goto ruleaexprEx; 893 } 894 895 ADAPTOR->addChild(ADAPTOR, root_0, crit9.tree); 896 897 } 898 break; 899 900 default: 901 goto loop3; /* break out of the loop */ 902 break; 903 } 904 } 905 loop3: ; /* Jump out to here if this rule does not match */ 906 907 908 } 909 910 } 911 912 913 // This is where rules clean up and exit 914 // 915 goto ruleaexprEx; /* Prevent compiler warnings */ 916 ruleaexprEx: ; 917 retval.stop = LT(-1); 918 919 retval.stop = LT(-1); 920 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 921 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 922 923 if (HASEXCEPTION()) 924 { 925 PREPORTERROR(); 926 PRECOVER(); 927 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 928 } 929 930 931 return retval; 932} 933/* $ANTLR end aexpr */ 934 935/** 936 * $ANTLR start crit 937 * RSP.g:36:1: crit : ( LPAR expr RPAR -> expr | strcrit | intcrit | datecrit ); 938 */ 939static RSPParser_crit_return 940crit(pRSPParser ctx) 941{ 942 RSPParser_crit_return retval; 943 944 pANTLR3_BASE_TREE root_0; 945 946 pANTLR3_COMMON_TOKEN LPAR10; 947 pANTLR3_COMMON_TOKEN RPAR12; 948 RSPParser_expr_return expr11; 949 #undef RETURN_TYPE_expr11 950 #define RETURN_TYPE_expr11 RSPParser_expr_return 951 952 RSPParser_strcrit_return strcrit13; 953 #undef RETURN_TYPE_strcrit13 954 #define RETURN_TYPE_strcrit13 RSPParser_strcrit_return 955 956 RSPParser_intcrit_return intcrit14; 957 #undef RETURN_TYPE_intcrit14 958 #define RETURN_TYPE_intcrit14 RSPParser_intcrit_return 959 960 RSPParser_datecrit_return datecrit15; 961 #undef RETURN_TYPE_datecrit15 962 #define RETURN_TYPE_datecrit15 RSPParser_datecrit_return 963 964 pANTLR3_BASE_TREE LPAR10_tree; 965 pANTLR3_BASE_TREE RPAR12_tree; 966 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR; 967 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR; 968 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr; 969 /* Initialize rule variables 970 */ 971 972 973 root_0 = NULL; 974 975 LPAR10 = NULL; 976 RPAR12 = NULL; 977 expr11.tree = NULL; 978 979 strcrit13.tree = NULL; 980 981 intcrit14.tree = NULL; 982 983 datecrit15.tree = NULL; 984 985 retval.start = LT(1); retval.stop = retval.start; 986 987 LPAR10_tree = NULL; 988 RPAR12_tree = NULL; 989 990 stream_RPAR = NULL; 991 #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); } 992 stream_LPAR = NULL; 993 #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); } 994 stream_expr = NULL; 995 #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); } 996 997 retval.tree = NULL; 998 { 999 { 1000 // RSP.g:36:6: ( LPAR expr RPAR -> expr | strcrit | intcrit | datecrit ) 1001 1002 ANTLR3_UINT32 alt4; 1003 1004 alt4=4; 1005 1006 switch ( LA(1) ) 1007 { 1008 case LPAR: 1009 { 1010 alt4=1; 1011 } 1012 break; 1013 case FIELD: 1014 { 1015 switch ( LA(2) ) 1016 { 1017 case NOT: 1018 { 1019 switch ( LA(3) ) 1020 { 1021 case EQUAL: 1022 { 1023 switch ( LA(4) ) 1024 { 1025 case STR: 1026 { 1027 alt4=2; 1028 } 1029 break; 1030 case INT: 1031 { 1032 alt4=3; 1033 } 1034 break; 1035 1036 default: 1037 CONSTRUCTEX(); 1038 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1039 EXCEPTION->message = (void *)""; 1040 EXCEPTION->decisionNum = 4; 1041 EXCEPTION->state = 8; 1042 1043 1044 goto rulecritEx; 1045 } 1046 1047 } 1048 break; 1049 case INCLUDES: 1050 case STARTSW: 1051 case ENDSW: 1052 { 1053 alt4=2; 1054 } 1055 break; 1056 case LESS: 1057 case GREATER: 1058 case LTE: 1059 case GTE: 1060 { 1061 alt4=3; 1062 } 1063 break; 1064 1065 default: 1066 CONSTRUCTEX(); 1067 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1068 EXCEPTION->message = (void *)""; 1069 EXCEPTION->decisionNum = 4; 1070 EXCEPTION->state = 3; 1071 1072 1073 goto rulecritEx; 1074 } 1075 1076 } 1077 break; 1078 case EQUAL: 1079 { 1080 switch ( LA(3) ) 1081 { 1082 case INT: 1083 { 1084 alt4=3; 1085 } 1086 break; 1087 case STR: 1088 { 1089 alt4=2; 1090 } 1091 break; 1092 1093 default: 1094 CONSTRUCTEX(); 1095 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1096 EXCEPTION->message = (void *)""; 1097 EXCEPTION->decisionNum = 4; 1098 EXCEPTION->state = 4; 1099 1100 1101 goto rulecritEx; 1102 } 1103 1104 } 1105 break; 1106 case BEFORE: 1107 case AFTER: 1108 { 1109 alt4=4; 1110 } 1111 break; 1112 case LESS: 1113 case GREATER: 1114 case LTE: 1115 case GTE: 1116 { 1117 alt4=3; 1118 } 1119 break; 1120 case INCLUDES: 1121 case STARTSW: 1122 case ENDSW: 1123 { 1124 alt4=2; 1125 } 1126 break; 1127 1128 default: 1129 CONSTRUCTEX(); 1130 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1131 EXCEPTION->message = (void *)""; 1132 EXCEPTION->decisionNum = 4; 1133 EXCEPTION->state = 2; 1134 1135 1136 goto rulecritEx; 1137 } 1138 1139 } 1140 break; 1141 1142 default: 1143 CONSTRUCTEX(); 1144 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1145 EXCEPTION->message = (void *)""; 1146 EXCEPTION->decisionNum = 4; 1147 EXCEPTION->state = 0; 1148 1149 1150 goto rulecritEx; 1151 } 1152 1153 switch (alt4) 1154 { 1155 case 1: 1156 // RSP.g:36:8: LPAR expr RPAR 1157 { 1158 LPAR10 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit99); 1159 if (HASEXCEPTION()) 1160 { 1161 goto rulecritEx; 1162 } 1163 1164 CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR10, NULL); 1165 1166 FOLLOWPUSH(FOLLOW_expr_in_crit101); 1167 expr11=expr(ctx); 1168 1169 FOLLOWPOP(); 1170 if (HASEXCEPTION()) 1171 { 1172 goto rulecritEx; 1173 } 1174 1175 CREATE_stream_expr; stream_expr->add(stream_expr, expr11.tree, NULL); 1176 RPAR12 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit103); 1177 if (HASEXCEPTION()) 1178 { 1179 goto rulecritEx; 1180 } 1181 1182 CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR12, NULL); 1183 1184 1185 1186 /* AST REWRITE 1187 * elements : expr 1188 * token labels : 1189 * rule labels : retval 1190 * token list labels : 1191 * rule list labels : 1192 */ 1193 { 1194 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 1195 1196 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 1197 1198 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1199 retval.tree = root_0; 1200 // 36:25: -> expr 1201 { 1202 ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr)); 1203 1204 } 1205 1206 retval.tree = root_0; // set result root 1207 if (stream_retval != NULL) stream_retval->free(stream_retval); 1208 1209 1210 } 1211 } 1212 break; 1213 case 2: 1214 // RSP.g:37:4: strcrit 1215 { 1216 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1217 1218 FOLLOWPUSH(FOLLOW_strcrit_in_crit114); 1219 strcrit13=strcrit(ctx); 1220 1221 FOLLOWPOP(); 1222 if (HASEXCEPTION()) 1223 { 1224 goto rulecritEx; 1225 } 1226 1227 ADAPTOR->addChild(ADAPTOR, root_0, strcrit13.tree); 1228 1229 } 1230 break; 1231 case 3: 1232 // RSP.g:38:4: intcrit 1233 { 1234 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1235 1236 FOLLOWPUSH(FOLLOW_intcrit_in_crit119); 1237 intcrit14=intcrit(ctx); 1238 1239 FOLLOWPOP(); 1240 if (HASEXCEPTION()) 1241 { 1242 goto rulecritEx; 1243 } 1244 1245 ADAPTOR->addChild(ADAPTOR, root_0, intcrit14.tree); 1246 1247 } 1248 break; 1249 case 4: 1250 // RSP.g:39:4: datecrit 1251 { 1252 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1253 1254 FOLLOWPUSH(FOLLOW_datecrit_in_crit124); 1255 datecrit15=datecrit(ctx); 1256 1257 FOLLOWPOP(); 1258 if (HASEXCEPTION()) 1259 { 1260 goto rulecritEx; 1261 } 1262 1263 ADAPTOR->addChild(ADAPTOR, root_0, datecrit15.tree); 1264 1265 } 1266 break; 1267 1268 } 1269 } 1270 } 1271 1272 1273 // This is where rules clean up and exit 1274 // 1275 goto rulecritEx; /* Prevent compiler warnings */ 1276 rulecritEx: ; 1277 retval.stop = LT(-1); 1278 1279 retval.stop = LT(-1); 1280 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 1281 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 1282 if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR); 1283 if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR); 1284 if (stream_expr != NULL) stream_expr->free(stream_expr); 1285 1286 if (HASEXCEPTION()) 1287 { 1288 PREPORTERROR(); 1289 PRECOVER(); 1290 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 1291 } 1292 1293 1294 return retval; 1295} 1296/* $ANTLR end crit */ 1297 1298/** 1299 * $ANTLR start strcrit 1300 * RSP.g:42:1: strcrit : ( FIELD strop STR -> ^( strop FIELD STR ) | FIELD NOT strop STR -> ^( NOT ^( strop FIELD STR ) ) ); 1301 */ 1302static RSPParser_strcrit_return 1303strcrit(pRSPParser ctx) 1304{ 1305 RSPParser_strcrit_return retval; 1306 1307 pANTLR3_BASE_TREE root_0; 1308 1309 pANTLR3_COMMON_TOKEN FIELD16; 1310 pANTLR3_COMMON_TOKEN STR18; 1311 pANTLR3_COMMON_TOKEN FIELD19; 1312 pANTLR3_COMMON_TOKEN NOT20; 1313 pANTLR3_COMMON_TOKEN STR22; 1314 RSPParser_strop_return strop17; 1315 #undef RETURN_TYPE_strop17 1316 #define RETURN_TYPE_strop17 RSPParser_strop_return 1317 1318 RSPParser_strop_return strop21; 1319 #undef RETURN_TYPE_strop21 1320 #define RETURN_TYPE_strop21 RSPParser_strop_return 1321 1322 pANTLR3_BASE_TREE FIELD16_tree; 1323 pANTLR3_BASE_TREE STR18_tree; 1324 pANTLR3_BASE_TREE FIELD19_tree; 1325 pANTLR3_BASE_TREE NOT20_tree; 1326 pANTLR3_BASE_TREE STR22_tree; 1327 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_STR; 1328 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD; 1329 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT; 1330 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_strop; 1331 /* Initialize rule variables 1332 */ 1333 1334 1335 root_0 = NULL; 1336 1337 FIELD16 = NULL; 1338 STR18 = NULL; 1339 FIELD19 = NULL; 1340 NOT20 = NULL; 1341 STR22 = NULL; 1342 strop17.tree = NULL; 1343 1344 strop21.tree = NULL; 1345 1346 retval.start = LT(1); retval.stop = retval.start; 1347 1348 FIELD16_tree = NULL; 1349 STR18_tree = NULL; 1350 FIELD19_tree = NULL; 1351 NOT20_tree = NULL; 1352 STR22_tree = NULL; 1353 1354 stream_STR = NULL; 1355 #define CREATE_stream_STR if (stream_STR == NULL) {stream_STR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token STR"); } 1356 stream_FIELD = NULL; 1357 #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); } 1358 stream_NOT = NULL; 1359 #define CREATE_stream_NOT if (stream_NOT == NULL) {stream_NOT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NOT"); } 1360 stream_strop = NULL; 1361 #define CREATE_stream_strop if (stream_strop == NULL) {stream_strop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule strop"); } 1362 1363 retval.tree = NULL; 1364 { 1365 { 1366 // RSP.g:42:9: ( FIELD strop STR -> ^( strop FIELD STR ) | FIELD NOT strop STR -> ^( NOT ^( strop FIELD STR ) ) ) 1367 1368 ANTLR3_UINT32 alt5; 1369 1370 alt5=2; 1371 1372 switch ( LA(1) ) 1373 { 1374 case FIELD: 1375 { 1376 switch ( LA(2) ) 1377 { 1378 case NOT: 1379 { 1380 alt5=2; 1381 } 1382 break; 1383 case EQUAL: 1384 case INCLUDES: 1385 case STARTSW: 1386 case ENDSW: 1387 { 1388 alt5=1; 1389 } 1390 break; 1391 1392 default: 1393 CONSTRUCTEX(); 1394 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1395 EXCEPTION->message = (void *)""; 1396 EXCEPTION->decisionNum = 5; 1397 EXCEPTION->state = 1; 1398 1399 1400 goto rulestrcritEx; 1401 } 1402 1403 } 1404 break; 1405 1406 default: 1407 CONSTRUCTEX(); 1408 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1409 EXCEPTION->message = (void *)""; 1410 EXCEPTION->decisionNum = 5; 1411 EXCEPTION->state = 0; 1412 1413 1414 goto rulestrcritEx; 1415 } 1416 1417 switch (alt5) 1418 { 1419 case 1: 1420 // RSP.g:42:11: FIELD strop STR 1421 { 1422 FIELD16 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit134); 1423 if (HASEXCEPTION()) 1424 { 1425 goto rulestrcritEx; 1426 } 1427 1428 CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD16, NULL); 1429 1430 FOLLOWPUSH(FOLLOW_strop_in_strcrit136); 1431 strop17=strop(ctx); 1432 1433 FOLLOWPOP(); 1434 if (HASEXCEPTION()) 1435 { 1436 goto rulestrcritEx; 1437 } 1438 1439 CREATE_stream_strop; stream_strop->add(stream_strop, strop17.tree, NULL); 1440 STR18 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_strcrit138); 1441 if (HASEXCEPTION()) 1442 { 1443 goto rulestrcritEx; 1444 } 1445 1446 CREATE_stream_STR; stream_STR->add(stream_STR, STR18, NULL); 1447 1448 1449 1450 /* AST REWRITE 1451 * elements : strop, FIELD, STR 1452 * token labels : 1453 * rule labels : retval 1454 * token list labels : 1455 * rule list labels : 1456 */ 1457 { 1458 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 1459 1460 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 1461 1462 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1463 retval.tree = root_0; 1464 // 42:29: -> ^( strop FIELD STR ) 1465 { 1466 // RSP.g:42:32: ^( strop FIELD STR ) 1467 { 1468 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1469 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_strop == NULL ? NULL : stream_strop->nextNode(stream_strop), root_1)); 1470 1471 ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD)); 1472 ADAPTOR->addChild(ADAPTOR, root_1, stream_STR == NULL ? NULL : stream_STR->nextNode(stream_STR)); 1473 1474 ADAPTOR->addChild(ADAPTOR, root_0, root_1); 1475 } 1476 1477 } 1478 1479 retval.tree = root_0; // set result root 1480 if (stream_retval != NULL) stream_retval->free(stream_retval); 1481 1482 1483 } 1484 } 1485 break; 1486 case 2: 1487 // RSP.g:43:4: FIELD NOT strop STR 1488 { 1489 FIELD19 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit155); 1490 if (HASEXCEPTION()) 1491 { 1492 goto rulestrcritEx; 1493 } 1494 1495 CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD19, NULL); 1496 1497 NOT20 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_strcrit157); 1498 if (HASEXCEPTION()) 1499 { 1500 goto rulestrcritEx; 1501 } 1502 1503 CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT20, NULL); 1504 1505 FOLLOWPUSH(FOLLOW_strop_in_strcrit159); 1506 strop21=strop(ctx); 1507 1508 FOLLOWPOP(); 1509 if (HASEXCEPTION()) 1510 { 1511 goto rulestrcritEx; 1512 } 1513 1514 CREATE_stream_strop; stream_strop->add(stream_strop, strop21.tree, NULL); 1515 STR22 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_strcrit161); 1516 if (HASEXCEPTION()) 1517 { 1518 goto rulestrcritEx; 1519 } 1520 1521 CREATE_stream_STR; stream_STR->add(stream_STR, STR22, NULL); 1522 1523 1524 1525 /* AST REWRITE 1526 * elements : STR, strop, NOT, FIELD 1527 * token labels : 1528 * rule labels : retval 1529 * token list labels : 1530 * rule list labels : 1531 */ 1532 { 1533 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 1534 1535 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 1536 1537 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1538 retval.tree = root_0; 1539 // 43:25: -> ^( NOT ^( strop FIELD STR ) ) 1540 { 1541 // RSP.g:43:28: ^( NOT ^( strop FIELD STR ) ) 1542 { 1543 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1544 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_NOT == NULL ? NULL : stream_NOT->nextNode(stream_NOT), root_1)); 1545 1546 // RSP.g:43:34: ^( strop FIELD STR ) 1547 { 1548 pANTLR3_BASE_TREE root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1549 root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_strop == NULL ? NULL : stream_strop->nextNode(stream_strop), root_2)); 1550 1551 ADAPTOR->addChild(ADAPTOR, root_2, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD)); 1552 ADAPTOR->addChild(ADAPTOR, root_2, stream_STR == NULL ? NULL : stream_STR->nextNode(stream_STR)); 1553 1554 ADAPTOR->addChild(ADAPTOR, root_1, root_2); 1555 } 1556 1557 ADAPTOR->addChild(ADAPTOR, root_0, root_1); 1558 } 1559 1560 } 1561 1562 retval.tree = root_0; // set result root 1563 if (stream_retval != NULL) stream_retval->free(stream_retval); 1564 1565 1566 } 1567 } 1568 break; 1569 1570 } 1571 } 1572 } 1573 1574 1575 // This is where rules clean up and exit 1576 // 1577 goto rulestrcritEx; /* Prevent compiler warnings */ 1578 rulestrcritEx: ; 1579 retval.stop = LT(-1); 1580 1581 retval.stop = LT(-1); 1582 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 1583 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 1584 if (stream_STR != NULL) stream_STR->free(stream_STR); 1585 if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD); 1586 if (stream_NOT != NULL) stream_NOT->free(stream_NOT); 1587 if (stream_strop != NULL) stream_strop->free(stream_strop); 1588 1589 if (HASEXCEPTION()) 1590 { 1591 PREPORTERROR(); 1592 PRECOVER(); 1593 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 1594 } 1595 1596 1597 return retval; 1598} 1599/* $ANTLR end strcrit */ 1600 1601/** 1602 * $ANTLR start strop 1603 * RSP.g:46:1: strop : ( EQUAL | INCLUDES | STARTSW | ENDSW ); 1604 */ 1605static RSPParser_strop_return 1606strop(pRSPParser ctx) 1607{ 1608 RSPParser_strop_return retval; 1609 1610 pANTLR3_BASE_TREE root_0; 1611 1612 pANTLR3_COMMON_TOKEN set23; 1613 1614 pANTLR3_BASE_TREE set23_tree; 1615 1616 /* Initialize rule variables 1617 */ 1618 1619 1620 root_0 = NULL; 1621 1622 set23 = NULL; 1623 retval.start = LT(1); retval.stop = retval.start; 1624 1625 set23_tree = NULL; 1626 1627 1628 retval.tree = NULL; 1629 { 1630 // RSP.g:46:7: ( EQUAL | INCLUDES | STARTSW | ENDSW ) 1631 // RSP.g: 1632 { 1633 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1634 1635 set23=(pANTLR3_COMMON_TOKEN)LT(1); 1636 if ( ((LA(1) >= EQUAL) && (LA(1) <= ENDSW)) ) 1637 { 1638 CONSUME(); 1639 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set23))); 1640 PERRORRECOVERY=ANTLR3_FALSE; 1641 } 1642 else 1643 { 1644 CONSTRUCTEX(); 1645 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 1646 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 1647 EXCEPTION->expectingSet = &FOLLOW_set_in_strop0; 1648 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_strop0); goto rulestropEx; 1649 } 1650 1651 1652 } 1653 1654 } 1655 1656 1657 // This is where rules clean up and exit 1658 // 1659 goto rulestropEx; /* Prevent compiler warnings */ 1660 rulestropEx: ; 1661 retval.stop = LT(-1); 1662 1663 retval.stop = LT(-1); 1664 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 1665 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 1666 1667 if (HASEXCEPTION()) 1668 { 1669 PREPORTERROR(); 1670 PRECOVER(); 1671 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 1672 } 1673 1674 1675 return retval; 1676} 1677/* $ANTLR end strop */ 1678 1679/** 1680 * $ANTLR start intcrit 1681 * RSP.g:52:1: intcrit : ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) ); 1682 */ 1683static RSPParser_intcrit_return 1684intcrit(pRSPParser ctx) 1685{ 1686 RSPParser_intcrit_return retval; 1687 1688 pANTLR3_BASE_TREE root_0; 1689 1690 pANTLR3_COMMON_TOKEN FIELD24; 1691 pANTLR3_COMMON_TOKEN INT26; 1692 pANTLR3_COMMON_TOKEN FIELD27; 1693 pANTLR3_COMMON_TOKEN NOT28; 1694 pANTLR3_COMMON_TOKEN INT30; 1695 RSPParser_intop_return intop25; 1696 #undef RETURN_TYPE_intop25 1697 #define RETURN_TYPE_intop25 RSPParser_intop_return 1698 1699 RSPParser_intop_return intop29; 1700 #undef RETURN_TYPE_intop29 1701 #define RETURN_TYPE_intop29 RSPParser_intop_return 1702 1703 pANTLR3_BASE_TREE FIELD24_tree; 1704 pANTLR3_BASE_TREE INT26_tree; 1705 pANTLR3_BASE_TREE FIELD27_tree; 1706 pANTLR3_BASE_TREE NOT28_tree; 1707 pANTLR3_BASE_TREE INT30_tree; 1708 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD; 1709 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT; 1710 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT; 1711 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_intop; 1712 /* Initialize rule variables 1713 */ 1714 1715 1716 root_0 = NULL; 1717 1718 FIELD24 = NULL; 1719 INT26 = NULL; 1720 FIELD27 = NULL; 1721 NOT28 = NULL; 1722 INT30 = NULL; 1723 intop25.tree = NULL; 1724 1725 intop29.tree = NULL; 1726 1727 retval.start = LT(1); retval.stop = retval.start; 1728 1729 FIELD24_tree = NULL; 1730 INT26_tree = NULL; 1731 FIELD27_tree = NULL; 1732 NOT28_tree = NULL; 1733 INT30_tree = NULL; 1734 1735 stream_FIELD = NULL; 1736 #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); } 1737 stream_INT = NULL; 1738 #define CREATE_stream_INT if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); } 1739 stream_NOT = NULL; 1740 #define CREATE_stream_NOT if (stream_NOT == NULL) {stream_NOT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NOT"); } 1741 stream_intop = NULL; 1742 #define CREATE_stream_intop if (stream_intop == NULL) {stream_intop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule intop"); } 1743 1744 retval.tree = NULL; 1745 { 1746 { 1747 // RSP.g:52:9: ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) ) 1748 1749 ANTLR3_UINT32 alt6; 1750 1751 alt6=2; 1752 1753 switch ( LA(1) ) 1754 { 1755 case FIELD: 1756 { 1757 switch ( LA(2) ) 1758 { 1759 case NOT: 1760 { 1761 alt6=2; 1762 } 1763 break; 1764 case EQUAL: 1765 case LESS: 1766 case GREATER: 1767 case LTE: 1768 case GTE: 1769 { 1770 alt6=1; 1771 } 1772 break; 1773 1774 default: 1775 CONSTRUCTEX(); 1776 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1777 EXCEPTION->message = (void *)""; 1778 EXCEPTION->decisionNum = 6; 1779 EXCEPTION->state = 1; 1780 1781 1782 goto ruleintcritEx; 1783 } 1784 1785 } 1786 break; 1787 1788 default: 1789 CONSTRUCTEX(); 1790 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 1791 EXCEPTION->message = (void *)""; 1792 EXCEPTION->decisionNum = 6; 1793 EXCEPTION->state = 0; 1794 1795 1796 goto ruleintcritEx; 1797 } 1798 1799 switch (alt6) 1800 { 1801 case 1: 1802 // RSP.g:52:11: FIELD intop INT 1803 { 1804 FIELD24 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit211); 1805 if (HASEXCEPTION()) 1806 { 1807 goto ruleintcritEx; 1808 } 1809 1810 CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD24, NULL); 1811 1812 FOLLOWPUSH(FOLLOW_intop_in_intcrit213); 1813 intop25=intop(ctx); 1814 1815 FOLLOWPOP(); 1816 if (HASEXCEPTION()) 1817 { 1818 goto ruleintcritEx; 1819 } 1820 1821 CREATE_stream_intop; stream_intop->add(stream_intop, intop25.tree, NULL); 1822 INT26 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit215); 1823 if (HASEXCEPTION()) 1824 { 1825 goto ruleintcritEx; 1826 } 1827 1828 CREATE_stream_INT; stream_INT->add(stream_INT, INT26, NULL); 1829 1830 1831 1832 /* AST REWRITE 1833 * elements : FIELD, intop, INT 1834 * token labels : 1835 * rule labels : retval 1836 * token list labels : 1837 * rule list labels : 1838 */ 1839 { 1840 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 1841 1842 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 1843 1844 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1845 retval.tree = root_0; 1846 // 52:29: -> ^( intop FIELD INT ) 1847 { 1848 // RSP.g:52:32: ^( intop FIELD INT ) 1849 { 1850 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1851 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_intop == NULL ? NULL : stream_intop->nextNode(stream_intop), root_1)); 1852 1853 ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD)); 1854 ADAPTOR->addChild(ADAPTOR, root_1, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT)); 1855 1856 ADAPTOR->addChild(ADAPTOR, root_0, root_1); 1857 } 1858 1859 } 1860 1861 retval.tree = root_0; // set result root 1862 if (stream_retval != NULL) stream_retval->free(stream_retval); 1863 1864 1865 } 1866 } 1867 break; 1868 case 2: 1869 // RSP.g:53:4: FIELD NOT intop INT 1870 { 1871 FIELD27 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit232); 1872 if (HASEXCEPTION()) 1873 { 1874 goto ruleintcritEx; 1875 } 1876 1877 CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD27, NULL); 1878 1879 NOT28 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_intcrit234); 1880 if (HASEXCEPTION()) 1881 { 1882 goto ruleintcritEx; 1883 } 1884 1885 CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT28, NULL); 1886 1887 FOLLOWPUSH(FOLLOW_intop_in_intcrit236); 1888 intop29=intop(ctx); 1889 1890 FOLLOWPOP(); 1891 if (HASEXCEPTION()) 1892 { 1893 goto ruleintcritEx; 1894 } 1895 1896 CREATE_stream_intop; stream_intop->add(stream_intop, intop29.tree, NULL); 1897 INT30 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit238); 1898 if (HASEXCEPTION()) 1899 { 1900 goto ruleintcritEx; 1901 } 1902 1903 CREATE_stream_INT; stream_INT->add(stream_INT, INT30, NULL); 1904 1905 1906 1907 /* AST REWRITE 1908 * elements : FIELD, intop, INT, NOT 1909 * token labels : 1910 * rule labels : retval 1911 * token list labels : 1912 * rule list labels : 1913 */ 1914 { 1915 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 1916 1917 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 1918 1919 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1920 retval.tree = root_0; 1921 // 53:25: -> ^( NOT ^( intop FIELD INT ) ) 1922 { 1923 // RSP.g:53:28: ^( NOT ^( intop FIELD INT ) ) 1924 { 1925 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1926 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_NOT == NULL ? NULL : stream_NOT->nextNode(stream_NOT), root_1)); 1927 1928 // RSP.g:53:34: ^( intop FIELD INT ) 1929 { 1930 pANTLR3_BASE_TREE root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 1931 root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_intop == NULL ? NULL : stream_intop->nextNode(stream_intop), root_2)); 1932 1933 ADAPTOR->addChild(ADAPTOR, root_2, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD)); 1934 ADAPTOR->addChild(ADAPTOR, root_2, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT)); 1935 1936 ADAPTOR->addChild(ADAPTOR, root_1, root_2); 1937 } 1938 1939 ADAPTOR->addChild(ADAPTOR, root_0, root_1); 1940 } 1941 1942 } 1943 1944 retval.tree = root_0; // set result root 1945 if (stream_retval != NULL) stream_retval->free(stream_retval); 1946 1947 1948 } 1949 } 1950 break; 1951 1952 } 1953 } 1954 } 1955 1956 1957 // This is where rules clean up and exit 1958 // 1959 goto ruleintcritEx; /* Prevent compiler warnings */ 1960 ruleintcritEx: ; 1961 retval.stop = LT(-1); 1962 1963 retval.stop = LT(-1); 1964 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 1965 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 1966 if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD); 1967 if (stream_INT != NULL) stream_INT->free(stream_INT); 1968 if (stream_NOT != NULL) stream_NOT->free(stream_NOT); 1969 if (stream_intop != NULL) stream_intop->free(stream_intop); 1970 1971 if (HASEXCEPTION()) 1972 { 1973 PREPORTERROR(); 1974 PRECOVER(); 1975 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 1976 } 1977 1978 1979 return retval; 1980} 1981/* $ANTLR end intcrit */ 1982 1983/** 1984 * $ANTLR start intop 1985 * RSP.g:56:1: intop : ( EQUAL | LESS | GREATER | LTE | GTE ); 1986 */ 1987static RSPParser_intop_return 1988intop(pRSPParser ctx) 1989{ 1990 RSPParser_intop_return retval; 1991 1992 pANTLR3_BASE_TREE root_0; 1993 1994 pANTLR3_COMMON_TOKEN set31; 1995 1996 pANTLR3_BASE_TREE set31_tree; 1997 1998 /* Initialize rule variables 1999 */ 2000 2001 2002 root_0 = NULL; 2003 2004 set31 = NULL; 2005 retval.start = LT(1); retval.stop = retval.start; 2006 2007 set31_tree = NULL; 2008 2009 2010 retval.tree = NULL; 2011 { 2012 // RSP.g:56:7: ( EQUAL | LESS | GREATER | LTE | GTE ) 2013 // RSP.g: 2014 { 2015 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2016 2017 set31=(pANTLR3_COMMON_TOKEN)LT(1); 2018 if ( LA(1) == EQUAL || ((LA(1) >= LESS) && (LA(1) <= GTE)) ) 2019 { 2020 CONSUME(); 2021 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set31))); 2022 PERRORRECOVERY=ANTLR3_FALSE; 2023 } 2024 else 2025 { 2026 CONSTRUCTEX(); 2027 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 2028 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 2029 EXCEPTION->expectingSet = &FOLLOW_set_in_intop0; 2030 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_intop0); goto ruleintopEx; 2031 } 2032 2033 2034 } 2035 2036 } 2037 2038 2039 // This is where rules clean up and exit 2040 // 2041 goto ruleintopEx; /* Prevent compiler warnings */ 2042 ruleintopEx: ; 2043 retval.stop = LT(-1); 2044 2045 retval.stop = LT(-1); 2046 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 2047 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 2048 2049 if (HASEXCEPTION()) 2050 { 2051 PREPORTERROR(); 2052 PRECOVER(); 2053 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 2054 } 2055 2056 2057 return retval; 2058} 2059/* $ANTLR end intop */ 2060 2061/** 2062 * $ANTLR start datecrit 2063 * RSP.g:63:1: datecrit : FIELD dateop datespec -> ^( dateop FIELD datespec ) ; 2064 */ 2065static RSPParser_datecrit_return 2066datecrit(pRSPParser ctx) 2067{ 2068 RSPParser_datecrit_return retval; 2069 2070 pANTLR3_BASE_TREE root_0; 2071 2072 pANTLR3_COMMON_TOKEN FIELD32; 2073 RSPParser_dateop_return dateop33; 2074 #undef RETURN_TYPE_dateop33 2075 #define RETURN_TYPE_dateop33 RSPParser_dateop_return 2076 2077 RSPParser_datespec_return datespec34; 2078 #undef RETURN_TYPE_datespec34 2079 #define RETURN_TYPE_datespec34 RSPParser_datespec_return 2080 2081 pANTLR3_BASE_TREE FIELD32_tree; 2082 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD; 2083 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_datespec; 2084 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop; 2085 /* Initialize rule variables 2086 */ 2087 2088 2089 root_0 = NULL; 2090 2091 FIELD32 = NULL; 2092 dateop33.tree = NULL; 2093 2094 datespec34.tree = NULL; 2095 2096 retval.start = LT(1); retval.stop = retval.start; 2097 2098 FIELD32_tree = NULL; 2099 2100 stream_FIELD = NULL; 2101 #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); } 2102 stream_datespec = NULL; 2103 #define CREATE_stream_datespec if (stream_datespec == NULL) {stream_datespec = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule datespec"); } 2104 stream_dateop = NULL; 2105 #define CREATE_stream_dateop if (stream_dateop == NULL) {stream_dateop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateop"); } 2106 2107 retval.tree = NULL; 2108 { 2109 // RSP.g:63:9: ( FIELD dateop datespec -> ^( dateop FIELD datespec ) ) 2110 // RSP.g:63:11: FIELD dateop datespec 2111 { 2112 FIELD32 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit292); 2113 if (HASEXCEPTION()) 2114 { 2115 goto ruledatecritEx; 2116 } 2117 2118 CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD32, NULL); 2119 2120 FOLLOWPUSH(FOLLOW_dateop_in_datecrit294); 2121 dateop33=dateop(ctx); 2122 2123 FOLLOWPOP(); 2124 if (HASEXCEPTION()) 2125 { 2126 goto ruledatecritEx; 2127 } 2128 2129 CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop33.tree, NULL); 2130 FOLLOWPUSH(FOLLOW_datespec_in_datecrit296); 2131 datespec34=datespec(ctx); 2132 2133 FOLLOWPOP(); 2134 if (HASEXCEPTION()) 2135 { 2136 goto ruledatecritEx; 2137 } 2138 2139 CREATE_stream_datespec; stream_datespec->add(stream_datespec, datespec34.tree, NULL); 2140 2141 2142 /* AST REWRITE 2143 * elements : dateop, datespec, FIELD 2144 * token labels : 2145 * rule labels : retval 2146 * token list labels : 2147 * rule list labels : 2148 */ 2149 { 2150 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 2151 2152 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 2153 2154 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2155 retval.tree = root_0; 2156 // 63:34: -> ^( dateop FIELD datespec ) 2157 { 2158 // RSP.g:63:37: ^( dateop FIELD datespec ) 2159 { 2160 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2161 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_dateop == NULL ? NULL : stream_dateop->nextNode(stream_dateop), root_1)); 2162 2163 ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD)); 2164 ADAPTOR->addChild(ADAPTOR, root_1, stream_datespec == NULL ? NULL : stream_datespec->nextTree(stream_datespec)); 2165 2166 ADAPTOR->addChild(ADAPTOR, root_0, root_1); 2167 } 2168 2169 } 2170 2171 retval.tree = root_0; // set result root 2172 if (stream_retval != NULL) stream_retval->free(stream_retval); 2173 2174 2175 } 2176 } 2177 2178 } 2179 2180 2181 // This is where rules clean up and exit 2182 // 2183 goto ruledatecritEx; /* Prevent compiler warnings */ 2184 ruledatecritEx: ; 2185 retval.stop = LT(-1); 2186 2187 retval.stop = LT(-1); 2188 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 2189 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 2190 if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD); 2191 if (stream_datespec != NULL) stream_datespec->free(stream_datespec); 2192 if (stream_dateop != NULL) stream_dateop->free(stream_dateop); 2193 2194 if (HASEXCEPTION()) 2195 { 2196 PREPORTERROR(); 2197 PRECOVER(); 2198 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 2199 } 2200 2201 2202 return retval; 2203} 2204/* $ANTLR end datecrit */ 2205 2206/** 2207 * $ANTLR start dateop 2208 * RSP.g:66:1: dateop : ( BEFORE | AFTER ); 2209 */ 2210static RSPParser_dateop_return 2211dateop(pRSPParser ctx) 2212{ 2213 RSPParser_dateop_return retval; 2214 2215 pANTLR3_BASE_TREE root_0; 2216 2217 pANTLR3_COMMON_TOKEN set35; 2218 2219 pANTLR3_BASE_TREE set35_tree; 2220 2221 /* Initialize rule variables 2222 */ 2223 2224 2225 root_0 = NULL; 2226 2227 set35 = NULL; 2228 retval.start = LT(1); retval.stop = retval.start; 2229 2230 set35_tree = NULL; 2231 2232 2233 retval.tree = NULL; 2234 { 2235 // RSP.g:66:8: ( BEFORE | AFTER ) 2236 // RSP.g: 2237 { 2238 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2239 2240 set35=(pANTLR3_COMMON_TOKEN)LT(1); 2241 if ( ((LA(1) >= BEFORE) && (LA(1) <= AFTER)) ) 2242 { 2243 CONSUME(); 2244 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set35))); 2245 PERRORRECOVERY=ANTLR3_FALSE; 2246 } 2247 else 2248 { 2249 CONSTRUCTEX(); 2250 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 2251 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 2252 EXCEPTION->expectingSet = &FOLLOW_set_in_dateop0; 2253 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateop0); goto ruledateopEx; 2254 } 2255 2256 2257 } 2258 2259 } 2260 2261 2262 // This is where rules clean up and exit 2263 // 2264 goto ruledateopEx; /* Prevent compiler warnings */ 2265 ruledateopEx: ; 2266 retval.stop = LT(-1); 2267 2268 retval.stop = LT(-1); 2269 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 2270 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 2271 2272 if (HASEXCEPTION()) 2273 { 2274 PREPORTERROR(); 2275 PRECOVER(); 2276 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 2277 } 2278 2279 2280 return retval; 2281} 2282/* $ANTLR end dateop */ 2283 2284/** 2285 * $ANTLR start datespec 2286 * RSP.g:70:1: datespec : ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) ); 2287 */ 2288static RSPParser_datespec_return 2289datespec(pRSPParser ctx) 2290{ 2291 RSPParser_datespec_return retval; 2292 2293 pANTLR3_BASE_TREE root_0; 2294 2295 pANTLR3_COMMON_TOKEN INT37; 2296 RSPParser_dateref_return dateref36; 2297 #undef RETURN_TYPE_dateref36 2298 #define RETURN_TYPE_dateref36 RSPParser_dateref_return 2299 2300 RSPParser_dateintval_return dateintval38; 2301 #undef RETURN_TYPE_dateintval38 2302 #define RETURN_TYPE_dateintval38 RSPParser_dateintval_return 2303 2304 RSPParser_dateop_return dateop39; 2305 #undef RETURN_TYPE_dateop39 2306 #define RETURN_TYPE_dateop39 RSPParser_dateop_return 2307 2308 RSPParser_dateref_return dateref40; 2309 #undef RETURN_TYPE_dateref40 2310 #define RETURN_TYPE_dateref40 RSPParser_dateref_return 2311 2312 pANTLR3_BASE_TREE INT37_tree; 2313 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT; 2314 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateintval; 2315 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateref; 2316 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop; 2317 /* Initialize rule variables 2318 */ 2319 2320 2321 root_0 = NULL; 2322 2323 INT37 = NULL; 2324 dateref36.tree = NULL; 2325 2326 dateintval38.tree = NULL; 2327 2328 dateop39.tree = NULL; 2329 2330 dateref40.tree = NULL; 2331 2332 retval.start = LT(1); retval.stop = retval.start; 2333 2334 INT37_tree = NULL; 2335 2336 stream_INT = NULL; 2337 #define CREATE_stream_INT if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); } 2338 stream_dateintval = NULL; 2339 #define CREATE_stream_dateintval if (stream_dateintval == NULL) {stream_dateintval = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateintval"); } 2340 stream_dateref = NULL; 2341 #define CREATE_stream_dateref if (stream_dateref == NULL) {stream_dateref = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateref"); } 2342 stream_dateop = NULL; 2343 #define CREATE_stream_dateop if (stream_dateop == NULL) {stream_dateop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateop"); } 2344 2345 retval.tree = NULL; 2346 { 2347 { 2348 // RSP.g:70:9: ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) ) 2349 2350 ANTLR3_UINT32 alt7; 2351 2352 alt7=2; 2353 2354 switch ( LA(1) ) 2355 { 2356 case DATE: 2357 case TODAY: 2358 { 2359 alt7=1; 2360 } 2361 break; 2362 case INT: 2363 { 2364 alt7=2; 2365 } 2366 break; 2367 2368 default: 2369 CONSTRUCTEX(); 2370 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; 2371 EXCEPTION->message = (void *)""; 2372 EXCEPTION->decisionNum = 7; 2373 EXCEPTION->state = 0; 2374 2375 2376 goto ruledatespecEx; 2377 } 2378 2379 switch (alt7) 2380 { 2381 case 1: 2382 // RSP.g:70:11: dateref 2383 { 2384 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2385 2386 FOLLOWPUSH(FOLLOW_dateref_in_datespec331); 2387 dateref36=dateref(ctx); 2388 2389 FOLLOWPOP(); 2390 if (HASEXCEPTION()) 2391 { 2392 goto ruledatespecEx; 2393 } 2394 2395 ADAPTOR->addChild(ADAPTOR, root_0, dateref36.tree); 2396 2397 } 2398 break; 2399 case 2: 2400 // RSP.g:71:4: INT dateintval dateop dateref 2401 { 2402 INT37 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_datespec336); 2403 if (HASEXCEPTION()) 2404 { 2405 goto ruledatespecEx; 2406 } 2407 2408 CREATE_stream_INT; stream_INT->add(stream_INT, INT37, NULL); 2409 2410 FOLLOWPUSH(FOLLOW_dateintval_in_datespec338); 2411 dateintval38=dateintval(ctx); 2412 2413 FOLLOWPOP(); 2414 if (HASEXCEPTION()) 2415 { 2416 goto ruledatespecEx; 2417 } 2418 2419 CREATE_stream_dateintval; stream_dateintval->add(stream_dateintval, dateintval38.tree, NULL); 2420 FOLLOWPUSH(FOLLOW_dateop_in_datespec340); 2421 dateop39=dateop(ctx); 2422 2423 FOLLOWPOP(); 2424 if (HASEXCEPTION()) 2425 { 2426 goto ruledatespecEx; 2427 } 2428 2429 CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop39.tree, NULL); 2430 FOLLOWPUSH(FOLLOW_dateref_in_datespec342); 2431 dateref40=dateref(ctx); 2432 2433 FOLLOWPOP(); 2434 if (HASEXCEPTION()) 2435 { 2436 goto ruledatespecEx; 2437 } 2438 2439 CREATE_stream_dateref; stream_dateref->add(stream_dateref, dateref40.tree, NULL); 2440 2441 2442 /* AST REWRITE 2443 * elements : INT, dateref, dateintval, dateop 2444 * token labels : 2445 * rule labels : retval 2446 * token list labels : 2447 * rule list labels : 2448 */ 2449 { 2450 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; 2451 2452 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); 2453 2454 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2455 retval.tree = root_0; 2456 // 71:34: -> ^( dateop dateref INT dateintval ) 2457 { 2458 // RSP.g:71:37: ^( dateop dateref INT dateintval ) 2459 { 2460 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2461 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_dateop == NULL ? NULL : stream_dateop->nextNode(stream_dateop), root_1)); 2462 2463 ADAPTOR->addChild(ADAPTOR, root_1, stream_dateref == NULL ? NULL : stream_dateref->nextTree(stream_dateref)); 2464 ADAPTOR->addChild(ADAPTOR, root_1, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT)); 2465 ADAPTOR->addChild(ADAPTOR, root_1, stream_dateintval == NULL ? NULL : stream_dateintval->nextTree(stream_dateintval)); 2466 2467 ADAPTOR->addChild(ADAPTOR, root_0, root_1); 2468 } 2469 2470 } 2471 2472 retval.tree = root_0; // set result root 2473 if (stream_retval != NULL) stream_retval->free(stream_retval); 2474 2475 2476 } 2477 } 2478 break; 2479 2480 } 2481 } 2482 } 2483 2484 2485 // This is where rules clean up and exit 2486 // 2487 goto ruledatespecEx; /* Prevent compiler warnings */ 2488 ruledatespecEx: ; 2489 retval.stop = LT(-1); 2490 2491 retval.stop = LT(-1); 2492 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 2493 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 2494 if (stream_INT != NULL) stream_INT->free(stream_INT); 2495 if (stream_dateintval != NULL) stream_dateintval->free(stream_dateintval); 2496 if (stream_dateref != NULL) stream_dateref->free(stream_dateref); 2497 if (stream_dateop != NULL) stream_dateop->free(stream_dateop); 2498 2499 if (HASEXCEPTION()) 2500 { 2501 PREPORTERROR(); 2502 PRECOVER(); 2503 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 2504 } 2505 2506 2507 return retval; 2508} 2509/* $ANTLR end datespec */ 2510 2511/** 2512 * $ANTLR start dateref 2513 * RSP.g:74:1: dateref : ( DATE | TODAY ); 2514 */ 2515static RSPParser_dateref_return 2516dateref(pRSPParser ctx) 2517{ 2518 RSPParser_dateref_return retval; 2519 2520 pANTLR3_BASE_TREE root_0; 2521 2522 pANTLR3_COMMON_TOKEN set41; 2523 2524 pANTLR3_BASE_TREE set41_tree; 2525 2526 /* Initialize rule variables 2527 */ 2528 2529 2530 root_0 = NULL; 2531 2532 set41 = NULL; 2533 retval.start = LT(1); retval.stop = retval.start; 2534 2535 set41_tree = NULL; 2536 2537 2538 retval.tree = NULL; 2539 { 2540 // RSP.g:74:9: ( DATE | TODAY ) 2541 // RSP.g: 2542 { 2543 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2544 2545 set41=(pANTLR3_COMMON_TOKEN)LT(1); 2546 if ( ((LA(1) >= DATE) && (LA(1) <= TODAY)) ) 2547 { 2548 CONSUME(); 2549 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set41))); 2550 PERRORRECOVERY=ANTLR3_FALSE; 2551 } 2552 else 2553 { 2554 CONSTRUCTEX(); 2555 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 2556 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 2557 EXCEPTION->expectingSet = &FOLLOW_set_in_dateref0; 2558 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateref0); goto ruledaterefEx; 2559 } 2560 2561 2562 } 2563 2564 } 2565 2566 2567 // This is where rules clean up and exit 2568 // 2569 goto ruledaterefEx; /* Prevent compiler warnings */ 2570 ruledaterefEx: ; 2571 retval.stop = LT(-1); 2572 2573 retval.stop = LT(-1); 2574 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 2575 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 2576 2577 if (HASEXCEPTION()) 2578 { 2579 PREPORTERROR(); 2580 PRECOVER(); 2581 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 2582 } 2583 2584 2585 return retval; 2586} 2587/* $ANTLR end dateref */ 2588 2589/** 2590 * $ANTLR start dateintval 2591 * RSP.g:78:1: dateintval : ( DAY | WEEK | MONTH | YEAR ); 2592 */ 2593static RSPParser_dateintval_return 2594dateintval(pRSPParser ctx) 2595{ 2596 RSPParser_dateintval_return retval; 2597 2598 pANTLR3_BASE_TREE root_0; 2599 2600 pANTLR3_COMMON_TOKEN set42; 2601 2602 pANTLR3_BASE_TREE set42_tree; 2603 2604 /* Initialize rule variables 2605 */ 2606 2607 2608 root_0 = NULL; 2609 2610 set42 = NULL; 2611 retval.start = LT(1); retval.stop = retval.start; 2612 2613 set42_tree = NULL; 2614 2615 2616 retval.tree = NULL; 2617 { 2618 // RSP.g:79:2: ( DAY | WEEK | MONTH | YEAR ) 2619 // RSP.g: 2620 { 2621 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); 2622 2623 set42=(pANTLR3_COMMON_TOKEN)LT(1); 2624 if ( ((LA(1) >= DAY) && (LA(1) <= YEAR)) ) 2625 { 2626 CONSUME(); 2627 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set42))); 2628 PERRORRECOVERY=ANTLR3_FALSE; 2629 } 2630 else 2631 { 2632 CONSTRUCTEX(); 2633 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; 2634 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; 2635 EXCEPTION->expectingSet = &FOLLOW_set_in_dateintval0; 2636 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateintval0); goto ruledateintvalEx; 2637 } 2638 2639 2640 } 2641 2642 } 2643 2644 2645 // This is where rules clean up and exit 2646 // 2647 goto ruledateintvalEx; /* Prevent compiler warnings */ 2648 ruledateintvalEx: ; 2649 retval.stop = LT(-1); 2650 2651 retval.stop = LT(-1); 2652 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); 2653 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); 2654 2655 if (HASEXCEPTION()) 2656 { 2657 PREPORTERROR(); 2658 PRECOVER(); 2659 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); 2660 } 2661 2662 2663 return retval; 2664} 2665/* $ANTLR end dateintval */ 2666/* End of parsing rules 2667 * ============================================== 2668 */ 2669 2670/* ============================================== 2671 * Syntactic predicates 2672 */ 2673/* End of syntactic predicates 2674 * ============================================== 2675 */ 2676 2677 2678 2679 2680 2681 2682/* End of code 2683 * ============================================================================= 2684 */ 2685