LILiK
/
openwrt-packages-dist
5
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5235 Commits
1 Branch
46 MiB
 
 
 
 
 
 
Tree: 82055305b3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '82055305b3'
${ noResults }
openwrt-packages-dist/sound/forked-daapd/patches/010-include_pregen.patch

23739 lines
704 KiB
Raw Blame History

diff --git a/src/pregen/DAAP.u b/src/pregen/DAAP.u
new file mode 100644
index 0000000..3de527b
--- /dev/null
+++ b/src/pregen/DAAP.u
@@ -0,0 +1,6 @@
+DAAPParser.c : DAAP.g
+./DAAP.tokens : DAAP.g
+DAAPParser.h : DAAP.g
+DAAPLexer.c : DAAP.g
+DAAPLexer.h : DAAP.g
+ANTLR_PRODUCTS += DAAPParser.c ./DAAP.tokens DAAPParser.h DAAPLexer.c DAAPLexer.h
\ No newline at end of file
diff --git a/src/pregen/DAAP2SQL.c b/src/pregen/DAAP2SQL.c
new file mode 100644
index 0000000..04d6153
--- /dev/null
+++ b/src/pregen/DAAP2SQL.c
@@ -0,0 +1,975 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP2SQL.g
+ * - On : 2016-01-01 12:23:43
+ * - for the tree parser : DAAP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+/* =============================================================================
+ * This is what the grammar programmer asked us to put at the top of every file.
+ */
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <limits.h>
+ #include <errno.h>
+
+ #include "logger.h"
+ #include "db.h"
+ #include "daap_query.h"
+
+/* End of Header action.
+ * =============================================================================
+ */
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "DAAP2SQL.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pDAAP2SQL_##scope##_SCOPE
+#define SCOPE_STACK(scope) pDAAP2SQL_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pDAAP2SQL_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pDAAP2SQL_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+/* Macros for accessing things in the parser
+ */
+
+#undef PARSER
+#undef RECOGNIZER
+#undef HAVEPARSEDRULE
+#undef INPUT
+#undef STRSTREAM
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef MATCHT
+#undef MATCHANYT
+#undef FOLLOWSTACK
+#undef FOLLOWPUSH
+#undef FOLLOWPOP
+#undef PRECOVER
+#undef PREPORTERROR
+#undef LA
+#undef LT
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef PERRORRECOVERY
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef RECOVERFROMMISMATCHEDSET
+#undef RECOVERFROMMISMATCHEDELEMENT
+#undef BACKTRACKING
+#undef ADAPTOR
+#undef RULEMEMO
+#undef SEEK
+#undef INDEX
+#undef DBG
+
+#define PARSER ctx->pTreeParser
+#define RECOGNIZER PARSER->rec
+#define PSRSTATE RECOGNIZER->state
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define INPUT PARSER->ctnstream
+#define ISTREAM INPUT->tnstream->istream
+#define STRSTREAM INPUT->tnstream
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION PSRSTATE->exception
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
+#define FOLLOWSTACK PSRSTATE->following
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
+#define LA(n) ISTREAM->_LA(ISTREAM, n)
+#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define CONSUME() ISTREAM->consume(ISTREAM)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define PERRORRECOVERY PSRSTATE->errorRecovery
+#define FAILEDFLAG PSRSTATE->failed
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
+#define BACKTRACKING PSRSTATE->backtracking
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
+#define ADAPTOR INPUT->adaptor
+#define RULEMEMO PSRSTATE->ruleMemo
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define INDEX() ISTREAM->index(ISTREAM)
+#define DBG RECOGNIZER->debugger
+
+
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+
+/** \brief Table of all token names in symbolic order, mainly used for
+ * error reporting.
+ */
+pANTLR3_UINT8 DAAP2SQLTokenNames[8+4]
+ = {
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
+ (pANTLR3_UINT8) "<EOR>",
+ (pANTLR3_UINT8) "<DOWN>",
+ (pANTLR3_UINT8) "<UP>",
+ (pANTLR3_UINT8) "NEWLINE",
+ (pANTLR3_UINT8) "OPOR",
+ (pANTLR3_UINT8) "OPAND",
+ (pANTLR3_UINT8) "LPAR",
+ (pANTLR3_UINT8) "RPAR",
+ (pANTLR3_UINT8) "STR",
+ (pANTLR3_UINT8) "QUOTE",
+ (pANTLR3_UINT8) "ESCAPED"
+ };
+
+
+
+// Forward declare the locally static matching functions we have generated.
+//
+static pANTLR3_STRING query (pDAAP2SQL ctx);
+static DAAP2SQL_expr_return expr (pDAAP2SQL ctx);
+static void DAAP2SQLFree(pDAAP2SQL ctx);
+/* For use in tree output where we are accumulating rule labels via label += ruleRef
+ * we need a function that knows how to free a return scope when the list is destroyed.
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
+ */
+static void ANTLR3_CDECL freeScope(void * scope)
+{
+ ANTLR3_FREE(scope);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "DAAP2SQL.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+/** \brief Create a new DAAP2SQL parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pDAAP2SQL
+DAAP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
+{
+ // See if we can create a new parser with the standard constructor
+ //
+ return DAAP2SQLNewSSD(instream, NULL);
+}
+
+/** \brief Create a new DAAP2SQL parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pDAAP2SQL
+DAAP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pDAAP2SQL ctx; /* Context structure we will build and return */
+
+ ctx = (pDAAP2SQL) ANTLR3_CALLOC(1, sizeof(DAAP2SQL));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for parser context
+ //
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * the base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 parser function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in DAAP2SQL.h here, in order that you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base Tree parser/recognizer, using the supplied tree node stream
+ */
+ ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
+ /* Install the implementation of our DAAP2SQL interface
+ */
+ ctx->query = query;
+ ctx->expr = expr;
+ ctx->free = DAAP2SQLFree;
+ ctx->getGrammarFileName = getGrammarFileName;
+
+ /* Install the scope pushing methods.
+ */
+
+
+
+
+
+ /* Install the token table
+ */
+ PSRSTATE->tokenNames = DAAP2SQLTokenNames;
+
+
+ /* Return the newly built parser to the caller
+ */
+ return ctx;
+}
+
+/** Free the parser resources
+ */
+ static void
+ DAAP2SQLFree(pDAAP2SQL ctx)
+ {
+ /* Free any scope memory
+ */
+
+
+ // Free this parser
+ //
+ ctx->pTreeParser->free(ctx->pTreeParser);
+ ANTLR3_FREE(ctx);
+
+ /* Everything is released, so we can return
+ */
+ return;
+ }
+
+/** Return token names used by this tree parser
+ *
+ * The returned pointer is used as an index into the token names table (using the token
+ * number as the index).
+ *
+ * \return Pointer to first char * in the table.
+ */
+static pANTLR3_UINT8 *getTokenNames()
+{
+ return DAAP2SQLTokenNames;
+}
+
+
+ struct dmap_query_field_map {
+ char *dmap_field;
+ char *db_col;
+ int as_int;
+ };
+
+ /* gperf static hash, daap_query.gperf */
+ #include "daap_query_hash.c"
+
+
+/* Declare the bitsets
+ */
+
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query70 */
+static ANTLR3_BITWORD FOLLOW_expr_in_query70_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_query70 = { FOLLOW_expr_in_query70_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPAND_in_expr95 */
+static ANTLR3_BITWORD FOLLOW_OPAND_in_expr95_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_OPAND_in_expr95 = { FOLLOW_OPAND_in_expr95_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr101 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000260) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr101 = { FOLLOW_expr_in_expr101_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr107 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr107 = { FOLLOW_expr_in_expr107_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPOR_in_expr118 */
+static ANTLR3_BITWORD FOLLOW_OPOR_in_expr118_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_OPOR_in_expr118 = { FOLLOW_OPOR_in_expr118_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr124 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr124_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000260) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr124 = { FOLLOW_expr_in_expr124_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr130 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr130_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr130 = { FOLLOW_expr_in_expr130_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_expr140 */
+static ANTLR3_BITWORD FOLLOW_STR_in_expr140_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_expr140 = { FOLLOW_STR_in_expr140_bits, 1 };
+
+
+
+
+/* ==============================================
+ * Parsing rules
+ */
+/**
+ * $ANTLR start query
+ * DAAP2SQL.g:50:1: query returns [ pANTLR3_STRING result ] : e= expr ;
+ */
+static pANTLR3_STRING
+query(pDAAP2SQL ctx)
+{
+ pANTLR3_STRING result = NULL;
+
+ DAAP2SQL_expr_return e;
+ #undef RETURN_TYPE_e
+ #define RETURN_TYPE_e DAAP2SQL_expr_return
+
+ /* Initialize rule variables
+ */
+
+
+ result= NULL;
+ {
+ // DAAP2SQL.g:52:2: (e= expr )
+ // DAAP2SQL.g:52:4: e= expr
+ {
+ FOLLOWPUSH(FOLLOW_expr_in_query70);
+ e=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ {
+
+ if (!e.valid)
+ {
+ result= NULL;
+ }
+ else
+ {
+ result= e.result->factory->newRaw(e.result->factory);
+ result->append8(result, "(");
+ result->appendS(result, e.result);
+ result->append8(result, ")");
+ }
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulequeryEx; /* Prevent compiler warnings */
+ rulequeryEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return result;
+}
+/* $ANTLR end query */
+
+/**
+ * $ANTLR start expr
+ * DAAP2SQL.g:68:1: expr returns [ pANTLR3_STRING result, int valid ] : ( ^( OPAND a= expr b= expr ) | ^( OPOR a= expr b= expr ) | STR );
+ */
+static DAAP2SQL_expr_return
+expr(pDAAP2SQL ctx)
+{
+ DAAP2SQL_expr_return retval;
+
+ pANTLR3_BASE_TREE STR1;
+ DAAP2SQL_expr_return a;
+ #undef RETURN_TYPE_a
+ #define RETURN_TYPE_a DAAP2SQL_expr_return
+
+ DAAP2SQL_expr_return b;
+ #undef RETURN_TYPE_b
+ #define RETURN_TYPE_b DAAP2SQL_expr_return
+
+ /* Initialize rule variables
+ */
+
+
+ retval.result= NULL; retval.valid= 1;
+ STR1 = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ {
+ // DAAP2SQL.g:70:2: ( ^( OPAND a= expr b= expr ) | ^( OPOR a= expr b= expr ) | STR )
+
+ ANTLR3_UINT32 alt1;
+
+ alt1=3;
+
+ switch ( LA(1) )
+ {
+ case OPAND:
+ {
+ alt1=1;
+ }
+ break;
+ case OPOR:
+ {
+ alt1=2;
+ }
+ break;
+ case STR:
+ {
+ alt1=3;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 0;
+
+
+ goto ruleexprEx;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // DAAP2SQL.g:70:4: ^( OPAND a= expr b= expr )
+ {
+ MATCHT(OPAND, &FOLLOW_OPAND_in_expr95);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr101);
+ a=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr107);
+ b=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ if (a.valid && b.valid)
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->append8(retval.result, "(");
+ retval.result->appendS(retval.result, a.result);
+ retval.result->append8(retval.result, " AND ");
+ retval.result->appendS(retval.result, b.result);
+ retval.result->append8(retval.result, ")");
+ }
+ else if (a.valid)
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->appendS(retval.result, a.result);
+ }
+ else if (b.valid)
+ {
+ retval.result= b.result->factory->newRaw(b.result->factory);
+ retval.result->appendS(retval.result, b.result);
+ }
+ else
+ {
+ retval.valid= 0;
+ }
+
+ }
+
+ }
+ break;
+ case 2:
+ // DAAP2SQL.g:96:4: ^( OPOR a= expr b= expr )
+ {
+ MATCHT(OPOR, &FOLLOW_OPOR_in_expr118);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr124);
+ a=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr130);
+ b=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ if (a.valid && b.valid)
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->append8(retval.result, "(");
+ retval.result->appendS(retval.result, a.result);
+ retval.result->append8(retval.result, " OR ");
+ retval.result->appendS(retval.result, b.result);
+ retval.result->append8(retval.result, ")");
+ }
+ else if (a.valid)
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->appendS(retval.result, a.result);
+ }
+ else if (b.valid)
+ {
+ retval.result= b.result->factory->newRaw(b.result->factory);
+ retval.result->appendS(retval.result, b.result);
+ }
+ else
+ {
+ retval.valid= 0;
+ }
+
+ }
+
+ }
+ break;
+ case 3:
+ // DAAP2SQL.g:122:4: STR
+ {
+ STR1 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expr140);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ pANTLR3_STRING str;
+ pANTLR3_UINT8 field;
+ pANTLR3_UINT8 val;
+ pANTLR3_UINT8 escaped;
+ ANTLR3_UINT8 op;
+ int neg_op;
+ const struct dmap_query_field_map *dqfm;
+ char *end;
+ long long llval;
+
+ escaped = NULL;
+
+ retval.result= (STR1->getText(STR1))->factory->newRaw((STR1->getText(STR1))->factory);
+
+ str = (STR1->getText(STR1))->toUTF8((STR1->getText(STR1)));
+
+ /* NOTE: the lexer delivers the string without quotes
+ which may not be obvious from the grammar due to embedded code
+ */
+
+ /* Make daap.songalbumid:0 a no-op */
+ if (strcmp((char *)str->chars, "daap.songalbumid:0") == 0)
+ {
+ retval.result->append8(retval.result, "1 = 1");
+
+ goto STR_out;
+ }
+
+ field = str->chars;
+
+ val = field;
+ while ((*val != '\0') && ((*val == '.')
+ || (*val == '-')
+ || ((*val >= 'a') && (*val <= 'z'))
+ || ((*val >= 'A') && (*val <= 'Z'))
+ || ((*val >= '0') && (*val <= '9'))))
+ {
+ val++;
+ }
+
+ if (*field == '\0')
+ {
+ DPRINTF(E_LOG, L_DAAP, "No field name found in clause '%s'\n", field);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ if (*val == '\0')
+ {
+ DPRINTF(E_LOG, L_DAAP, "No operator found in clause '%s'\n", field);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ op = *val;
+ *val = '\0';
+ val++;
+
+ if (op == '!')
+ {
+ if (*val == '\0')
+ {
+ DPRINTF(E_LOG, L_DAAP, "Negation found but operator missing in clause '%s%c'\n", field, op);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ neg_op = 1;
+ op = *val;
+ val++;
+ }
+ else
+ neg_op = 0;
+
+ /* Lookup DMAP field in the query field map */
+ dqfm = daap_query_field_lookup((char *)field, strlen((char *)field));
+ if (!dqfm)
+ {
+ DPRINTF(E_LOG, L_DAAP, "DMAP field '%s' is not a valid field in queries\n", field);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ /* Empty values OK for string fields, NOK for integer */
+ if (*val == '\0')
+ {
+ if (dqfm->as_int)
+ {
+ DPRINTF(E_LOG, L_DAAP, "No value given in clause '%s%s%c'\n", field, (neg_op) ? "!" : "", op);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ /* No need to exclude empty artist and album, as forked-daapd makes sure there always exists an artist/album. */
+ if (neg_op && op == ':'
+ && (strcmp((char *)field, "daap.songalbumartist") == 0
+ || strcmp((char *)field, "daap.songartist") == 0
+ || strcmp((char *)field, "daap.songalbum") == 0))
+ {
+ DPRINTF(E_DBG, L_DAAP, "Ignoring clause '%s%s%c'\n", field, (neg_op) ? "!" : "", op);
+ retval.valid= 0;
+ goto STR_result_valid_0;
+ }
+
+ /* Need to check against NULL too */
+ if (op == ':')
+ retval.result->append8(retval.result, "(");
+ }
+
+ /* Int field: check integer conversion */
+ if (dqfm->as_int)
+ {
+ errno = 0;
+ llval = strtoll((const char *)val, &end, 10);
+
+ if (((errno == ERANGE) && ((llval == LLONG_MAX) || (llval == LLONG_MIN)))
+ || ((errno != 0) && (llval == 0)))
+ {
+ DPRINTF(E_LOG, L_DAAP, "Value '%s' in clause '%s%s%c%s' does not convert to an integer type\n",
+ val, field, (neg_op) ? "!" : "", op, val);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ if (end == (char *)val)
+ {
+ DPRINTF(E_LOG, L_DAAP, "Value '%s' in clause '%s%s%c%s' does not represent an integer value\n",
+ val, field, (neg_op) ? "!" : "", op, val);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ *end = '\0'; /* Cut out potential garbage - we're being kind */
+
+ /* forked-daapd only has media_kind = 1 for music - so remove media_kind = 32 to imporve select query performance. */
+ if (llval == 32
+ && (strcmp((char *)field, "com.apple.itunes.mediakind") == 0
+ || strcmp((char *)field, "com.apple.itunes.extended-media-kind") == 0))
+ {
+ DPRINTF(E_DBG, L_DAAP, "Ignoring clause '%s%s%c%s'\n", field, (neg_op) ? "!" : "", op, val);
+
+ if (neg_op)
+ retval.result->append8(retval.result, "1 = 1");
+ else
+ retval.result->append8(retval.result, "1 = 0");
+
+ goto STR_out;
+ }
+ }
+ /* String field: escape string, check for '*' */
+ else
+ {
+ if (op != ':')
+ {
+ DPRINTF(E_LOG, L_DAAP, "Operation '%c' not valid for string values\n", op);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ escaped = (pANTLR3_UINT8)db_escape_string((char *)val);
+ if (!escaped)
+ {
+ DPRINTF(E_LOG, L_DAAP, "Could not escape value\n");
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ }
+
+ val = escaped;
+
+ if (val[0] == '*')
+ {
+ op = '%';
+ val[0] = '%';
+ }
+
+ if (val[0] && val[1] && val[strlen((char *)val) - 1] == '*')
+ {
+ op = '%';
+ val[strlen((char *)val) - 1] = '%';
+ }
+ }
+
+ retval.result->append8(retval.result, dqfm->db_col);
+
+ switch(op)
+ {
+ case ':':
+ if (neg_op)
+ retval.result->append8(retval.result, " <> ");
+ else
+ retval.result->append8(retval.result, " = ");
+ break;
+
+ case '+':
+ if (neg_op)
+ retval.result->append8(retval.result, " <= ");
+ else
+ retval.result->append8(retval.result, " > ");
+ break;
+
+ case '-':
+ if (neg_op)
+ retval.result->append8(retval.result, " >= ");
+ else
+ retval.result->append8(retval.result, " < ");
+ break;
+
+ case '%':
+ retval.result->append8(retval.result, " LIKE ");
+ break;
+
+ default:
+ if (neg_op)
+ DPRINTF(E_LOG, L_DAAP, "Missing or unknown operator '%c' in clause '%s!%c%s'\n", op, field, op, val);
+ else
+ DPRINTF(E_LOG, L_DAAP, "Unknown operator '%c' in clause '%s%c%s'\n", op, field, op, val);
+ retval.valid= 0;
+ goto STR_result_valid_0; /* ABORT */
+ break;
+ }
+
+ if (!dqfm->as_int)
+ retval.result->append8(retval.result, "'");
+
+ retval.result->append8(retval.result, (const char *)val);
+
+ if (!dqfm->as_int)
+ retval.result->append8(retval.result, "'");
+
+ /* For empty string value, we need to check against NULL too */
+ if ((*val == '\0') && (op == ':'))
+ {
+ if (neg_op)
+ retval.result->append8(retval.result, " AND ");
+ else
+ retval.result->append8(retval.result, " OR ");
+
+ retval.result->append8(retval.result, dqfm->db_col);
+
+ if (neg_op)
+ retval.result->append8(retval.result, " IS NOT NULL");
+ else
+ retval.result->append8(retval.result, " IS NULL");
+
+ retval.result->append8(retval.result, ")");
+ }
+
+ STR_result_valid_0: /* bail out label */
+ ;
+
+ if (escaped)
+ free(escaped);
+
+ STR_out: /* get out of here */
+ ;
+
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleexprEx; /* Prevent compiler warnings */
+ ruleexprEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end expr */
+/* End of parsing rules
+ * ==============================================
+ */
+
+/* ==============================================
+ * Syntactic predicates
+ */
+/* End of syntactic predicates
+ * ==============================================
+ */
+
+
+
+
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/DAAP2SQL.h b/src/pregen/DAAP2SQL.h
new file mode 100644
index 0000000..e829049
--- /dev/null
+++ b/src/pregen/DAAP2SQL.h
@@ -0,0 +1,195 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP2SQL.g
+ * - On : 2016-01-01 12:23:43
+ * - for the tree parser : DAAP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The tree parser DAAP2SQL has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pDAAP2SQL, which is returned from a call to DAAP2SQLNew().
+ *
+ * The methods in pDAAP2SQL are as follows:
+ *
+ * - pANTLR3_STRING pDAAP2SQL->query(pDAAP2SQL)
+ * - DAAP2SQL_expr_return pDAAP2SQL->expr(pDAAP2SQL)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _DAAP2SQL_H
+#define _DAAP2SQL_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct DAAP2SQL_Ctx_struct DAAP2SQL, * pDAAP2SQL;
+
+
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <limits.h>
+ #include <errno.h>
+
+ #include "logger.h"
+ #include "db.h"
+ #include "daap_query.h"
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+typedef struct DAAP2SQL_expr_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ pANTLR3_STRING result;
+ int valid;
+}
+ DAAP2SQL_expr_return;
+
+
+
+/** Context tracking structure for DAAP2SQL
+ */
+struct DAAP2SQL_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_TREE_PARSER pTreeParser;
+
+
+ pANTLR3_STRING (*query) (struct DAAP2SQL_Ctx_struct * ctx);
+ DAAP2SQL_expr_return (*expr) (struct DAAP2SQL_Ctx_struct * ctx);
+ // Delegated rules
+ const char * (*getGrammarFileName)();
+ void (*free) (struct DAAP2SQL_Ctx_struct * ctx);
+
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pDAAP2SQL DAAP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream);
+ANTLR3_API pDAAP2SQL DAAP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the tree parser will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define STR 9
+#define QUOTE 10
+#define NEWLINE 4
+#define LPAR 7
+#define OPOR 5
+#define RPAR 8
+#define ESCAPED 11
+#define OPAND 6
+#define EOF -1
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for DAAP2SQL
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/DAAP2SQL.u b/src/pregen/DAAP2SQL.u
new file mode 100644
index 0000000..385d80b
--- /dev/null
+++ b/src/pregen/DAAP2SQL.u
@@ -0,0 +1,5 @@
+DAAP2SQL.g: DAAP.tokens
+DAAP2SQL.c : DAAP2SQL.g
+./DAAP2SQL.tokens : DAAP2SQL.g
+DAAP2SQL.h : DAAP2SQL.g
+ANTLR_PRODUCTS += DAAP2SQL.c ./DAAP2SQL.tokens DAAP2SQL.h
\ No newline at end of file
diff --git a/src/pregen/DAAPLexer.c b/src/pregen/DAAPLexer.c
new file mode 100644
index 0000000..eab3ff4
--- /dev/null
+++ b/src/pregen/DAAPLexer.c
@@ -0,0 +1,1101 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP.g
+ * - On : 2016-01-01 12:23:41
+ * - for the lexer : DAAPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "DAAPLexer.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pDAAPLexer_##scope##_SCOPE
+#define SCOPE_STACK(scope) pDAAPLexer_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pDAAPLexer_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pDAAPLexer_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+
+/* Macros for accessing things in a lexer
+ */
+#undef LEXER
+#undef RECOGNIZER
+#undef RULEMEMO
+#undef GETCHARINDEX
+#undef GETLINE
+#undef GETCHARPOSITIONINLINE
+#undef EMIT
+#undef EMITNEW
+#undef MATCHC
+#undef MATCHS
+#undef MATCHRANGE
+#undef LTOKEN
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef INPUT
+#undef STRSTREAM
+#undef LA
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef LRECOVER
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef BACKTRACKING
+#undef MATCHANY
+#undef MEMOIZE
+#undef HAVEPARSEDRULE
+#undef GETTEXT
+#undef INDEX
+#undef SEEK
+#undef PUSHSTREAM
+#undef POPSTREAM
+#undef SETTEXT
+#undef SETTEXT8
+
+#define LEXER ctx->pLexer
+#define RECOGNIZER LEXER->rec
+#define LEXSTATE RECOGNIZER->state
+#define TOKSOURCE LEXSTATE->tokSource
+#define GETCHARINDEX() LEXER->getCharIndex(LEXER)
+#define GETLINE() LEXER->getLine(LEXER)
+#define GETTEXT() LEXER->getText(LEXER)
+#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
+#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER)
+#define EMITNEW(t) LEXER->emitNew(LEXER, t)
+#define MATCHC(c) LEXER->matchc(LEXER, c)
+#define MATCHS(s) LEXER->matchs(LEXER, s)
+#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2)
+#define MATCHANY() LEXER->matchAny(LEXER)
+#define LTOKEN LEXSTATE->token
+#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE)
+#define BACKTRACKING LEXSTATE->backtracking
+#define FAILEDFLAG LEXSTATE->failed
+#define INPUT LEXER->input
+#define STRSTREAM INPUT
+#define ISTREAM INPUT->istream
+#define INDEX() ISTREAM->index(ISTREAM)
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken)
+#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION LEXSTATE->exception
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define LRECOVER() LEXER->recover(LEXER)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str)
+#define POPSTREAM() LEXER->popCharStream(LEXER)
+#define SETTEXT(str) LEXSTATE->text = str
+#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken)
+#define USER1 LEXSTATE->user1
+#define USER2 LEXSTATE->user2
+#define USER3 LEXSTATE->user3
+#define CUSTOM LEXSTATE->custom
+#define RULEMEMO LEXSTATE->ruleMemo
+#define DBG RECOGNIZER->debugger
+
+/* If we have been told we can rely on the standard 8 bit or 16 bit input
+ * stream, then we can define our macros to use the direct pointers
+ * in the input object, which is much faster than indirect calls. This
+ * is really only significant to lexers with a lot of fragment rules (which
+ * do not place LA(1) in a temporary at the moment) and even then
+ * only if there is a lot of input (order of say 1M or so).
+ */
+#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
+
+# ifdef ANTLR3_INLINE_INPUT_ASCII
+
+/* 8 bit "ASCII" (actually any 8 bit character set) */
+
+# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar))
+# define DATAP ((pANTLR3_UINT8)(INPUT->data))
+
+# else
+
+# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar))
+# define DATAP ((pANTLR3_UINT16)(INPUT->data))
+
+# endif
+
+# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
+# define CONSUME() \
+{ \
+ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \
+ { \
+ INPUT->charPositionInLine++; \
+ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \
+ { \
+ INPUT->line++; \
+ INPUT->charPositionInLine = 0; \
+ INPUT->currentLine = (void *)(NEXTCHAR + 1); \
+ } \
+ INPUT->nextChar = (void *)(NEXTCHAR + 1); \
+ } \
+}
+
+#else
+
+// Pick up the input character by calling the input stream implementation.
+//
+#define CONSUME() INPUT->istream->consume(INPUT->istream)
+#define LA(n) INPUT->istream->_LA(INPUT->istream, n)
+
+#endif
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+/* Forward declare the locally static matching functions we have generated and any predicate functions.
+ */
+static ANTLR3_INLINE void mQUOTE (pDAAPLexer ctx);
+static ANTLR3_INLINE void mLPAR (pDAAPLexer ctx);
+static ANTLR3_INLINE void mRPAR (pDAAPLexer ctx);
+static ANTLR3_INLINE void mOPAND (pDAAPLexer ctx);
+static ANTLR3_INLINE void mOPOR (pDAAPLexer ctx);
+static ANTLR3_INLINE void mNEWLINE (pDAAPLexer ctx);
+static ANTLR3_INLINE void mSTR (pDAAPLexer ctx);
+static ANTLR3_INLINE void mESCAPED (pDAAPLexer ctx);
+static ANTLR3_INLINE void mTokens (pDAAPLexer ctx);
+static void DAAPLexerFree(pDAAPLexer ctx);
+
+/* =========================================================================
+ * Lexer matching rules end.
+ * =========================================================================
+ */
+
+
+
+static void
+DAAPLexerFree (pDAAPLexer ctx)
+{
+ LEXER->free(LEXER);
+
+ ANTLR3_FREE(ctx);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "DAAP.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+
+/** \brief Create a new lexer called DAAPLexer
+ *
+ * \param[in] instream Pointer to an initialized input stream
+ * \return
+ * - Success pDAAPLexer initialized for the lex start
+ * - Fail NULL
+ */
+ANTLR3_API pDAAPLexer DAAPLexerNew
+(pANTLR3_INPUT_STREAM instream)
+{
+ // See if we can create a new lexer with the standard constructor
+ //
+ return DAAPLexerNewSSD(instream, NULL);
+}
+
+/** \brief Create a new lexer called DAAPLexer
+ *
+ * \param[in] instream Pointer to an initialized input stream
+ * \param[state] state Previously created shared recognizer stat
+ * \return
+ * - Success pDAAPLexer initialized for the lex start
+ * - Fail NULL
+ */
+ANTLR3_API pDAAPLexer DAAPLexerNewSSD
+(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pDAAPLexer ctx; // Context structure we will build and return
+
+ ctx = (pDAAPLexer) ANTLR3_CALLOC(1, sizeof(DAAPLexer));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for lexer context
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * in base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 lexer function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in DAAPLexer.h here so you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base lexer, using the supplied input stream
+ */
+ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
+
+ /* Check that we allocated the memory correctly
+ */
+ if (ctx->pLexer == NULL)
+ {
+ ANTLR3_FREE(ctx);
+ return NULL;
+ }
+ /* Install the implementation of our DAAPLexer interface
+ */
+ ctx->mQUOTE = mQUOTE;
+ ctx->mLPAR = mLPAR;
+ ctx->mRPAR = mRPAR;
+ ctx->mOPAND = mOPAND;
+ ctx->mOPOR = mOPOR;
+ ctx->mNEWLINE = mNEWLINE;
+ ctx->mSTR = mSTR;
+ ctx->mESCAPED = mESCAPED;
+ ctx->mTokens = mTokens;
+
+ /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
+ * it will call mTokens() in this generated code, and will pass it the ctx
+ * pointer of this lexer, not the context of the base lexer, so store that now.
+ */
+ ctx->pLexer->ctx = ctx;
+
+ /**Install the token matching function
+ */
+ ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
+
+ ctx->getGrammarFileName = getGrammarFileName;
+ ctx->free = DAAPLexerFree;
+
+
+
+
+
+ /* Return the newly built lexer to the caller
+ */
+ return ctx;
+}
+
+
+/* =========================================================================
+ * Functions to match the lexer grammar defined tokens from the input stream
+ */
+
+// Comes from: 40:7: ( '\\'' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start QUOTE
+ *
+ * Looks to match the characters the constitute the token QUOTE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mQUOTE(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = QUOTE;
+
+
+ // DAAP.g:40:7: ( '\\'' )
+ // DAAP.g:40:9: '\\''
+ {
+ MATCHC('\'');
+ if (HASEXCEPTION())
+ {
+ goto ruleQUOTEEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleQUOTEEx; /* Prevent compiler warnings */
+ ruleQUOTEEx: ;
+
+}
+// $ANTLR end QUOTE
+
+// Comes from: 41:6: ( '(' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LPAR
+ *
+ * Looks to match the characters the constitute the token LPAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLPAR(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = LPAR;
+
+
+ // DAAP.g:41:6: ( '(' )
+ // DAAP.g:41:8: '('
+ {
+ MATCHC('(');
+ if (HASEXCEPTION())
+ {
+ goto ruleLPAREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLPAREx; /* Prevent compiler warnings */
+ ruleLPAREx: ;
+
+}
+// $ANTLR end LPAR
+
+// Comes from: 42:6: ( ')' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start RPAR
+ *
+ * Looks to match the characters the constitute the token RPAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mRPAR(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = RPAR;
+
+
+ // DAAP.g:42:6: ( ')' )
+ // DAAP.g:42:8: ')'
+ {
+ MATCHC(')');
+ if (HASEXCEPTION())
+ {
+ goto ruleRPAREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleRPAREx; /* Prevent compiler warnings */
+ ruleRPAREx: ;
+
+}
+// $ANTLR end RPAR
+
+// Comes from: 44:7: ( '+' | ' ' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start OPAND
+ *
+ * Looks to match the characters the constitute the token OPAND
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mOPAND(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = OPAND;
+
+
+ // DAAP.g:44:7: ( '+' | ' ' )
+ // DAAP.g:
+ {
+ if ( LA(1) == ' ' || LA(1) == '+' )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleOPANDEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleOPANDEx; /* Prevent compiler warnings */
+ ruleOPANDEx: ;
+
+}
+// $ANTLR end OPAND
+
+// Comes from: 45:6: ( ',' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start OPOR
+ *
+ * Looks to match the characters the constitute the token OPOR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mOPOR(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = OPOR;
+
+
+ // DAAP.g:45:6: ( ',' )
+ // DAAP.g:45:8: ','
+ {
+ MATCHC(',');
+ if (HASEXCEPTION())
+ {
+ goto ruleOPOREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleOPOREx; /* Prevent compiler warnings */
+ ruleOPOREx: ;
+
+}
+// $ANTLR end OPOR
+
+// Comes from: 47:9: ( ( '\\r' )? '\\n' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start NEWLINE
+ *
+ * Looks to match the characters the constitute the token NEWLINE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mNEWLINE(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = NEWLINE;
+
+
+ // DAAP.g:47:9: ( ( '\\r' )? '\\n' )
+ // DAAP.g:47:11: ( '\\r' )? '\\n'
+ {
+
+ // DAAP.g:47:11: ( '\\r' )?
+ {
+ int alt1=2;
+ switch ( LA(1) )
+ {
+ case '\r':
+ {
+ alt1=1;
+ }
+ break;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // DAAP.g:47:11: '\\r'
+ {
+ MATCHC('\r');
+ if (HASEXCEPTION())
+ {
+ goto ruleNEWLINEEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ MATCHC('\n');
+ if (HASEXCEPTION())
+ {
+ goto ruleNEWLINEEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleNEWLINEEx; /* Prevent compiler warnings */
+ ruleNEWLINEEx: ;
+
+}
+// $ANTLR end NEWLINE
+
+// Comes from: 55:2: ( QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start STR
+ *
+ * Looks to match the characters the constitute the token STR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mSTR(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+ pANTLR3_COMMON_TOKEN esc;
+ ANTLR3_UINT32 reg;
+
+
+ esc = NULL;
+
+ _type = STR;
+
+ pANTLR3_STRING unesc = GETTEXT()->factory->newRaw(GETTEXT()->factory);
+
+ // DAAP.g:55:2: ( QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE )
+ // DAAP.g:55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE
+ {
+ /* 55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE */
+ mQUOTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ // DAAP.g:55:10: (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+
+ {
+ int cnt2=0;
+
+ for (;;)
+ {
+ int alt2=3;
+ {
+ /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
+ */
+ int LA2_0 = LA(1);
+ if ( (((LA2_0 >= 0x0000) && (LA2_0 <= '&')) || ((LA2_0 >= '(') && (LA2_0 <= '[')) || ((LA2_0 >= ']') && (LA2_0 <= 0xFFFF))) )
+ {
+ alt2=1;
+ }
+ else if ( (LA2_0 == '\\') )
+ {
+ alt2=2;
+ }
+
+ }
+ switch (alt2)
+ {
+ case 1:
+ // DAAP.g:55:12: reg=~ ( '\\\\' | '\\'' )
+ {
+ reg= LA(1);
+ if ( ((LA(1) >= 0x0000) && (LA(1) <= '&')) || ((LA(1) >= '(') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleSTREx;
+ }
+
+ {
+ unesc->addc(unesc, reg);
+ }
+
+ }
+ break;
+ case 2:
+ // DAAP.g:56:6: esc= ESCAPED
+ {
+ /* 56:6: esc= ESCAPED */
+ {
+ ANTLR3_MARKER escStart118 = GETCHARINDEX();
+ mESCAPED(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ esc = LEXSTATE->tokFactory->newToken(LEXSTATE->tokFactory);
+ esc->setType(esc, ANTLR3_TOKEN_INVALID);
+ esc->setStartIndex(esc, escStart118);
+ esc->setStopIndex(esc, GETCHARINDEX()-1);
+ esc->input = INPUT;
+ }
+ {
+ unesc->appendS(unesc, GETTEXT());
+ }
+
+ }
+ break;
+
+ default:
+
+ if ( cnt2 >= 1 )
+ {
+ goto loop2;
+ }
+ /* mismatchedSetEx()
+ */
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
+
+
+ goto ruleSTREx;
+ }
+ cnt2++;
+ }
+ loop2: ; /* Jump to here if this rule does not match */
+ }
+ /* 55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE */
+ mQUOTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ {
+ SETTEXT(unesc);
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleSTREx; /* Prevent compiler warnings */
+ ruleSTREx: ;
+
+ esc = NULL;
+
+}
+// $ANTLR end STR
+
+// Comes from: 59:9: ( '\\\\' ( '\\\\' | '\\'' ) )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start ESCAPED
+ *
+ * Looks to match the characters the constitute the token ESCAPED
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mESCAPED(pDAAPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // DAAP.g:59:9: ( '\\\\' ( '\\\\' | '\\'' ) )
+ // DAAP.g:59:11: '\\\\' ( '\\\\' | '\\'' )
+ {
+ MATCHC('\\');
+ if (HASEXCEPTION())
+ {
+ goto ruleESCAPEDEx;
+ }
+
+
+ // DAAP.g:60:3: ( '\\\\' | '\\'' )
+ {
+ int alt3=2;
+ switch ( LA(1) )
+ {
+ case '\\':
+ {
+ alt3=1;
+ }
+ break;
+ case '\'':
+ {
+ alt3=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 0;
+
+
+ goto ruleESCAPEDEx;
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // DAAP.g:60:5: '\\\\'
+ {
+ MATCHC('\\');
+ if (HASEXCEPTION())
+ {
+ goto ruleESCAPEDEx;
+ }
+
+ {
+ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\\"));
+ }
+
+ }
+ break;
+ case 2:
+ // DAAP.g:61:5: '\\''
+ {
+ MATCHC('\'');
+ if (HASEXCEPTION())
+ {
+ goto ruleESCAPEDEx;
+ }
+
+ {
+ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\'"));
+ }
+
+ }
+ break;
+
+ }
+ }
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleESCAPEDEx; /* Prevent compiler warnings */
+ ruleESCAPEDEx: ;
+
+}
+// $ANTLR end ESCAPED
+
+/** This is the entry point in to the lexer from an object that
+ * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
+ */
+static void
+mTokens(pDAAPLexer ctx)
+{
+ {
+ // DAAP.g:1:8: ( QUOTE | LPAR | RPAR | OPAND | OPOR | NEWLINE | STR )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=7;
+
+ switch ( LA(1) )
+ {
+ case '\'':
+ {
+
+ {
+ int LA4_1 = LA(2);
+ if ( (((LA4_1 >= 0x0000) && (LA4_1 <= '&')) || ((LA4_1 >= '(') && (LA4_1 <= 0xFFFF))) )
+ {
+ alt4=7;
+ }
+ else
+ {
+ alt4=1; }
+ }
+ }
+ break;
+ case '(':
+ {
+ alt4=2;
+ }
+ break;
+ case ')':
+ {
+ alt4=3;
+ }
+ break;
+ case ' ':
+ case '+':
+ {
+ alt4=4;
+ }
+ break;
+ case ',':
+ {
+ alt4=5;
+ }
+ break;
+ case '\n':
+ case '\r':
+ {
+ alt4=6;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto ruleTokensEx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // DAAP.g:1:10: QUOTE
+ {
+ /* 1:10: QUOTE */
+ mQUOTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 2:
+ // DAAP.g:1:16: LPAR
+ {
+ /* 1:16: LPAR */
+ mLPAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 3:
+ // DAAP.g:1:21: RPAR
+ {
+ /* 1:21: RPAR */
+ mRPAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 4:
+ // DAAP.g:1:26: OPAND
+ {
+ /* 1:26: OPAND */
+ mOPAND(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 5:
+ // DAAP.g:1:32: OPOR
+ {
+ /* 1:32: OPOR */
+ mOPOR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 6:
+ // DAAP.g:1:37: NEWLINE
+ {
+ /* 1:37: NEWLINE */
+ mNEWLINE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 7:
+ // DAAP.g:1:45: STR
+ {
+ /* 1:45: STR */
+ mSTR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+
+
+ goto ruleTokensEx; /* Prevent compiler warnings */
+ruleTokensEx: ;
+}
+
+/* =========================================================================
+ * Lexer matching rules end.
+ * =========================================================================
+ */
+/* End of Lexer code
+ * ================================================
+ * ================================================
+ */
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/DAAPLexer.h b/src/pregen/DAAPLexer.h
new file mode 100644
index 0000000..685a0bc
--- /dev/null
+++ b/src/pregen/DAAPLexer.h
@@ -0,0 +1,188 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP.g
+ * - On : 2016-01-01 12:23:41
+ * - for the lexer : DAAPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The lexer DAAPLexer has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pDAAPLexer, which is returned from a call to DAAPLexerNew().
+ *
+ * As this is a generated lexer, it is unlikely you will call it 'manually'. However
+ * the methods are provided anyway.
+ * * The methods in pDAAPLexer are as follows:
+ *
+ * - void pDAAPLexer->QUOTE(pDAAPLexer)
+ * - void pDAAPLexer->LPAR(pDAAPLexer)
+ * - void pDAAPLexer->RPAR(pDAAPLexer)
+ * - void pDAAPLexer->OPAND(pDAAPLexer)
+ * - void pDAAPLexer->OPOR(pDAAPLexer)
+ * - void pDAAPLexer->NEWLINE(pDAAPLexer)
+ * - void pDAAPLexer->STR(pDAAPLexer)
+ * - void pDAAPLexer->ESCAPED(pDAAPLexer)
+ * - void pDAAPLexer->Tokens(pDAAPLexer)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _DAAPLexer_H
+#define _DAAPLexer_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct DAAPLexer_Ctx_struct DAAPLexer, * pDAAPLexer;
+
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+
+/** Context tracking structure for DAAPLexer
+ */
+struct DAAPLexer_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_LEXER pLexer;
+
+
+ void (*mQUOTE) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mLPAR) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mRPAR) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mOPAND) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mOPOR) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mNEWLINE) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mSTR) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mESCAPED) (struct DAAPLexer_Ctx_struct * ctx);
+ void (*mTokens) (struct DAAPLexer_Ctx_struct * ctx); const char * (*getGrammarFileName)();
+ void (*free) (struct DAAPLexer_Ctx_struct * ctx);
+
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pDAAPLexer DAAPLexerNew (pANTLR3_INPUT_STREAM instream);
+ANTLR3_API pDAAPLexer DAAPLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the lexer will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define STR 9
+#define QUOTE 10
+#define NEWLINE 4
+#define LPAR 7
+#define OPOR 5
+#define RPAR 8
+#define ESCAPED 11
+#define OPAND 6
+#define EOF -1
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for DAAPLexer
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/DAAPParser.c b/src/pregen/DAAPParser.c
new file mode 100644
index 0000000..1091f05
--- /dev/null
+++ b/src/pregen/DAAPParser.c
@@ -0,0 +1,1014 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP.g
+ * - On : 2016-01-01 12:23:41
+ * - for the parser : DAAPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "DAAPParser.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pDAAPParser_##scope##_SCOPE
+#define SCOPE_STACK(scope) pDAAPParser_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pDAAPParser_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pDAAPParser_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+/* Macros for accessing things in the parser
+ */
+
+#undef PARSER
+#undef RECOGNIZER
+#undef HAVEPARSEDRULE
+#undef MEMOIZE
+#undef INPUT
+#undef STRSTREAM
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef MATCHT
+#undef MATCHANYT
+#undef FOLLOWSTACK
+#undef FOLLOWPUSH
+#undef FOLLOWPOP
+#undef PRECOVER
+#undef PREPORTERROR
+#undef LA
+#undef LT
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef PERRORRECOVERY
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef RECOVERFROMMISMATCHEDSET
+#undef RECOVERFROMMISMATCHEDELEMENT
+#undef INDEX
+#undef ADAPTOR
+#undef SEEK
+#undef RULEMEMO
+#undef DBG
+
+#define PARSER ctx->pParser
+#define RECOGNIZER PARSER->rec
+#define PSRSTATE RECOGNIZER->state
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
+#define INPUT PARSER->tstream
+#define STRSTREAM INPUT
+#define ISTREAM INPUT->istream
+#define INDEX() ISTREAM->index(INPUT->istream)
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION PSRSTATE->exception
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
+#define FOLLOWSTACK PSRSTATE->following
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
+#define LA(n) INPUT->istream->_LA(ISTREAM, n)
+#define LT(n) INPUT->_LT(INPUT, n)
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define CONSUME() ISTREAM->consume(ISTREAM)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define PERRORRECOVERY PSRSTATE->errorRecovery
+#define FAILEDFLAG PSRSTATE->failed
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
+#define BACKTRACKING PSRSTATE->backtracking
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
+#define ADAPTOR ctx->adaptor
+#define RULEMEMO PSRSTATE->ruleMemo
+#define DBG RECOGNIZER->debugger
+
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+
+/** \brief Table of all token names in symbolic order, mainly used for
+ * error reporting.
+ */
+pANTLR3_UINT8 DAAPParserTokenNames[8+4]
+ = {
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
+ (pANTLR3_UINT8) "<EOR>",
+ (pANTLR3_UINT8) "<DOWN>",
+ (pANTLR3_UINT8) "<UP>",
+ (pANTLR3_UINT8) "NEWLINE",
+ (pANTLR3_UINT8) "OPOR",
+ (pANTLR3_UINT8) "OPAND",
+ (pANTLR3_UINT8) "LPAR",
+ (pANTLR3_UINT8) "RPAR",
+ (pANTLR3_UINT8) "STR",
+ (pANTLR3_UINT8) "QUOTE",
+ (pANTLR3_UINT8) "ESCAPED"
+ };
+
+
+
+// Forward declare the locally static matching functions we have generated.
+//
+static DAAPParser_query_return query (pDAAPParser ctx);
+static DAAPParser_expr_return expr (pDAAPParser ctx);
+static DAAPParser_aexpr_return aexpr (pDAAPParser ctx);
+static DAAPParser_crit_return crit (pDAAPParser ctx);
+static void DAAPParserFree(pDAAPParser ctx);
+/* For use in tree output where we are accumulating rule labels via label += ruleRef
+ * we need a function that knows how to free a return scope when the list is destroyed.
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
+ */
+static void ANTLR3_CDECL freeScope(void * scope)
+{
+ ANTLR3_FREE(scope);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "DAAP.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+/** \brief Create a new DAAPParser parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pDAAPParser
+DAAPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
+{
+ // See if we can create a new parser with the standard constructor
+ //
+ return DAAPParserNewSSD(instream, NULL);
+}
+
+/** \brief Create a new DAAPParser parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pDAAPParser
+DAAPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pDAAPParser ctx; /* Context structure we will build and return */
+
+ ctx = (pDAAPParser) ANTLR3_CALLOC(1, sizeof(DAAPParser));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for parser context
+ //
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * the base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 parser function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in DAAPParser.h here, in order that you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base parser/recognizer, using the supplied token stream
+ */
+ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
+ /* Install the implementation of our DAAPParser interface
+ */
+ ctx->query = query;
+ ctx->expr = expr;
+ ctx->aexpr = aexpr;
+ ctx->crit = crit;
+ ctx->free = DAAPParserFree;
+ ctx->getGrammarFileName = getGrammarFileName;
+
+ /* Install the scope pushing methods.
+ */
+ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
+ ctx->vectors = antlr3VectorFactoryNew(0);
+
+
+
+ /* Install the token table
+ */
+ PSRSTATE->tokenNames = DAAPParserTokenNames;
+
+
+ /* Return the newly built parser to the caller
+ */
+ return ctx;
+}
+
+/** Free the parser resources
+ */
+ static void
+ DAAPParserFree(pDAAPParser ctx)
+ {
+ /* Free any scope memory
+ */
+
+ ctx->vectors->close(ctx->vectors);
+ /* We created the adaptor so we must free it
+ */
+ ADAPTOR->free(ADAPTOR);
+ // Free this parser
+ //
+ ctx->pParser->free(ctx->pParser);
+ ANTLR3_FREE(ctx);
+
+ /* Everything is released, so we can return
+ */
+ return;
+ }
+
+/** Return token names used by this parser
+ *
+ * The returned pointer is used as an index into the token names table (using the token
+ * number as the index).
+ *
+ * \return Pointer to first char * in the table.
+ */
+static pANTLR3_UINT8 *getTokenNames()
+{
+ return DAAPParserTokenNames;
+}
+
+
+/* Declare the bitsets
+ */
+
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query42 */
+static ANTLR3_BITWORD FOLLOW_expr_in_query42_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_query42 = { FOLLOW_expr_in_query42_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_query44 */
+static ANTLR3_BITWORD FOLLOW_NEWLINE_in_query44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) };
+static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_query44 = { FOLLOW_NEWLINE_in_query44_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_query47 */
+static ANTLR3_BITWORD FOLLOW_EOF_in_query47_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EOF_in_query47 = { FOLLOW_EOF_in_query47_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr62 */
+static ANTLR3_BITWORD FOLLOW_aexpr_in_expr62_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
+static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr62 = { FOLLOW_aexpr_in_expr62_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPOR_in_expr65 */
+static ANTLR3_BITWORD FOLLOW_OPOR_in_expr65_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
+static ANTLR3_BITSET_LIST FOLLOW_OPOR_in_expr65 = { FOLLOW_OPOR_in_expr65_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr68 */
+static ANTLR3_BITWORD FOLLOW_aexpr_in_expr68_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
+static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr68 = { FOLLOW_aexpr_in_expr68_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr80 */
+static ANTLR3_BITWORD FOLLOW_crit_in_aexpr80_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
+static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr80 = { FOLLOW_crit_in_aexpr80_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPAND_in_aexpr83 */
+static ANTLR3_BITWORD FOLLOW_OPAND_in_aexpr83_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
+static ANTLR3_BITSET_LIST FOLLOW_OPAND_in_aexpr83 = { FOLLOW_OPAND_in_aexpr83_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr86 */
+static ANTLR3_BITWORD FOLLOW_crit_in_aexpr86_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
+static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr86 = { FOLLOW_crit_in_aexpr86_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit98 */
+static ANTLR3_BITWORD FOLLOW_LPAR_in_crit98_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
+static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit98 = { FOLLOW_LPAR_in_crit98_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_crit100 */
+static ANTLR3_BITWORD FOLLOW_expr_in_crit100_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000100) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_crit100 = { FOLLOW_expr_in_crit100_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit102 */
+static ANTLR3_BITWORD FOLLOW_RPAR_in_crit102_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit102 = { FOLLOW_RPAR_in_crit102_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_crit112 */
+static ANTLR3_BITWORD FOLLOW_STR_in_crit112_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_crit112 = { FOLLOW_STR_in_crit112_bits, 1 };
+
+
+
+
+/* ==============================================
+ * Parsing rules
+ */
+/**
+ * $ANTLR start query
+ * DAAP.g:27:1: query : expr ( NEWLINE )? EOF -> expr ;
+ */
+static DAAPParser_query_return
+query(pDAAPParser ctx)
+{
+ DAAPParser_query_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN NEWLINE2;
+ pANTLR3_COMMON_TOKEN EOF3;
+ DAAPParser_expr_return expr1;
+ #undef RETURN_TYPE_expr1
+ #define RETURN_TYPE_expr1 DAAPParser_expr_return
+
+ pANTLR3_BASE_TREE NEWLINE2_tree;
+ pANTLR3_BASE_TREE EOF3_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NEWLINE;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_EOF;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ NEWLINE2 = NULL;
+ EOF3 = NULL;
+ expr1.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ NEWLINE2_tree = NULL;
+ EOF3_tree = NULL;
+
+ stream_NEWLINE = NULL;
+ #define CREATE_stream_NEWLINE if (stream_NEWLINE == NULL) {stream_NEWLINE = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NEWLINE"); }
+ stream_EOF = NULL;
+ #define CREATE_stream_EOF if (stream_EOF == NULL) {stream_EOF = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token EOF"); }
+ stream_expr = NULL;
+ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
+
+ retval.tree = NULL;
+ {
+ // DAAP.g:27:7: ( expr ( NEWLINE )? EOF -> expr )
+ // DAAP.g:27:9: expr ( NEWLINE )? EOF
+ {
+ FOLLOWPUSH(FOLLOW_expr_in_query42);
+ expr1=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ CREATE_stream_expr; stream_expr->add(stream_expr, expr1.tree, NULL);
+
+ // DAAP.g:27:14: ( NEWLINE )?
+ {
+ int alt1=2;
+ switch ( LA(1) )
+ {
+ case NEWLINE:
+ {
+ alt1=1;
+ }
+ break;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // DAAP.g:27:14: NEWLINE
+ {
+ NEWLINE2 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_query44);
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ CREATE_stream_NEWLINE; stream_NEWLINE->add(stream_NEWLINE, NEWLINE2, NULL);
+
+
+ }
+ break;
+
+ }
+ }
+ EOF3 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_query47);
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ CREATE_stream_EOF; stream_EOF->add(stream_EOF, EOF3, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : expr
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 27:27: -> expr
+ {
+ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulequeryEx; /* Prevent compiler warnings */
+ rulequeryEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_NEWLINE != NULL) stream_NEWLINE->free(stream_NEWLINE);
+ if (stream_EOF != NULL) stream_EOF->free(stream_EOF);
+ if (stream_expr != NULL) stream_expr->free(stream_expr);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end query */
+
+/**
+ * $ANTLR start expr
+ * DAAP.g:30:1: expr : aexpr ( OPOR aexpr )* ;
+ */
+static DAAPParser_expr_return
+expr(pDAAPParser ctx)
+{
+ DAAPParser_expr_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN OPOR5;
+ DAAPParser_aexpr_return aexpr4;
+ #undef RETURN_TYPE_aexpr4
+ #define RETURN_TYPE_aexpr4 DAAPParser_aexpr_return
+
+ DAAPParser_aexpr_return aexpr6;
+ #undef RETURN_TYPE_aexpr6
+ #define RETURN_TYPE_aexpr6 DAAPParser_aexpr_return
+
+ pANTLR3_BASE_TREE OPOR5_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ OPOR5 = NULL;
+ aexpr4.tree = NULL;
+
+ aexpr6.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ OPOR5_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // DAAP.g:30:6: ( aexpr ( OPOR aexpr )* )
+ // DAAP.g:30:8: aexpr ( OPOR aexpr )*
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_aexpr_in_expr62);
+ aexpr4=aexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, aexpr4.tree);
+
+ // DAAP.g:30:14: ( OPOR aexpr )*
+
+ for (;;)
+ {
+ int alt2=2;
+ switch ( LA(1) )
+ {
+ case OPOR:
+ {
+ alt2=1;
+ }
+ break;
+
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // DAAP.g:30:15: OPOR aexpr
+ {
+ OPOR5 = (pANTLR3_COMMON_TOKEN) MATCHT(OPOR, &FOLLOW_OPOR_in_expr65);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ OPOR5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OPOR5));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OPOR5_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_aexpr_in_expr68);
+ aexpr6=aexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree);
+
+ }
+ break;
+
+ default:
+ goto loop2; /* break out of the loop */
+ break;
+ }
+ }
+ loop2: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleexprEx; /* Prevent compiler warnings */
+ ruleexprEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end expr */
+
+/**
+ * $ANTLR start aexpr
+ * DAAP.g:33:1: aexpr : crit ( OPAND crit )* ;
+ */
+static DAAPParser_aexpr_return
+aexpr(pDAAPParser ctx)
+{
+ DAAPParser_aexpr_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN OPAND8;
+ DAAPParser_crit_return crit7;
+ #undef RETURN_TYPE_crit7
+ #define RETURN_TYPE_crit7 DAAPParser_crit_return
+
+ DAAPParser_crit_return crit9;
+ #undef RETURN_TYPE_crit9
+ #define RETURN_TYPE_crit9 DAAPParser_crit_return
+
+ pANTLR3_BASE_TREE OPAND8_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ OPAND8 = NULL;
+ crit7.tree = NULL;
+
+ crit9.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ OPAND8_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // DAAP.g:33:7: ( crit ( OPAND crit )* )
+ // DAAP.g:33:9: crit ( OPAND crit )*
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_crit_in_aexpr80);
+ crit7=crit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, crit7.tree);
+
+ // DAAP.g:33:14: ( OPAND crit )*
+
+ for (;;)
+ {
+ int alt3=2;
+ switch ( LA(1) )
+ {
+ case OPAND:
+ {
+ alt3=1;
+ }
+ break;
+
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // DAAP.g:33:15: OPAND crit
+ {
+ OPAND8 = (pANTLR3_COMMON_TOKEN) MATCHT(OPAND, &FOLLOW_OPAND_in_aexpr83);
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ OPAND8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OPAND8));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OPAND8_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_crit_in_aexpr86);
+ crit9=crit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, crit9.tree);
+
+ }
+ break;
+
+ default:
+ goto loop3; /* break out of the loop */
+ break;
+ }
+ }
+ loop3: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleaexprEx; /* Prevent compiler warnings */
+ ruleaexprEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end aexpr */
+
+/**
+ * $ANTLR start crit
+ * DAAP.g:36:1: crit : ( LPAR expr RPAR -> expr | STR );
+ */
+static DAAPParser_crit_return
+crit(pDAAPParser ctx)
+{
+ DAAPParser_crit_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN LPAR10;
+ pANTLR3_COMMON_TOKEN RPAR12;
+ pANTLR3_COMMON_TOKEN STR13;
+ DAAPParser_expr_return expr11;
+ #undef RETURN_TYPE_expr11
+ #define RETURN_TYPE_expr11 DAAPParser_expr_return
+
+ pANTLR3_BASE_TREE LPAR10_tree;
+ pANTLR3_BASE_TREE RPAR12_tree;
+ pANTLR3_BASE_TREE STR13_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ LPAR10 = NULL;
+ RPAR12 = NULL;
+ STR13 = NULL;
+ expr11.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ LPAR10_tree = NULL;
+ RPAR12_tree = NULL;
+ STR13_tree = NULL;
+
+ stream_RPAR = NULL;
+ #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); }
+ stream_LPAR = NULL;
+ #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); }
+ stream_expr = NULL;
+ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
+
+ retval.tree = NULL;
+ {
+ {
+ // DAAP.g:36:6: ( LPAR expr RPAR -> expr | STR )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=2;
+
+ switch ( LA(1) )
+ {
+ case LPAR:
+ {
+ alt4=1;
+ }
+ break;
+ case STR:
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto rulecritEx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // DAAP.g:36:8: LPAR expr RPAR
+ {
+ LPAR10 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit98);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR10, NULL);
+
+ FOLLOWPUSH(FOLLOW_expr_in_crit100);
+ expr11=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_expr; stream_expr->add(stream_expr, expr11.tree, NULL);
+ RPAR12 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit102);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR12, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : expr
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 36:24: -> expr
+ {
+ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+ case 2:
+ // DAAP.g:37:4: STR
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ STR13 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_crit112);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ STR13_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STR13));
+ ADAPTOR->addChild(ADAPTOR, root_0, STR13_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulecritEx; /* Prevent compiler warnings */
+ rulecritEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR);
+ if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR);
+ if (stream_expr != NULL) stream_expr->free(stream_expr);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end crit */
+/* End of parsing rules
+ * ==============================================
+ */
+
+/* ==============================================
+ * Syntactic predicates
+ */
+/* End of syntactic predicates
+ * ==============================================
+ */
+
+
+
+
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/DAAPParser.h b/src/pregen/DAAPParser.h
new file mode 100644
index 0000000..e206694
--- /dev/null
+++ b/src/pregen/DAAPParser.h
@@ -0,0 +1,226 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP.g
+ * - On : 2016-01-01 12:23:41
+ * - for the parser : DAAPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The parser DAAPParser has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pDAAPParser, which is returned from a call to DAAPParserNew().
+ *
+ * The methods in pDAAPParser are as follows:
+ *
+ * - DAAPParser_query_return pDAAPParser->query(pDAAPParser)
+ * - DAAPParser_expr_return pDAAPParser->expr(pDAAPParser)
+ * - DAAPParser_aexpr_return pDAAPParser->aexpr(pDAAPParser)
+ * - DAAPParser_crit_return pDAAPParser->crit(pDAAPParser)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _DAAPParser_H
+#define _DAAPParser_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct DAAPParser_Ctx_struct DAAPParser, * pDAAPParser;
+
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+typedef struct DAAPParser_query_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ DAAPParser_query_return;
+
+typedef struct DAAPParser_expr_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ DAAPParser_expr_return;
+
+typedef struct DAAPParser_aexpr_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ DAAPParser_aexpr_return;
+
+typedef struct DAAPParser_crit_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ DAAPParser_crit_return;
+
+
+
+/** Context tracking structure for DAAPParser
+ */
+struct DAAPParser_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_PARSER pParser;
+
+
+ DAAPParser_query_return (*query) (struct DAAPParser_Ctx_struct * ctx);
+ DAAPParser_expr_return (*expr) (struct DAAPParser_Ctx_struct * ctx);
+ DAAPParser_aexpr_return (*aexpr) (struct DAAPParser_Ctx_struct * ctx);
+ DAAPParser_crit_return (*crit) (struct DAAPParser_Ctx_struct * ctx);
+ // Delegated rules
+ const char * (*getGrammarFileName)();
+ void (*free) (struct DAAPParser_Ctx_struct * ctx);
+ /* @headerFile.members() */
+ pANTLR3_BASE_TREE_ADAPTOR adaptor;
+ pANTLR3_VECTOR_FACTORY vectors;
+ /* End @headerFile.members() */
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pDAAPParser DAAPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream);
+ANTLR3_API pDAAPParser DAAPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the parser will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define STR 9
+#define QUOTE 10
+#define LPAR 7
+#define NEWLINE 4
+#define OPOR 5
+#define RPAR 8
+#define ESCAPED 11
+#define OPAND 6
+#define EOF -1
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for DAAPParser
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/RSP.u b/src/pregen/RSP.u
new file mode 100644
index 0000000..89256ff
--- /dev/null
+++ b/src/pregen/RSP.u
@@ -0,0 +1,6 @@
+RSPParser.c : RSP.g
+./RSP.tokens : RSP.g
+RSPParser.h : RSP.g
+RSPLexer.c : RSP.g
+RSPLexer.h : RSP.g
+ANTLR_PRODUCTS += RSPParser.c ./RSP.tokens RSPParser.h RSPLexer.c RSPLexer.h
\ No newline at end of file
diff --git a/src/pregen/RSP2SQL.c b/src/pregen/RSP2SQL.c
new file mode 100644
index 0000000..40958f9
--- /dev/null
+++ b/src/pregen/RSP2SQL.c
@@ -0,0 +1,2546 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : RSP2SQL.g
+ * - On : 2016-01-01 12:23:43
+ * - for the tree parser : RSP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+/* =============================================================================
+ * This is what the grammar programmer asked us to put at the top of every file.
+ */
+
+ /* Needs #define _GNU_SOURCE for strptime() */
+
+ #include <stdio.h>
+ #include <string.h>
+ #include <time.h>
+ #include <stdint.h>
+
+ #include "logger.h"
+ #include "db.h"
+ #include "misc.h"
+ #include "rsp_query.h"
+
+/* End of Header action.
+ * =============================================================================
+ */
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "RSP2SQL.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pRSP2SQL_##scope##_SCOPE
+#define SCOPE_STACK(scope) pRSP2SQL_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pRSP2SQL_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pRSP2SQL_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+/* Macros for accessing things in the parser
+ */
+
+#undef PARSER
+#undef RECOGNIZER
+#undef HAVEPARSEDRULE
+#undef INPUT
+#undef STRSTREAM
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef MATCHT
+#undef MATCHANYT
+#undef FOLLOWSTACK
+#undef FOLLOWPUSH
+#undef FOLLOWPOP
+#undef PRECOVER
+#undef PREPORTERROR
+#undef LA
+#undef LT
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef PERRORRECOVERY
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef RECOVERFROMMISMATCHEDSET
+#undef RECOVERFROMMISMATCHEDELEMENT
+#undef BACKTRACKING
+#undef ADAPTOR
+#undef RULEMEMO
+#undef SEEK
+#undef INDEX
+#undef DBG
+
+#define PARSER ctx->pTreeParser
+#define RECOGNIZER PARSER->rec
+#define PSRSTATE RECOGNIZER->state
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define INPUT PARSER->ctnstream
+#define ISTREAM INPUT->tnstream->istream
+#define STRSTREAM INPUT->tnstream
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION PSRSTATE->exception
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
+#define FOLLOWSTACK PSRSTATE->following
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
+#define LA(n) ISTREAM->_LA(ISTREAM, n)
+#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define CONSUME() ISTREAM->consume(ISTREAM)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define PERRORRECOVERY PSRSTATE->errorRecovery
+#define FAILEDFLAG PSRSTATE->failed
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
+#define BACKTRACKING PSRSTATE->backtracking
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
+#define ADAPTOR INPUT->adaptor
+#define RULEMEMO PSRSTATE->ruleMemo
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define INDEX() ISTREAM->index(ISTREAM)
+#define DBG RECOGNIZER->debugger
+
+
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+
+/** \brief Table of all token names in symbolic order, mainly used for
+ * error reporting.
+ */
+pANTLR3_UINT8 RSP2SQLTokenNames[30+4]
+ = {
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
+ (pANTLR3_UINT8) "<EOR>",
+ (pANTLR3_UINT8) "<DOWN>",
+ (pANTLR3_UINT8) "<UP>",
+ (pANTLR3_UINT8) "NEWLINE",
+ (pANTLR3_UINT8) "OR",
+ (pANTLR3_UINT8) "AND",
+ (pANTLR3_UINT8) "LPAR",
+ (pANTLR3_UINT8) "RPAR",
+ (pANTLR3_UINT8) "FIELD",
+ (pANTLR3_UINT8) "STR",
+ (pANTLR3_UINT8) "NOT",
+ (pANTLR3_UINT8) "EQUAL",
+ (pANTLR3_UINT8) "INCLUDES",
+ (pANTLR3_UINT8) "STARTSW",
+ (pANTLR3_UINT8) "ENDSW",
+ (pANTLR3_UINT8) "INT",
+ (pANTLR3_UINT8) "LESS",
+ (pANTLR3_UINT8) "GREATER",
+ (pANTLR3_UINT8) "LTE",
+ (pANTLR3_UINT8) "GTE",
+ (pANTLR3_UINT8) "BEFORE",
+ (pANTLR3_UINT8) "AFTER",
+ (pANTLR3_UINT8) "DATE",
+ (pANTLR3_UINT8) "TODAY",
+ (pANTLR3_UINT8) "DAY",
+ (pANTLR3_UINT8) "WEEK",
+ (pANTLR3_UINT8) "MONTH",
+ (pANTLR3_UINT8) "YEAR",
+ (pANTLR3_UINT8) "QUOTE",
+ (pANTLR3_UINT8) "WS",
+ (pANTLR3_UINT8) "DIGIT19",
+ (pANTLR3_UINT8) "DIGIT09",
+ (pANTLR3_UINT8) "ESCAPED"
+ };
+
+
+
+// Forward declare the locally static matching functions we have generated.
+//
+static pANTLR3_STRING query (pRSP2SQL ctx);
+static RSP2SQL_expr_return expr (pRSP2SQL ctx);
+static RSP2SQL_strcrit_return strcrit (pRSP2SQL ctx);
+static pANTLR3_COMMON_TOKEN strop (pRSP2SQL ctx);
+static RSP2SQL_intcrit_return intcrit (pRSP2SQL ctx);
+static pANTLR3_COMMON_TOKEN intop (pRSP2SQL ctx);
+static RSP2SQL_datecrit_return datecrit (pRSP2SQL ctx);
+static pANTLR3_COMMON_TOKEN dateop (pRSP2SQL ctx);
+static RSP2SQL_datespec_return datespec (pRSP2SQL ctx);
+static RSP2SQL_dateref_return dateref (pRSP2SQL ctx);
+static RSP2SQL_dateintval_return dateintval (pRSP2SQL ctx);
+static void RSP2SQLFree(pRSP2SQL ctx);
+/* For use in tree output where we are accumulating rule labels via label += ruleRef
+ * we need a function that knows how to free a return scope when the list is destroyed.
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
+ */
+static void ANTLR3_CDECL freeScope(void * scope)
+{
+ ANTLR3_FREE(scope);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "RSP2SQL.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+/** \brief Create a new RSP2SQL parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pRSP2SQL
+RSP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
+{
+ // See if we can create a new parser with the standard constructor
+ //
+ return RSP2SQLNewSSD(instream, NULL);
+}
+
+/** \brief Create a new RSP2SQL parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pRSP2SQL
+RSP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pRSP2SQL ctx; /* Context structure we will build and return */
+
+ ctx = (pRSP2SQL) ANTLR3_CALLOC(1, sizeof(RSP2SQL));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for parser context
+ //
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * the base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 parser function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in RSP2SQL.h here, in order that you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base Tree parser/recognizer, using the supplied tree node stream
+ */
+ ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
+ /* Install the implementation of our RSP2SQL interface
+ */
+ ctx->query = query;
+ ctx->expr = expr;
+ ctx->strcrit = strcrit;
+ ctx->strop = strop;
+ ctx->intcrit = intcrit;
+ ctx->intop = intop;
+ ctx->datecrit = datecrit;
+ ctx->dateop = dateop;
+ ctx->datespec = datespec;
+ ctx->dateref = dateref;
+ ctx->dateintval = dateintval;
+ ctx->free = RSP2SQLFree;
+ ctx->getGrammarFileName = getGrammarFileName;
+
+ /* Install the scope pushing methods.
+ */
+
+
+
+
+
+ /* Install the token table
+ */
+ PSRSTATE->tokenNames = RSP2SQLTokenNames;
+
+
+ /* Return the newly built parser to the caller
+ */
+ return ctx;
+}
+
+/** Free the parser resources
+ */
+ static void
+ RSP2SQLFree(pRSP2SQL ctx)
+ {
+ /* Free any scope memory
+ */
+
+
+ // Free this parser
+ //
+ ctx->pTreeParser->free(ctx->pTreeParser);
+ ANTLR3_FREE(ctx);
+
+ /* Everything is released, so we can return
+ */
+ return;
+ }
+
+/** Return token names used by this tree parser
+ *
+ * The returned pointer is used as an index into the token names table (using the token
+ * number as the index).
+ *
+ * \return Pointer to first char * in the table.
+ */
+static pANTLR3_UINT8 *getTokenNames()
+{
+ return RSP2SQLTokenNames;
+}
+
+
+ #define RSP_TYPE_STRING 0
+ #define RSP_TYPE_INT 1
+ #define RSP_TYPE_DATE 2
+
+ struct rsp_query_field_map {
+ char *rsp_field;
+ int field_type;
+ /* RSP fields are named after the DB columns - or vice versa */
+ };
+
+ /* gperf static hash, rsp_query.gperf */
+ #include "rsp_query_hash.c"
+
+
+/* Declare the bitsets
+ */
+
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query70 */
+static ANTLR3_BITWORD FOLLOW_expr_in_query70_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_query70 = { FOLLOW_expr_in_query70_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_expr95 */
+static ANTLR3_BITWORD FOLLOW_AND_in_expr95_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_AND_in_expr95 = { FOLLOW_AND_in_expr95_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr101 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr101_bits[] = { ANTLR3_UINT64_LIT(0x00000000007EF860) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr101 = { FOLLOW_expr_in_expr101_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr107 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr107 = { FOLLOW_expr_in_expr107_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expr118 */
+static ANTLR3_BITWORD FOLLOW_OR_in_expr118_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_OR_in_expr118 = { FOLLOW_OR_in_expr118_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr124 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr124_bits[] = { ANTLR3_UINT64_LIT(0x00000000007EF860) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr124 = { FOLLOW_expr_in_expr124_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr130 */
+static ANTLR3_BITWORD FOLLOW_expr_in_expr130_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr130 = { FOLLOW_expr_in_expr130_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_expr144 */
+static ANTLR3_BITWORD FOLLOW_strcrit_in_expr144_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_expr144 = { FOLLOW_strcrit_in_expr144_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_expr154 */
+static ANTLR3_BITWORD FOLLOW_NOT_in_expr154_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_NOT_in_expr154 = { FOLLOW_NOT_in_expr154_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_expr160 */
+static ANTLR3_BITWORD FOLLOW_strcrit_in_expr160_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_expr160 = { FOLLOW_strcrit_in_expr160_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_expr174 */
+static ANTLR3_BITWORD FOLLOW_intcrit_in_expr174_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_expr174 = { FOLLOW_intcrit_in_expr174_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_expr184 */
+static ANTLR3_BITWORD FOLLOW_NOT_in_expr184_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_NOT_in_expr184 = { FOLLOW_NOT_in_expr184_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_expr190 */
+static ANTLR3_BITWORD FOLLOW_intcrit_in_expr190_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_expr190 = { FOLLOW_intcrit_in_expr190_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_datecrit_in_expr204 */
+static ANTLR3_BITWORD FOLLOW_datecrit_in_expr204_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_datecrit_in_expr204 = { FOLLOW_datecrit_in_expr204_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit233 */
+static ANTLR3_BITWORD FOLLOW_strop_in_strcrit233_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit233 = { FOLLOW_strop_in_strcrit233_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit239 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit239_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit239 = { FOLLOW_FIELD_in_strcrit239_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit245 */
+static ANTLR3_BITWORD FOLLOW_STR_in_strcrit245_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit245 = { FOLLOW_STR_in_strcrit245_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_strop274 */
+static ANTLR3_BITWORD FOLLOW_EQUAL_in_strop274_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_strop274 = { FOLLOW_EQUAL_in_strop274_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INCLUDES_in_strop287 */
+static ANTLR3_BITWORD FOLLOW_INCLUDES_in_strop287_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_INCLUDES_in_strop287 = { FOLLOW_INCLUDES_in_strop287_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STARTSW_in_strop300 */
+static ANTLR3_BITWORD FOLLOW_STARTSW_in_strop300_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STARTSW_in_strop300 = { FOLLOW_STARTSW_in_strop300_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENDSW_in_strop313 */
+static ANTLR3_BITWORD FOLLOW_ENDSW_in_strop313_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_ENDSW_in_strop313 = { FOLLOW_ENDSW_in_strop313_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit342 */
+static ANTLR3_BITWORD FOLLOW_intop_in_intcrit342_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit342 = { FOLLOW_intop_in_intcrit342_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit348 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit348_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit348 = { FOLLOW_FIELD_in_intcrit348_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit354 */
+static ANTLR3_BITWORD FOLLOW_INT_in_intcrit354_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit354 = { FOLLOW_INT_in_intcrit354_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_intop383 */
+static ANTLR3_BITWORD FOLLOW_EQUAL_in_intop383_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_intop383 = { FOLLOW_EQUAL_in_intop383_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LESS_in_intop396 */
+static ANTLR3_BITWORD FOLLOW_LESS_in_intop396_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_LESS_in_intop396 = { FOLLOW_LESS_in_intop396_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_in_intop409 */
+static ANTLR3_BITWORD FOLLOW_GREATER_in_intop409_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_GREATER_in_intop409 = { FOLLOW_GREATER_in_intop409_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LTE_in_intop422 */
+static ANTLR3_BITWORD FOLLOW_LTE_in_intop422_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_LTE_in_intop422 = { FOLLOW_LTE_in_intop422_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_GTE_in_intop435 */
+static ANTLR3_BITWORD FOLLOW_GTE_in_intop435_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_GTE_in_intop435 = { FOLLOW_GTE_in_intop435_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit464 */
+static ANTLR3_BITWORD FOLLOW_dateop_in_datecrit464_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit464 = { FOLLOW_dateop_in_datecrit464_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit470 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit470_bits[] = { ANTLR3_UINT64_LIT(0x0000000001FEF860) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit470 = { FOLLOW_FIELD_in_datecrit470_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit476 */
+static ANTLR3_BITWORD FOLLOW_datespec_in_datecrit476_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit476 = { FOLLOW_datespec_in_datecrit476_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateop505 */
+static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateop505_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateop505 = { FOLLOW_BEFORE_in_dateop505_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateop518 */
+static ANTLR3_BITWORD FOLLOW_AFTER_in_dateop518_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateop518 = { FOLLOW_AFTER_in_dateop518_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec546 */
+static ANTLR3_BITWORD FOLLOW_dateref_in_datespec546_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec546 = { FOLLOW_dateref_in_datespec546_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec560 */
+static ANTLR3_BITWORD FOLLOW_dateop_in_datespec560_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec560 = { FOLLOW_dateop_in_datespec560_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec566 */
+static ANTLR3_BITWORD FOLLOW_dateref_in_datespec566_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
+static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec566 = { FOLLOW_dateref_in_datespec566_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec572 */
+static ANTLR3_BITWORD FOLLOW_INT_in_datespec572_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec572 = { FOLLOW_INT_in_datespec572_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec578 */
+static ANTLR3_BITWORD FOLLOW_dateintval_in_datespec578_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec578 = { FOLLOW_dateintval_in_datespec578_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateref607 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateref607_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateref607 = { FOLLOW_DATE_in_dateref607_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_TODAY_in_dateref616 */
+static ANTLR3_BITWORD FOLLOW_TODAY_in_dateref616_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_TODAY_in_dateref616 = { FOLLOW_TODAY_in_dateref616_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DAY_in_dateintval640 */
+static ANTLR3_BITWORD FOLLOW_DAY_in_dateintval640_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DAY_in_dateintval640 = { FOLLOW_DAY_in_dateintval640_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_WEEK_in_dateintval649 */
+static ANTLR3_BITWORD FOLLOW_WEEK_in_dateintval649_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_WEEK_in_dateintval649 = { FOLLOW_WEEK_in_dateintval649_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_MONTH_in_dateintval658 */
+static ANTLR3_BITWORD FOLLOW_MONTH_in_dateintval658_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_MONTH_in_dateintval658 = { FOLLOW_MONTH_in_dateintval658_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_YEAR_in_dateintval667 */
+static ANTLR3_BITWORD FOLLOW_YEAR_in_dateintval667_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_YEAR_in_dateintval667 = { FOLLOW_YEAR_in_dateintval667_bits, 1 };
+
+
+
+
+/* ==============================================
+ * Parsing rules
+ */
+/**
+ * $ANTLR start query
+ * RSP2SQL.g:56:1: query returns [ pANTLR3_STRING result ] : e= expr ;
+ */
+static pANTLR3_STRING
+query(pRSP2SQL ctx)
+{
+ pANTLR3_STRING result = NULL;
+
+ RSP2SQL_expr_return e;
+ #undef RETURN_TYPE_e
+ #define RETURN_TYPE_e RSP2SQL_expr_return
+
+ /* Initialize rule variables
+ */
+
+
+ result= NULL;
+ {
+ // RSP2SQL.g:58:2: (e= expr )
+ // RSP2SQL.g:58:4: e= expr
+ {
+ FOLLOWPUSH(FOLLOW_expr_in_query70);
+ e=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ {
+
+ if (!e.valid)
+ {
+ result= NULL;
+ }
+ else
+ {
+ result= e.result->factory->newRaw(e.result->factory);
+ result->append8(result, "(");
+ result->appendS(result, e.result);
+ result->append8(result, ")");
+ }
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulequeryEx; /* Prevent compiler warnings */
+ rulequeryEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return result;
+}
+/* $ANTLR end query */
+
+/**
+ * $ANTLR start expr
+ * RSP2SQL.g:74:1: expr returns [ pANTLR3_STRING result, int valid ] : ( ^( AND a= expr b= expr ) | ^( OR a= expr b= expr ) | c= strcrit | ^( NOT c= strcrit ) | i= intcrit | ^( NOT i= intcrit ) | d= datecrit );
+ */
+static RSP2SQL_expr_return
+expr(pRSP2SQL ctx)
+{
+ RSP2SQL_expr_return retval;
+
+ RSP2SQL_expr_return a;
+ #undef RETURN_TYPE_a
+ #define RETURN_TYPE_a RSP2SQL_expr_return
+
+ RSP2SQL_expr_return b;
+ #undef RETURN_TYPE_b
+ #define RETURN_TYPE_b RSP2SQL_expr_return
+
+ RSP2SQL_strcrit_return c;
+ #undef RETURN_TYPE_c
+ #define RETURN_TYPE_c RSP2SQL_strcrit_return
+
+ RSP2SQL_intcrit_return i;
+ #undef RETURN_TYPE_i
+ #define RETURN_TYPE_i RSP2SQL_intcrit_return
+
+ RSP2SQL_datecrit_return d;
+ #undef RETURN_TYPE_d
+ #define RETURN_TYPE_d RSP2SQL_datecrit_return
+
+ /* Initialize rule variables
+ */
+
+
+ retval.result= NULL; retval.valid= 1;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ {
+ // RSP2SQL.g:76:2: ( ^( AND a= expr b= expr ) | ^( OR a= expr b= expr ) | c= strcrit | ^( NOT c= strcrit ) | i= intcrit | ^( NOT i= intcrit ) | d= datecrit )
+
+ ANTLR3_UINT32 alt1;
+
+ alt1=7;
+
+ switch ( LA(1) )
+ {
+ case AND:
+ {
+ alt1=1;
+ }
+ break;
+ case OR:
+ {
+ alt1=2;
+ }
+ break;
+ case EQUAL:
+ {
+ switch ( LA(2) )
+ {
+ case DOWN:
+ {
+ switch ( LA(3) )
+ {
+ case FIELD:
+ {
+ switch ( LA(4) )
+ {
+ case INT:
+ {
+ alt1=5;
+ }
+ break;
+ case STR:
+ {
+ alt1=3;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 10;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 8;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 3;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+ case INCLUDES:
+ case STARTSW:
+ case ENDSW:
+ {
+ alt1=3;
+ }
+ break;
+ case NOT:
+ {
+ switch ( LA(2) )
+ {
+ case DOWN:
+ {
+ switch ( LA(3) )
+ {
+ case EQUAL:
+ {
+ switch ( LA(4) )
+ {
+ case DOWN:
+ {
+ switch ( LA(5) )
+ {
+ case FIELD:
+ {
+ switch ( LA(6) )
+ {
+ case STR:
+ {
+ alt1=4;
+ }
+ break;
+ case INT:
+ {
+ alt1=6;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 15;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 14;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 11;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+ case LESS:
+ case GREATER:
+ case LTE:
+ case GTE:
+ {
+ alt1=6;
+ }
+ break;
+ case INCLUDES:
+ case STARTSW:
+ case ENDSW:
+ {
+ alt1=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 9;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 5;
+
+
+ goto ruleexprEx;
+ }
+
+ }
+ break;
+ case LESS:
+ case GREATER:
+ case LTE:
+ case GTE:
+ {
+ alt1=5;
+ }
+ break;
+ case BEFORE:
+ case AFTER:
+ {
+ alt1=7;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 0;
+
+
+ goto ruleexprEx;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // RSP2SQL.g:76:4: ^( AND a= expr b= expr )
+ {
+ MATCHT(AND, &FOLLOW_AND_in_expr95);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr101);
+ a=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr107);
+ b=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ if (!a.valid || !b.valid)
+ {
+ retval.valid= 0;
+ }
+ else
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->append8(retval.result, "(");
+ retval.result->appendS(retval.result, a.result);
+ retval.result->append8(retval.result, " AND ");
+ retval.result->appendS(retval.result, b.result);
+ retval.result->append8(retval.result, ")");
+ }
+
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:92:4: ^( OR a= expr b= expr )
+ {
+ MATCHT(OR, &FOLLOW_OR_in_expr118);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr124);
+ a=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expr_in_expr130);
+ b=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ if (!a.valid || !b.valid)
+ {
+ retval.valid= 0;
+ }
+ else
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->append8(retval.result, "(");
+ retval.result->appendS(retval.result, a.result);
+ retval.result->append8(retval.result, " OR ");
+ retval.result->appendS(retval.result, b.result);
+ retval.result->append8(retval.result, ")");
+ }
+
+ }
+
+ }
+ break;
+ case 3:
+ // RSP2SQL.g:108:4: c= strcrit
+ {
+ FOLLOWPUSH(FOLLOW_strcrit_in_expr144);
+ c=strcrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ retval.valid= c.valid;
+ retval.result= c.result;
+
+ }
+
+ }
+ break;
+ case 4:
+ // RSP2SQL.g:113:4: ^( NOT c= strcrit )
+ {
+ MATCHT(NOT, &FOLLOW_NOT_in_expr154);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_strcrit_in_expr160);
+ c=strcrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ if (!c.valid)
+ {
+ retval.valid= 0;
+ }
+ else
+ {
+ retval.result= c.result->factory->newRaw(c.result->factory);
+ retval.result->append8(retval.result, "(NOT ");
+ retval.result->appendS(retval.result, c.result);
+ retval.result->append8(retval.result, ")");
+ }
+
+ }
+
+ }
+ break;
+ case 5:
+ // RSP2SQL.g:127:4: i= intcrit
+ {
+ FOLLOWPUSH(FOLLOW_intcrit_in_expr174);
+ i=intcrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ retval.valid= i.valid;
+ retval.result= i.result;
+
+ }
+
+ }
+ break;
+ case 6:
+ // RSP2SQL.g:132:4: ^( NOT i= intcrit )
+ {
+ MATCHT(NOT, &FOLLOW_NOT_in_expr184);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_intcrit_in_expr190);
+ i=intcrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ if (!i.valid)
+ {
+ retval.valid= 0;
+ }
+ else
+ {
+ retval.result= i.result->factory->newRaw(i.result->factory);
+ retval.result->append8(retval.result, "(NOT ");
+ retval.result->appendS(retval.result, i.result);
+ retval.result->append8(retval.result, ")");
+ }
+
+ }
+
+ }
+ break;
+ case 7:
+ // RSP2SQL.g:146:4: d= datecrit
+ {
+ FOLLOWPUSH(FOLLOW_datecrit_in_expr204);
+ d=datecrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ {
+
+ retval.valid= d.valid;
+ retval.result= d.result;
+
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleexprEx; /* Prevent compiler warnings */
+ ruleexprEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end expr */
+
+/**
+ * $ANTLR start strcrit
+ * RSP2SQL.g:153:1: strcrit returns [ pANTLR3_STRING result, int valid ] : ^(o= strop f= FIELD s= STR ) ;
+ */
+static RSP2SQL_strcrit_return
+strcrit(pRSP2SQL ctx)
+{
+ RSP2SQL_strcrit_return retval;
+
+ pANTLR3_BASE_TREE f;
+ pANTLR3_BASE_TREE s;
+ pANTLR3_COMMON_TOKEN o;
+ #undef RETURN_TYPE_o
+ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
+
+ /* Initialize rule variables
+ */
+
+
+ retval.result= NULL; retval.valid= 1;
+ f = NULL;
+ s = NULL;
+ o = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ // RSP2SQL.g:155:2: ( ^(o= strop f= FIELD s= STR ) )
+ // RSP2SQL.g:155:4: ^(o= strop f= FIELD s= STR )
+ {
+ FOLLOWPUSH(FOLLOW_strop_in_strcrit233);
+ o=strop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ f = (pANTLR3_BASE_TREE) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit239);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ s = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_strcrit245);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ {
+
+ char *op;
+ const struct rsp_query_field_map *rqfp;
+ pANTLR3_STRING field;
+ char *escaped;
+ ANTLR3_UINT32 optok;
+
+ escaped = NULL;
+
+ op = NULL;
+ optok = o->getType(o);
+ switch (optok)
+ {
+ case EQUAL:
+ op = " = ";
+ break;
+
+ case INCLUDES:
+ case STARTSW:
+ case ENDSW:
+ op = " LIKE ";
+ break;
+ }
+
+ field = f->getText(f);
+
+ /* Field lookup */
+ rqfp = rsp_query_field_lookup((char *)field->chars, strlen((char *)field->chars));
+ if (!rqfp)
+ {
+ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a valid field in queries\n", field->chars);
+ retval.valid= 0;
+ goto strcrit_valid_0; /* ABORT */
+ }
+
+ /* Check field type */
+ if (rqfp->field_type != RSP_TYPE_STRING)
+ {
+ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a string field\n", field->chars);
+ retval.valid= 0;
+ goto strcrit_valid_0; /* ABORT */
+ }
+
+ escaped = db_escape_string((char *)s->getText(s)->chars);
+ if (!escaped)
+ {
+ DPRINTF(E_LOG, L_RSP, "Could not escape value\n");
+ retval.valid= 0;
+ goto strcrit_valid_0; /* ABORT */
+ }
+
+ retval.result= field->factory->newRaw(field->factory);
+ retval.result->append8(retval.result, "f.");
+ retval.result->appendS(retval.result, field);
+ retval.result->append8(retval.result, op);
+ retval.result->append8(retval.result, "'");
+ if ((optok == INCLUDES) || (optok == STARTSW))
+ retval.result->append8(retval.result, "%");
+
+ retval.result->append8(retval.result, escaped);
+
+ if ((optok == INCLUDES) || (optok == ENDSW))
+ retval.result->append8(retval.result, "%");
+ retval.result->append8(retval.result, "'");
+
+ strcrit_valid_0:
+ ;
+
+ if (escaped)
+ free(escaped);
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulestrcritEx; /* Prevent compiler warnings */
+ rulestrcritEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end strcrit */
+
+/**
+ * $ANTLR start strop
+ * RSP2SQL.g:229:1: strop returns [ pANTLR3_COMMON_TOKEN op ] : (n= EQUAL | n= INCLUDES | n= STARTSW | n= ENDSW );
+ */
+static pANTLR3_COMMON_TOKEN
+strop(pRSP2SQL ctx)
+{
+ pANTLR3_COMMON_TOKEN op = NULL;
+
+ pANTLR3_BASE_TREE n;
+
+ /* Initialize rule variables
+ */
+
+
+ op= NULL;
+ n = NULL;
+
+ {
+ {
+ // RSP2SQL.g:231:2: (n= EQUAL | n= INCLUDES | n= STARTSW | n= ENDSW )
+
+ ANTLR3_UINT32 alt2;
+
+ alt2=4;
+
+ switch ( LA(1) )
+ {
+ case EQUAL:
+ {
+ alt2=1;
+ }
+ break;
+ case INCLUDES:
+ {
+ alt2=2;
+ }
+ break;
+ case STARTSW:
+ {
+ alt2=3;
+ }
+ break;
+ case ENDSW:
+ {
+ alt2=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 0;
+
+
+ goto rulestropEx;
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // RSP2SQL.g:231:4: n= EQUAL
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(EQUAL, &FOLLOW_EQUAL_in_strop274);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:233:4: n= INCLUDES
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(INCLUDES, &FOLLOW_INCLUDES_in_strop287);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 3:
+ // RSP2SQL.g:235:4: n= STARTSW
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(STARTSW, &FOLLOW_STARTSW_in_strop300);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 4:
+ // RSP2SQL.g:237:4: n= ENDSW
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(ENDSW, &FOLLOW_ENDSW_in_strop313);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulestropEx; /* Prevent compiler warnings */
+ rulestropEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return op;
+}
+/* $ANTLR end strop */
+
+/**
+ * $ANTLR start intcrit
+ * RSP2SQL.g:241:1: intcrit returns [ pANTLR3_STRING result, int valid ] : ^(o= intop f= FIELD i= INT ) ;
+ */
+static RSP2SQL_intcrit_return
+intcrit(pRSP2SQL ctx)
+{
+ RSP2SQL_intcrit_return retval;
+
+ pANTLR3_BASE_TREE f;
+ pANTLR3_BASE_TREE i;
+ pANTLR3_COMMON_TOKEN o;
+ #undef RETURN_TYPE_o
+ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
+
+ /* Initialize rule variables
+ */
+
+
+ retval.result= NULL; retval.valid= 1;
+ f = NULL;
+ i = NULL;
+ o = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ // RSP2SQL.g:243:2: ( ^(o= intop f= FIELD i= INT ) )
+ // RSP2SQL.g:243:4: ^(o= intop f= FIELD i= INT )
+ {
+ FOLLOWPUSH(FOLLOW_intop_in_intcrit342);
+ o=intop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ f = (pANTLR3_BASE_TREE) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit348);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ i = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_intcrit354);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ {
+
+ char *op;
+ const struct rsp_query_field_map *rqfp;
+ pANTLR3_STRING field;
+
+ op = NULL;
+ switch (o->getType(o))
+ {
+ case EQUAL:
+ op = " = ";
+ break;
+
+ case LESS:
+ op = " < ";
+ break;
+
+ case GREATER:
+ op = " > ";
+ break;
+
+ case LTE:
+ op = " <= ";
+ break;
+
+ case GTE:
+ op = " >= ";
+ break;
+ }
+
+ field = f->getText(f);
+
+ /* Field lookup */
+ rqfp = rsp_query_field_lookup((char *)field->chars, strlen((char *)field->chars));
+ if (!rqfp)
+ {
+ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a valid field in queries\n", field->chars);
+ retval.valid= 0;
+ goto intcrit_valid_0; /* ABORT */
+ }
+
+ /* Check field type */
+ if (rqfp->field_type != RSP_TYPE_INT)
+ {
+ DPRINTF(E_LOG, L_RSP, "Field '%s' is not an integer field\n", field->chars);
+ retval.valid= 0;
+ goto intcrit_valid_0; /* ABORT */
+ }
+
+ retval.result= field->factory->newRaw(field->factory);
+ retval.result->append8(retval.result, "f.");
+ retval.result->appendS(retval.result, field);
+ retval.result->append8(retval.result, op);
+ retval.result->appendS(retval.result, i->getText(i));
+
+ intcrit_valid_0:
+ ;
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleintcritEx; /* Prevent compiler warnings */
+ ruleintcritEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end intcrit */
+
+/**
+ * $ANTLR start intop
+ * RSP2SQL.g:303:1: intop returns [ pANTLR3_COMMON_TOKEN op ] : (n= EQUAL | n= LESS | n= GREATER | n= LTE | n= GTE );
+ */
+static pANTLR3_COMMON_TOKEN
+intop(pRSP2SQL ctx)
+{
+ pANTLR3_COMMON_TOKEN op = NULL;
+
+ pANTLR3_BASE_TREE n;
+
+ /* Initialize rule variables
+ */
+
+
+ op= NULL;
+ n = NULL;
+
+ {
+ {
+ // RSP2SQL.g:305:2: (n= EQUAL | n= LESS | n= GREATER | n= LTE | n= GTE )
+
+ ANTLR3_UINT32 alt3;
+
+ alt3=5;
+
+ switch ( LA(1) )
+ {
+ case EQUAL:
+ {
+ alt3=1;
+ }
+ break;
+ case LESS:
+ {
+ alt3=2;
+ }
+ break;
+ case GREATER:
+ {
+ alt3=3;
+ }
+ break;
+ case LTE:
+ {
+ alt3=4;
+ }
+ break;
+ case GTE:
+ {
+ alt3=5;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 0;
+
+
+ goto ruleintopEx;
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // RSP2SQL.g:305:4: n= EQUAL
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(EQUAL, &FOLLOW_EQUAL_in_intop383);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:307:4: n= LESS
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(LESS, &FOLLOW_LESS_in_intop396);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 3:
+ // RSP2SQL.g:309:4: n= GREATER
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(GREATER, &FOLLOW_GREATER_in_intop409);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 4:
+ // RSP2SQL.g:311:4: n= LTE
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(LTE, &FOLLOW_LTE_in_intop422);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 5:
+ // RSP2SQL.g:313:4: n= GTE
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(GTE, &FOLLOW_GTE_in_intop435);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleintopEx; /* Prevent compiler warnings */
+ ruleintopEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return op;
+}
+/* $ANTLR end intop */
+
+/**
+ * $ANTLR start datecrit
+ * RSP2SQL.g:317:1: datecrit returns [ pANTLR3_STRING result, int valid ] : ^(o= dateop f= FIELD d= datespec ) ;
+ */
+static RSP2SQL_datecrit_return
+datecrit(pRSP2SQL ctx)
+{
+ RSP2SQL_datecrit_return retval;
+
+ pANTLR3_BASE_TREE f;
+ pANTLR3_COMMON_TOKEN o;
+ #undef RETURN_TYPE_o
+ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
+
+ RSP2SQL_datespec_return d;
+ #undef RETURN_TYPE_d
+ #define RETURN_TYPE_d RSP2SQL_datespec_return
+
+ /* Initialize rule variables
+ */
+
+
+ retval.result= NULL; retval.valid= 1;
+ f = NULL;
+ o = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ // RSP2SQL.g:319:2: ( ^(o= dateop f= FIELD d= datespec ) )
+ // RSP2SQL.g:319:4: ^(o= dateop f= FIELD d= datespec )
+ {
+ FOLLOWPUSH(FOLLOW_dateop_in_datecrit464);
+ o=dateop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+ f = (pANTLR3_BASE_TREE) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit470);
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_datespec_in_datecrit476);
+ d=datespec(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+ {
+
+ char *op;
+ const struct rsp_query_field_map *rqfp;
+ pANTLR3_STRING field;
+ char buf[32];
+ int ret;
+
+ op = NULL;
+ switch (o->getType(o))
+ {
+ case BEFORE:
+ op = " < ";
+ break;
+
+ case AFTER:
+ op = " > ";
+ break;
+ }
+
+ field = f->getText(f);
+
+ /* Field lookup */
+ rqfp = rsp_query_field_lookup((char *)field->chars, strlen((char *)field->chars));
+ if (!rqfp)
+ {
+ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a valid field in queries\n", field->chars);
+ retval.valid= 0;
+ goto datecrit_valid_0; /* ABORT */
+ }
+
+ /* Check field type */
+ if (rqfp->field_type != RSP_TYPE_DATE)
+ {
+ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a date field\n", field->chars);
+ retval.valid= 0;
+ goto datecrit_valid_0; /* ABORT */
+ }
+
+ ret = snprintf(buf, sizeof(buf), "%ld", d.date);
+ if ((ret < 0) || (ret >= sizeof(buf)))
+ {
+ DPRINTF(E_LOG, L_RSP, "Date %ld too large for buffer, oops!\n", d.date);
+ retval.valid= 0;
+ goto datecrit_valid_0; /* ABORT */
+ }
+
+ retval.result= field->factory->newRaw(field->factory);
+ retval.result->append8(retval.result, "f.");
+ retval.result->appendS(retval.result, field);
+ retval.result->append8(retval.result, op);
+ retval.result->append8(retval.result, buf);
+
+ datecrit_valid_0:
+ ;
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledatecritEx; /* Prevent compiler warnings */
+ ruledatecritEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end datecrit */
+
+/**
+ * $ANTLR start dateop
+ * RSP2SQL.g:377:1: dateop returns [ pANTLR3_COMMON_TOKEN op ] : (n= BEFORE | n= AFTER );
+ */
+static pANTLR3_COMMON_TOKEN
+dateop(pRSP2SQL ctx)
+{
+ pANTLR3_COMMON_TOKEN op = NULL;
+
+ pANTLR3_BASE_TREE n;
+
+ /* Initialize rule variables
+ */
+
+
+ op= NULL;
+ n = NULL;
+
+ {
+ {
+ // RSP2SQL.g:379:2: (n= BEFORE | n= AFTER )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=2;
+
+ switch ( LA(1) )
+ {
+ case BEFORE:
+ {
+ alt4=1;
+ }
+ break;
+ case AFTER:
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto ruledateopEx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // RSP2SQL.g:379:4: n= BEFORE
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateop505);
+ if (HASEXCEPTION())
+ {
+ goto ruledateopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:381:4: n= AFTER
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(AFTER, &FOLLOW_AFTER_in_dateop518);
+ if (HASEXCEPTION())
+ {
+ goto ruledateopEx;
+ }
+
+ {
+ op= n->getToken(n);
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledateopEx; /* Prevent compiler warnings */
+ ruledateopEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return op;
+}
+/* $ANTLR end dateop */
+
+/**
+ * $ANTLR start datespec
+ * RSP2SQL.g:385:1: datespec returns [ time_t date, int valid ] : (r= dateref | ^(o= dateop r= dateref m= INT i= dateintval ) );
+ */
+static RSP2SQL_datespec_return
+datespec(pRSP2SQL ctx)
+{
+ RSP2SQL_datespec_return retval;
+
+ pANTLR3_BASE_TREE m;
+ RSP2SQL_dateref_return r;
+ #undef RETURN_TYPE_r
+ #define RETURN_TYPE_r RSP2SQL_dateref_return
+
+ pANTLR3_COMMON_TOKEN o;
+ #undef RETURN_TYPE_o
+ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
+
+ RSP2SQL_dateintval_return i;
+ #undef RETURN_TYPE_i
+ #define RETURN_TYPE_i RSP2SQL_dateintval_return
+
+ /* Initialize rule variables
+ */
+
+
+ retval.date= 0; retval.valid= 1;
+ m = NULL;
+ o = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ {
+ // RSP2SQL.g:387:2: (r= dateref | ^(o= dateop r= dateref m= INT i= dateintval ) )
+
+ ANTLR3_UINT32 alt5;
+
+ alt5=2;
+
+ switch ( LA(1) )
+ {
+ case DATE:
+ case TODAY:
+ {
+ alt5=1;
+ }
+ break;
+ case BEFORE:
+ case AFTER:
+ {
+ alt5=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 0;
+
+
+ goto ruledatespecEx;
+ }
+
+ switch (alt5)
+ {
+ case 1:
+ // RSP2SQL.g:387:4: r= dateref
+ {
+ FOLLOWPUSH(FOLLOW_dateref_in_datespec546);
+ r=dateref(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ {
+
+ if (!r.valid)
+ retval.valid= 0;
+ else
+ retval.date= r.date;
+
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:394:4: ^(o= dateop r= dateref m= INT i= dateintval )
+ {
+ FOLLOWPUSH(FOLLOW_dateop_in_datespec560);
+ o=dateop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_dateref_in_datespec566);
+ r=dateref(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ m = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_datespec572);
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_dateintval_in_datespec578);
+ i=dateintval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ {
+
+ int32_t val;
+ int ret;
+
+ if (!r.valid || !i.valid)
+ {
+ retval.valid= 0;
+ goto datespec_valid_0; /* ABORT */
+ }
+
+ ret = safe_atoi32((char *)m->getText(m)->chars, &val);
+ if (ret < 0)
+ {
+ DPRINTF(E_LOG, L_RSP, "Could not convert '%s' to integer\n", (char *)m->getText(m));
+ retval.valid= 0;
+ goto datespec_valid_0; /* ABORT */
+ }
+
+ switch (o->getType(o))
+ {
+ case BEFORE:
+ retval.date= r.date - (val * i.period);
+ break;
+
+ case AFTER:
+ retval.date= r.date + (val * i.period);
+ break;
+ }
+
+ datespec_valid_0:
+ ;
+
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledatespecEx; /* Prevent compiler warnings */
+ ruledatespecEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end datespec */
+
+/**
+ * $ANTLR start dateref
+ * RSP2SQL.g:429:1: dateref returns [ time_t date, int valid ] : (n= DATE | TODAY );
+ */
+static RSP2SQL_dateref_return
+dateref(pRSP2SQL ctx)
+{
+ RSP2SQL_dateref_return retval;
+
+ pANTLR3_BASE_TREE n;
+
+ /* Initialize rule variables
+ */
+
+
+ retval.date= 0; retval.valid= 1;
+ n = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ {
+ // RSP2SQL.g:431:2: (n= DATE | TODAY )
+
+ ANTLR3_UINT32 alt6;
+
+ alt6=2;
+
+ switch ( LA(1) )
+ {
+ case DATE:
+ {
+ alt6=1;
+ }
+ break;
+ case TODAY:
+ {
+ alt6=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 6;
+ EXCEPTION->state = 0;
+
+
+ goto ruledaterefEx;
+ }
+
+ switch (alt6)
+ {
+ case 1:
+ // RSP2SQL.g:431:4: n= DATE
+ {
+ n = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateref607);
+ if (HASEXCEPTION())
+ {
+ goto ruledaterefEx;
+ }
+
+ {
+
+ struct tm tm;
+ char *ret;
+
+ ret = strptime((char *)n->getText(n), "%Y-%m-%d", &tm);
+ if (!ret)
+ {
+ DPRINTF(E_LOG, L_RSP, "Date '%s' could not be interpreted\n", (char *)n->getText(n));
+ retval.valid= 0;
+ goto dateref_valid_0; /* ABORT */
+ }
+ else
+ {
+ if (*ret != '\0')
+ DPRINTF(E_LOG, L_RSP, "Garbage at end of date '%s' ?!\n", (char *)n->getText(n));
+
+ retval.date= mktime(&tm);
+ if (retval.date == (time_t) -1)
+ {
+ DPRINTF(E_LOG, L_RSP, "Date '%s' could not be converted to an epoch\n", (char *)n->getText(n));
+ retval.valid= 0;
+ goto dateref_valid_0; /* ABORT */
+ }
+ }
+
+ dateref_valid_0:
+ ;
+
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:460:4: TODAY
+ {
+ MATCHT(TODAY, &FOLLOW_TODAY_in_dateref616);
+ if (HASEXCEPTION())
+ {
+ goto ruledaterefEx;
+ }
+
+ {
+ retval.date= time(NULL);
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledaterefEx; /* Prevent compiler warnings */
+ ruledaterefEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end dateref */
+
+/**
+ * $ANTLR start dateintval
+ * RSP2SQL.g:464:1: dateintval returns [ time_t period, int valid ] : ( DAY | WEEK | MONTH | YEAR );
+ */
+static RSP2SQL_dateintval_return
+dateintval(pRSP2SQL ctx)
+{
+ RSP2SQL_dateintval_return retval;
+
+ /* Initialize rule variables
+ */
+
+
+ retval.period= 0; retval.valid= 1;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ {
+ // RSP2SQL.g:466:2: ( DAY | WEEK | MONTH | YEAR )
+
+ ANTLR3_UINT32 alt7;
+
+ alt7=4;
+
+ switch ( LA(1) )
+ {
+ case DAY:
+ {
+ alt7=1;
+ }
+ break;
+ case WEEK:
+ {
+ alt7=2;
+ }
+ break;
+ case MONTH:
+ {
+ alt7=3;
+ }
+ break;
+ case YEAR:
+ {
+ alt7=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 7;
+ EXCEPTION->state = 0;
+
+
+ goto ruledateintvalEx;
+ }
+
+ switch (alt7)
+ {
+ case 1:
+ // RSP2SQL.g:466:4: DAY
+ {
+ MATCHT(DAY, &FOLLOW_DAY_in_dateintval640);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ {
+ retval.period= 24 * 60 * 60;
+ }
+
+ }
+ break;
+ case 2:
+ // RSP2SQL.g:468:4: WEEK
+ {
+ MATCHT(WEEK, &FOLLOW_WEEK_in_dateintval649);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ {
+ retval.period= 7 * 24 * 60 * 60;
+ }
+
+ }
+ break;
+ case 3:
+ // RSP2SQL.g:470:4: MONTH
+ {
+ MATCHT(MONTH, &FOLLOW_MONTH_in_dateintval658);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ {
+ retval.period= 30 * 24 * 60 * 60;
+ }
+
+ }
+ break;
+ case 4:
+ // RSP2SQL.g:472:4: YEAR
+ {
+ MATCHT(YEAR, &FOLLOW_YEAR_in_dateintval667);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ {
+ retval.period= 365 * 24 * 60 * 60;
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledateintvalEx; /* Prevent compiler warnings */
+ ruledateintvalEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end dateintval */
+/* End of parsing rules
+ * ==============================================
+ */
+
+/* ==============================================
+ * Syntactic predicates
+ */
+/* End of syntactic predicates
+ * ==============================================
+ */
+
+
+
+
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/RSP2SQL.h b/src/pregen/RSP2SQL.h
new file mode 100644
index 0000000..08ac7bb
--- /dev/null
+++ b/src/pregen/RSP2SQL.h
@@ -0,0 +1,291 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : RSP2SQL.g
+ * - On : 2016-01-01 12:23:43
+ * - for the tree parser : RSP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The tree parser RSP2SQL has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pRSP2SQL, which is returned from a call to RSP2SQLNew().
+ *
+ * The methods in pRSP2SQL are as follows:
+ *
+ * - pANTLR3_STRING pRSP2SQL->query(pRSP2SQL)
+ * - RSP2SQL_expr_return pRSP2SQL->expr(pRSP2SQL)
+ * - RSP2SQL_strcrit_return pRSP2SQL->strcrit(pRSP2SQL)
+ * - pANTLR3_COMMON_TOKEN pRSP2SQL->strop(pRSP2SQL)
+ * - RSP2SQL_intcrit_return pRSP2SQL->intcrit(pRSP2SQL)
+ * - pANTLR3_COMMON_TOKEN pRSP2SQL->intop(pRSP2SQL)
+ * - RSP2SQL_datecrit_return pRSP2SQL->datecrit(pRSP2SQL)
+ * - pANTLR3_COMMON_TOKEN pRSP2SQL->dateop(pRSP2SQL)
+ * - RSP2SQL_datespec_return pRSP2SQL->datespec(pRSP2SQL)
+ * - RSP2SQL_dateref_return pRSP2SQL->dateref(pRSP2SQL)
+ * - RSP2SQL_dateintval_return pRSP2SQL->dateintval(pRSP2SQL)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _RSP2SQL_H
+#define _RSP2SQL_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct RSP2SQL_Ctx_struct RSP2SQL, * pRSP2SQL;
+
+
+
+ /* Needs #define _GNU_SOURCE for strptime() */
+
+ #include <stdio.h>
+ #include <string.h>
+ #include <time.h>
+ #include <stdint.h>
+
+ #include "logger.h"
+ #include "db.h"
+ #include "misc.h"
+ #include "rsp_query.h"
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+typedef struct RSP2SQL_expr_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ pANTLR3_STRING result;
+ int valid;
+}
+ RSP2SQL_expr_return;
+
+typedef struct RSP2SQL_strcrit_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ pANTLR3_STRING result;
+ int valid;
+}
+ RSP2SQL_strcrit_return;
+
+typedef struct RSP2SQL_intcrit_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ pANTLR3_STRING result;
+ int valid;
+}
+ RSP2SQL_intcrit_return;
+
+typedef struct RSP2SQL_datecrit_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ pANTLR3_STRING result;
+ int valid;
+}
+ RSP2SQL_datecrit_return;
+
+typedef struct RSP2SQL_datespec_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ time_t date;
+ int valid;
+}
+ RSP2SQL_datespec_return;
+
+typedef struct RSP2SQL_dateref_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ time_t date;
+ int valid;
+}
+ RSP2SQL_dateref_return;
+
+typedef struct RSP2SQL_dateintval_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ time_t period;
+ int valid;
+}
+ RSP2SQL_dateintval_return;
+
+
+
+/** Context tracking structure for RSP2SQL
+ */
+struct RSP2SQL_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_TREE_PARSER pTreeParser;
+
+
+ pANTLR3_STRING (*query) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_expr_return (*expr) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_strcrit_return (*strcrit) (struct RSP2SQL_Ctx_struct * ctx);
+ pANTLR3_COMMON_TOKEN (*strop) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_intcrit_return (*intcrit) (struct RSP2SQL_Ctx_struct * ctx);
+ pANTLR3_COMMON_TOKEN (*intop) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_datecrit_return (*datecrit) (struct RSP2SQL_Ctx_struct * ctx);
+ pANTLR3_COMMON_TOKEN (*dateop) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_datespec_return (*datespec) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_dateref_return (*dateref) (struct RSP2SQL_Ctx_struct * ctx);
+ RSP2SQL_dateintval_return (*dateintval) (struct RSP2SQL_Ctx_struct * ctx);
+ // Delegated rules
+ const char * (*getGrammarFileName)();
+ void (*free) (struct RSP2SQL_Ctx_struct * ctx);
+
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pRSP2SQL RSP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream);
+ANTLR3_API pRSP2SQL RSP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the tree parser will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define STARTSW 14
+#define WEEK 26
+#define TODAY 24
+#define YEAR 28
+#define ENDSW 15
+#define GTE 20
+#define BEFORE 21
+#define DAY 25
+#define INT 16
+#define NOT 11
+#define AFTER 22
+#define AND 6
+#define EOF -1
+#define LTE 19
+#define MONTH 27
+#define DIGIT19 31
+#define INCLUDES 13
+#define STR 10
+#define QUOTE 29
+#define GREATER 18
+#define WS 30
+#define LPAR 7
+#define NEWLINE 4
+#define EQUAL 12
+#define OR 5
+#define LESS 17
+#define FIELD 9
+#define RPAR 8
+#define ESCAPED 33
+#define DATE 23
+#define DIGIT09 32
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for RSP2SQL
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/RSP2SQL.u b/src/pregen/RSP2SQL.u
new file mode 100644
index 0000000..53d8cda
--- /dev/null
+++ b/src/pregen/RSP2SQL.u
@@ -0,0 +1,5 @@
+RSP2SQL.g: RSP.tokens
+RSP2SQL.c : RSP2SQL.g
+./RSP2SQL.tokens : RSP2SQL.g
+RSP2SQL.h : RSP2SQL.g
+ANTLR_PRODUCTS += RSP2SQL.c ./RSP2SQL.tokens RSP2SQL.h
\ No newline at end of file
diff --git a/src/pregen/RSPLexer.c b/src/pregen/RSPLexer.c
new file mode 100644
index 0000000..2e3faae
--- /dev/null
+++ b/src/pregen/RSPLexer.c
@@ -0,0 +1,4867 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : RSP.g
+ * - On : 2016-01-01 12:23:42
+ * - for the lexer : RSPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "RSPLexer.h"
+/* ----------------------------------------- */
+
+
+/** String literals used by RSPLexer that we must do things like MATCHS() with.
+ * C will normally just lay down 8 bit characters, and you can use L"xxx" to
+ * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
+ * we perform this little trick of defining the literals as arrays of UINT32
+ * and passing in the address of these.
+ */
+static ANTLR3_UCHAR lit_1[] = { 0x61, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_2[] = { 0x6F, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_3[] = { 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_4[] = { 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x77, 0x69, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_5[] = { 0x65, 0x6E, 0x64, 0x73, 0x77, 0x69, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_6[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_7[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_8[] = { 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_9[] = { 0x61, 0x66, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_10[] = { 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_11[] = { 0x64, 0x61, 0x79, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_12[] = { 0x77, 0x65, 0x65, 0x6B, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_13[] = { 0x77, 0x65, 0x65, 0x6B, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_14[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_15[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_16[] = { 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_17[] = { 0x79, 0x65, 0x61, 0x72, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_18[] = { 0x74, 0x6F, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pRSPLexer_##scope##_SCOPE
+#define SCOPE_STACK(scope) pRSPLexer_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pRSPLexer_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pRSPLexer_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+
+/* Macros for accessing things in a lexer
+ */
+#undef LEXER
+#undef RECOGNIZER
+#undef RULEMEMO
+#undef GETCHARINDEX
+#undef GETLINE
+#undef GETCHARPOSITIONINLINE
+#undef EMIT
+#undef EMITNEW
+#undef MATCHC
+#undef MATCHS
+#undef MATCHRANGE
+#undef LTOKEN
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef INPUT
+#undef STRSTREAM
+#undef LA
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef LRECOVER
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef BACKTRACKING
+#undef MATCHANY
+#undef MEMOIZE
+#undef HAVEPARSEDRULE
+#undef GETTEXT
+#undef INDEX
+#undef SEEK
+#undef PUSHSTREAM
+#undef POPSTREAM
+#undef SETTEXT
+#undef SETTEXT8
+
+#define LEXER ctx->pLexer
+#define RECOGNIZER LEXER->rec
+#define LEXSTATE RECOGNIZER->state
+#define TOKSOURCE LEXSTATE->tokSource
+#define GETCHARINDEX() LEXER->getCharIndex(LEXER)
+#define GETLINE() LEXER->getLine(LEXER)
+#define GETTEXT() LEXER->getText(LEXER)
+#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
+#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER)
+#define EMITNEW(t) LEXER->emitNew(LEXER, t)
+#define MATCHC(c) LEXER->matchc(LEXER, c)
+#define MATCHS(s) LEXER->matchs(LEXER, s)
+#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2)
+#define MATCHANY() LEXER->matchAny(LEXER)
+#define LTOKEN LEXSTATE->token
+#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE)
+#define BACKTRACKING LEXSTATE->backtracking
+#define FAILEDFLAG LEXSTATE->failed
+#define INPUT LEXER->input
+#define STRSTREAM INPUT
+#define ISTREAM INPUT->istream
+#define INDEX() ISTREAM->index(ISTREAM)
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken)
+#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION LEXSTATE->exception
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define LRECOVER() LEXER->recover(LEXER)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str)
+#define POPSTREAM() LEXER->popCharStream(LEXER)
+#define SETTEXT(str) LEXSTATE->text = str
+#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken)
+#define USER1 LEXSTATE->user1
+#define USER2 LEXSTATE->user2
+#define USER3 LEXSTATE->user3
+#define CUSTOM LEXSTATE->custom
+#define RULEMEMO LEXSTATE->ruleMemo
+#define DBG RECOGNIZER->debugger
+
+/* If we have been told we can rely on the standard 8 bit or 16 bit input
+ * stream, then we can define our macros to use the direct pointers
+ * in the input object, which is much faster than indirect calls. This
+ * is really only significant to lexers with a lot of fragment rules (which
+ * do not place LA(1) in a temporary at the moment) and even then
+ * only if there is a lot of input (order of say 1M or so).
+ */
+#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
+
+# ifdef ANTLR3_INLINE_INPUT_ASCII
+
+/* 8 bit "ASCII" (actually any 8 bit character set) */
+
+# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar))
+# define DATAP ((pANTLR3_UINT8)(INPUT->data))
+
+# else
+
+# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar))
+# define DATAP ((pANTLR3_UINT16)(INPUT->data))
+
+# endif
+
+# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
+# define CONSUME() \
+{ \
+ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \
+ { \
+ INPUT->charPositionInLine++; \
+ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \
+ { \
+ INPUT->line++; \
+ INPUT->charPositionInLine = 0; \
+ INPUT->currentLine = (void *)(NEXTCHAR + 1); \
+ } \
+ INPUT->nextChar = (void *)(NEXTCHAR + 1); \
+ } \
+}
+
+#else
+
+// Pick up the input character by calling the input stream implementation.
+//
+#define CONSUME() INPUT->istream->consume(INPUT->istream)
+#define LA(n) INPUT->istream->_LA(INPUT->istream, n)
+
+#endif
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+/* Forward declare the locally static matching functions we have generated and any predicate functions.
+ */
+static ANTLR3_INLINE void mQUOTE (pRSPLexer ctx);
+static ANTLR3_INLINE void mLPAR (pRSPLexer ctx);
+static ANTLR3_INLINE void mRPAR (pRSPLexer ctx);
+static ANTLR3_INLINE void mAND (pRSPLexer ctx);
+static ANTLR3_INLINE void mOR (pRSPLexer ctx);
+static ANTLR3_INLINE void mNOT (pRSPLexer ctx);
+static ANTLR3_INLINE void mEQUAL (pRSPLexer ctx);
+static ANTLR3_INLINE void mINCLUDES (pRSPLexer ctx);
+static ANTLR3_INLINE void mSTARTSW (pRSPLexer ctx);
+static ANTLR3_INLINE void mENDSW (pRSPLexer ctx);
+static ANTLR3_INLINE void mGREATER (pRSPLexer ctx);
+static ANTLR3_INLINE void mLESS (pRSPLexer ctx);
+static ANTLR3_INLINE void mGTE (pRSPLexer ctx);
+static ANTLR3_INLINE void mLTE (pRSPLexer ctx);
+static ANTLR3_INLINE void mBEFORE (pRSPLexer ctx);
+static ANTLR3_INLINE void mAFTER (pRSPLexer ctx);
+static ANTLR3_INLINE void mDAY (pRSPLexer ctx);
+static ANTLR3_INLINE void mWEEK (pRSPLexer ctx);
+static ANTLR3_INLINE void mMONTH (pRSPLexer ctx);
+static ANTLR3_INLINE void mYEAR (pRSPLexer ctx);
+static ANTLR3_INLINE void mTODAY (pRSPLexer ctx);
+static ANTLR3_INLINE void mNEWLINE (pRSPLexer ctx);
+static ANTLR3_INLINE void mWS (pRSPLexer ctx);
+static ANTLR3_INLINE void mFIELD (pRSPLexer ctx);
+static ANTLR3_INLINE void mINT (pRSPLexer ctx);
+static ANTLR3_INLINE void mDATE (pRSPLexer ctx);
+static ANTLR3_INLINE void mSTR (pRSPLexer ctx);
+static ANTLR3_INLINE void mESCAPED (pRSPLexer ctx);
+static ANTLR3_INLINE void mDIGIT09 (pRSPLexer ctx);
+static ANTLR3_INLINE void mDIGIT19 (pRSPLexer ctx);
+static ANTLR3_INLINE void mTokens (pRSPLexer ctx);
+static void RSPLexerFree(pRSPLexer ctx);
+
+/* =========================================================================
+ * Lexer matching rules end.
+ * =========================================================================
+ */
+
+
+
+static void
+RSPLexerFree (pRSPLexer ctx)
+{
+ LEXER->free(LEXER);
+
+ ANTLR3_FREE(ctx);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "RSP.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+
+/** \brief Create a new lexer called RSPLexer
+ *
+ * \param[in] instream Pointer to an initialized input stream
+ * \return
+ * - Success pRSPLexer initialized for the lex start
+ * - Fail NULL
+ */
+ANTLR3_API pRSPLexer RSPLexerNew
+(pANTLR3_INPUT_STREAM instream)
+{
+ // See if we can create a new lexer with the standard constructor
+ //
+ return RSPLexerNewSSD(instream, NULL);
+}
+
+/** \brief Create a new lexer called RSPLexer
+ *
+ * \param[in] instream Pointer to an initialized input stream
+ * \param[state] state Previously created shared recognizer stat
+ * \return
+ * - Success pRSPLexer initialized for the lex start
+ * - Fail NULL
+ */
+ANTLR3_API pRSPLexer RSPLexerNewSSD
+(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pRSPLexer ctx; // Context structure we will build and return
+
+ ctx = (pRSPLexer) ANTLR3_CALLOC(1, sizeof(RSPLexer));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for lexer context
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * in base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 lexer function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in RSPLexer.h here so you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base lexer, using the supplied input stream
+ */
+ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
+
+ /* Check that we allocated the memory correctly
+ */
+ if (ctx->pLexer == NULL)
+ {
+ ANTLR3_FREE(ctx);
+ return NULL;
+ }
+ /* Install the implementation of our RSPLexer interface
+ */
+ ctx->mQUOTE = mQUOTE;
+ ctx->mLPAR = mLPAR;
+ ctx->mRPAR = mRPAR;
+ ctx->mAND = mAND;
+ ctx->mOR = mOR;
+ ctx->mNOT = mNOT;
+ ctx->mEQUAL = mEQUAL;
+ ctx->mINCLUDES = mINCLUDES;
+ ctx->mSTARTSW = mSTARTSW;
+ ctx->mENDSW = mENDSW;
+ ctx->mGREATER = mGREATER;
+ ctx->mLESS = mLESS;
+ ctx->mGTE = mGTE;
+ ctx->mLTE = mLTE;
+ ctx->mBEFORE = mBEFORE;
+ ctx->mAFTER = mAFTER;
+ ctx->mDAY = mDAY;
+ ctx->mWEEK = mWEEK;
+ ctx->mMONTH = mMONTH;
+ ctx->mYEAR = mYEAR;
+ ctx->mTODAY = mTODAY;
+ ctx->mNEWLINE = mNEWLINE;
+ ctx->mWS = mWS;
+ ctx->mFIELD = mFIELD;
+ ctx->mINT = mINT;
+ ctx->mDATE = mDATE;
+ ctx->mSTR = mSTR;
+ ctx->mESCAPED = mESCAPED;
+ ctx->mDIGIT09 = mDIGIT09;
+ ctx->mDIGIT19 = mDIGIT19;
+ ctx->mTokens = mTokens;
+
+ /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
+ * it will call mTokens() in this generated code, and will pass it the ctx
+ * pointer of this lexer, not the context of the base lexer, so store that now.
+ */
+ ctx->pLexer->ctx = ctx;
+
+ /**Install the token matching function
+ */
+ ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
+
+ ctx->getGrammarFileName = getGrammarFileName;
+ ctx->free = RSPLexerFree;
+
+
+
+
+
+ /* Return the newly built lexer to the caller
+ */
+ return ctx;
+}
+
+
+/* =========================================================================
+ * Functions to match the lexer grammar defined tokens from the input stream
+ */
+
+// Comes from: 85:7: ( '\"' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start QUOTE
+ *
+ * Looks to match the characters the constitute the token QUOTE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mQUOTE(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = QUOTE;
+
+
+ // RSP.g:85:7: ( '\"' )
+ // RSP.g:85:9: '\"'
+ {
+ MATCHC('"');
+ if (HASEXCEPTION())
+ {
+ goto ruleQUOTEEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleQUOTEEx; /* Prevent compiler warnings */
+ ruleQUOTEEx: ;
+
+}
+// $ANTLR end QUOTE
+
+// Comes from: 86:6: ( '(' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LPAR
+ *
+ * Looks to match the characters the constitute the token LPAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLPAR(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = LPAR;
+
+
+ // RSP.g:86:6: ( '(' )
+ // RSP.g:86:8: '('
+ {
+ MATCHC('(');
+ if (HASEXCEPTION())
+ {
+ goto ruleLPAREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLPAREx; /* Prevent compiler warnings */
+ ruleLPAREx: ;
+
+}
+// $ANTLR end LPAR
+
+// Comes from: 87:6: ( ')' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start RPAR
+ *
+ * Looks to match the characters the constitute the token RPAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mRPAR(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = RPAR;
+
+
+ // RSP.g:87:6: ( ')' )
+ // RSP.g:87:8: ')'
+ {
+ MATCHC(')');
+ if (HASEXCEPTION())
+ {
+ goto ruleRPAREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleRPAREx; /* Prevent compiler warnings */
+ ruleRPAREx: ;
+
+}
+// $ANTLR end RPAR
+
+// Comes from: 89:5: ( 'and' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start AND
+ *
+ * Looks to match the characters the constitute the token AND
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mAND(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = AND;
+
+
+ // RSP.g:89:5: ( 'and' )
+ // RSP.g:89:7: 'and'
+ {
+ MATCHS(lit_1);
+ if (HASEXCEPTION())
+ {
+ goto ruleANDEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleANDEx; /* Prevent compiler warnings */
+ ruleANDEx: ;
+
+}
+// $ANTLR end AND
+
+// Comes from: 90:4: ( 'or' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start OR
+ *
+ * Looks to match the characters the constitute the token OR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mOR(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = OR;
+
+
+ // RSP.g:90:4: ( 'or' )
+ // RSP.g:90:6: 'or'
+ {
+ MATCHS(lit_2);
+ if (HASEXCEPTION())
+ {
+ goto ruleOREx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleOREx; /* Prevent compiler warnings */
+ ruleOREx: ;
+
+}
+// $ANTLR end OR
+
+// Comes from: 91:5: ( '!' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start NOT
+ *
+ * Looks to match the characters the constitute the token NOT
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mNOT(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = NOT;
+
+
+ // RSP.g:91:5: ( '!' )
+ // RSP.g:91:7: '!'
+ {
+ MATCHC('!');
+ if (HASEXCEPTION())
+ {
+ goto ruleNOTEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleNOTEx; /* Prevent compiler warnings */
+ ruleNOTEx: ;
+
+}
+// $ANTLR end NOT
+
+// Comes from: 94:7: ( '=' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start EQUAL
+ *
+ * Looks to match the characters the constitute the token EQUAL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mEQUAL(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = EQUAL;
+
+
+ // RSP.g:94:7: ( '=' )
+ // RSP.g:94:9: '='
+ {
+ MATCHC('=');
+ if (HASEXCEPTION())
+ {
+ goto ruleEQUALEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleEQUALEx; /* Prevent compiler warnings */
+ ruleEQUALEx: ;
+
+}
+// $ANTLR end EQUAL
+
+// Comes from: 97:9: ( 'includes' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start INCLUDES
+ *
+ * Looks to match the characters the constitute the token INCLUDES
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mINCLUDES(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = INCLUDES;
+
+
+ // RSP.g:97:9: ( 'includes' )
+ // RSP.g:97:11: 'includes'
+ {
+ MATCHS(lit_3);
+ if (HASEXCEPTION())
+ {
+ goto ruleINCLUDESEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleINCLUDESEx; /* Prevent compiler warnings */
+ ruleINCLUDESEx: ;
+
+}
+// $ANTLR end INCLUDES
+
+// Comes from: 98:9: ( 'startswith' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start STARTSW
+ *
+ * Looks to match the characters the constitute the token STARTSW
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mSTARTSW(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = STARTSW;
+
+
+ // RSP.g:98:9: ( 'startswith' )
+ // RSP.g:98:11: 'startswith'
+ {
+ MATCHS(lit_4);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTARTSWEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleSTARTSWEx; /* Prevent compiler warnings */
+ ruleSTARTSWEx: ;
+
+}
+// $ANTLR end STARTSW
+
+// Comes from: 99:7: ( 'endswith' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start ENDSW
+ *
+ * Looks to match the characters the constitute the token ENDSW
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mENDSW(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = ENDSW;
+
+
+ // RSP.g:99:7: ( 'endswith' )
+ // RSP.g:99:9: 'endswith'
+ {
+ MATCHS(lit_5);
+ if (HASEXCEPTION())
+ {
+ goto ruleENDSWEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleENDSWEx; /* Prevent compiler warnings */
+ ruleENDSWEx: ;
+
+}
+// $ANTLR end ENDSW
+
+// Comes from: 102:9: ( '>' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start GREATER
+ *
+ * Looks to match the characters the constitute the token GREATER
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mGREATER(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = GREATER;
+
+
+ // RSP.g:102:9: ( '>' )
+ // RSP.g:102:11: '>'
+ {
+ MATCHC('>');
+ if (HASEXCEPTION())
+ {
+ goto ruleGREATEREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleGREATEREx; /* Prevent compiler warnings */
+ ruleGREATEREx: ;
+
+}
+// $ANTLR end GREATER
+
+// Comes from: 103:6: ( '<' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LESS
+ *
+ * Looks to match the characters the constitute the token LESS
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLESS(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = LESS;
+
+
+ // RSP.g:103:6: ( '<' )
+ // RSP.g:103:8: '<'
+ {
+ MATCHC('<');
+ if (HASEXCEPTION())
+ {
+ goto ruleLESSEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLESSEx; /* Prevent compiler warnings */
+ ruleLESSEx: ;
+
+}
+// $ANTLR end LESS
+
+// Comes from: 104:5: ( '>=' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start GTE
+ *
+ * Looks to match the characters the constitute the token GTE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mGTE(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = GTE;
+
+
+ // RSP.g:104:5: ( '>=' )
+ // RSP.g:104:7: '>='
+ {
+ MATCHS(lit_6);
+ if (HASEXCEPTION())
+ {
+ goto ruleGTEEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleGTEEx; /* Prevent compiler warnings */
+ ruleGTEEx: ;
+
+}
+// $ANTLR end GTE
+
+// Comes from: 105:5: ( '<=' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LTE
+ *
+ * Looks to match the characters the constitute the token LTE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLTE(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = LTE;
+
+
+ // RSP.g:105:5: ( '<=' )
+ // RSP.g:105:7: '<='
+ {
+ MATCHS(lit_7);
+ if (HASEXCEPTION())
+ {
+ goto ruleLTEEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLTEEx; /* Prevent compiler warnings */
+ ruleLTEEx: ;
+
+}
+// $ANTLR end LTE
+
+// Comes from: 108:8: ( 'before' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start BEFORE
+ *
+ * Looks to match the characters the constitute the token BEFORE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mBEFORE(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = BEFORE;
+
+
+ // RSP.g:108:8: ( 'before' )
+ // RSP.g:108:10: 'before'
+ {
+ MATCHS(lit_8);
+ if (HASEXCEPTION())
+ {
+ goto ruleBEFOREEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleBEFOREEx; /* Prevent compiler warnings */
+ ruleBEFOREEx: ;
+
+}
+// $ANTLR end BEFORE
+
+// Comes from: 109:7: ( 'after' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start AFTER
+ *
+ * Looks to match the characters the constitute the token AFTER
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mAFTER(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = AFTER;
+
+
+ // RSP.g:109:7: ( 'after' )
+ // RSP.g:109:9: 'after'
+ {
+ MATCHS(lit_9);
+ if (HASEXCEPTION())
+ {
+ goto ruleAFTEREx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleAFTEREx; /* Prevent compiler warnings */
+ ruleAFTEREx: ;
+
+}
+// $ANTLR end AFTER
+
+// Comes from: 110:5: ( 'day' | 'days' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DAY
+ *
+ * Looks to match the characters the constitute the token DAY
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDAY(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = DAY;
+
+
+ {
+ // RSP.g:110:5: ( 'day' | 'days' )
+
+ ANTLR3_UINT32 alt1;
+
+ alt1=2;
+
+ switch ( LA(1) )
+ {
+ case 'd':
+ {
+ switch ( LA(2) )
+ {
+ case 'a':
+ {
+ switch ( LA(3) )
+ {
+ case 'y':
+ {
+ switch ( LA(4) )
+ {
+ case 's':
+ {
+ alt1=2;
+ }
+ break;
+
+ default:
+ alt1=1;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 2;
+
+
+ goto ruleDAYEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 1;
+
+
+ goto ruleDAYEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 0;
+
+
+ goto ruleDAYEx;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // RSP.g:110:7: 'day'
+ {
+ MATCHS(lit_10);
+ if (HASEXCEPTION())
+ {
+ goto ruleDAYEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:110:15: 'days'
+ {
+ MATCHS(lit_11);
+ if (HASEXCEPTION())
+ {
+ goto ruleDAYEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDAYEx; /* Prevent compiler warnings */
+ ruleDAYEx: ;
+
+}
+// $ANTLR end DAY
+
+// Comes from: 111:6: ( 'week' | 'weeks' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start WEEK
+ *
+ * Looks to match the characters the constitute the token WEEK
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mWEEK(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = WEEK;
+
+
+ {
+ // RSP.g:111:6: ( 'week' | 'weeks' )
+
+ ANTLR3_UINT32 alt2;
+
+ alt2=2;
+
+ switch ( LA(1) )
+ {
+ case 'w':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ switch ( LA(3) )
+ {
+ case 'e':
+ {
+ switch ( LA(4) )
+ {
+ case 'k':
+ {
+ switch ( LA(5) )
+ {
+ case 's':
+ {
+ alt2=2;
+ }
+ break;
+
+ default:
+ alt2=1;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 3;
+
+
+ goto ruleWEEKEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 2;
+
+
+ goto ruleWEEKEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 1;
+
+
+ goto ruleWEEKEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 0;
+
+
+ goto ruleWEEKEx;
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // RSP.g:111:8: 'week'
+ {
+ MATCHS(lit_12);
+ if (HASEXCEPTION())
+ {
+ goto ruleWEEKEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:111:17: 'weeks'
+ {
+ MATCHS(lit_13);
+ if (HASEXCEPTION())
+ {
+ goto ruleWEEKEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleWEEKEx; /* Prevent compiler warnings */
+ ruleWEEKEx: ;
+
+}
+// $ANTLR end WEEK
+
+// Comes from: 112:7: ( 'month' | 'months' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start MONTH
+ *
+ * Looks to match the characters the constitute the token MONTH
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mMONTH(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = MONTH;
+
+
+ {
+ // RSP.g:112:7: ( 'month' | 'months' )
+
+ ANTLR3_UINT32 alt3;
+
+ alt3=2;
+
+ switch ( LA(1) )
+ {
+ case 'm':
+ {
+ switch ( LA(2) )
+ {
+ case 'o':
+ {
+ switch ( LA(3) )
+ {
+ case 'n':
+ {
+ switch ( LA(4) )
+ {
+ case 't':
+ {
+ switch ( LA(5) )
+ {
+ case 'h':
+ {
+ switch ( LA(6) )
+ {
+ case 's':
+ {
+ alt3=2;
+ }
+ break;
+
+ default:
+ alt3=1;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 4;
+
+
+ goto ruleMONTHEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 3;
+
+
+ goto ruleMONTHEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 2;
+
+
+ goto ruleMONTHEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 1;
+
+
+ goto ruleMONTHEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 0;
+
+
+ goto ruleMONTHEx;
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // RSP.g:112:9: 'month'
+ {
+ MATCHS(lit_14);
+ if (HASEXCEPTION())
+ {
+ goto ruleMONTHEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:112:19: 'months'
+ {
+ MATCHS(lit_15);
+ if (HASEXCEPTION())
+ {
+ goto ruleMONTHEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleMONTHEx; /* Prevent compiler warnings */
+ ruleMONTHEx: ;
+
+}
+// $ANTLR end MONTH
+
+// Comes from: 113:6: ( 'year' | 'years' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start YEAR
+ *
+ * Looks to match the characters the constitute the token YEAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mYEAR(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = YEAR;
+
+
+ {
+ // RSP.g:113:6: ( 'year' | 'years' )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=2;
+
+ switch ( LA(1) )
+ {
+ case 'y':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ switch ( LA(3) )
+ {
+ case 'a':
+ {
+ switch ( LA(4) )
+ {
+ case 'r':
+ {
+ switch ( LA(5) )
+ {
+ case 's':
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ alt4=1;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 3;
+
+
+ goto ruleYEAREx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 2;
+
+
+ goto ruleYEAREx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 1;
+
+
+ goto ruleYEAREx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto ruleYEAREx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // RSP.g:113:8: 'year'
+ {
+ MATCHS(lit_16);
+ if (HASEXCEPTION())
+ {
+ goto ruleYEAREx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:113:17: 'years'
+ {
+ MATCHS(lit_17);
+ if (HASEXCEPTION())
+ {
+ goto ruleYEAREx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleYEAREx; /* Prevent compiler warnings */
+ ruleYEAREx: ;
+
+}
+// $ANTLR end YEAR
+
+// Comes from: 114:7: ( 'today' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start TODAY
+ *
+ * Looks to match the characters the constitute the token TODAY
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mTODAY(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = TODAY;
+
+
+ // RSP.g:114:7: ( 'today' )
+ // RSP.g:114:9: 'today'
+ {
+ MATCHS(lit_18);
+ if (HASEXCEPTION())
+ {
+ goto ruleTODAYEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleTODAYEx; /* Prevent compiler warnings */
+ ruleTODAYEx: ;
+
+}
+// $ANTLR end TODAY
+
+// Comes from: 116:9: ( ( '\\r' )? '\\n' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start NEWLINE
+ *
+ * Looks to match the characters the constitute the token NEWLINE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mNEWLINE(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = NEWLINE;
+
+
+ // RSP.g:116:9: ( ( '\\r' )? '\\n' )
+ // RSP.g:116:11: ( '\\r' )? '\\n'
+ {
+
+ // RSP.g:116:11: ( '\\r' )?
+ {
+ int alt5=2;
+ switch ( LA(1) )
+ {
+ case '\r':
+ {
+ alt5=1;
+ }
+ break;
+ }
+
+ switch (alt5)
+ {
+ case 1:
+ // RSP.g:116:11: '\\r'
+ {
+ MATCHC('\r');
+ if (HASEXCEPTION())
+ {
+ goto ruleNEWLINEEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ MATCHC('\n');
+ if (HASEXCEPTION())
+ {
+ goto ruleNEWLINEEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleNEWLINEEx; /* Prevent compiler warnings */
+ ruleNEWLINEEx: ;
+
+}
+// $ANTLR end NEWLINE
+
+// Comes from: 118:4: ( ( ' ' | '\\t' ) )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start WS
+ *
+ * Looks to match the characters the constitute the token WS
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mWS(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = WS;
+
+
+ // RSP.g:118:4: ( ( ' ' | '\\t' ) )
+ // RSP.g:118:6: ( ' ' | '\\t' )
+ {
+ if ( LA(1) == '\t' || LA(1) == ' ' )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleWSEx;
+ }
+
+ {
+ LEXSTATE->channel = HIDDEN;
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleWSEx; /* Prevent compiler warnings */
+ ruleWSEx: ;
+
+}
+// $ANTLR end WS
+
+// Comes from: 120:7: ( 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start FIELD
+ *
+ * Looks to match the characters the constitute the token FIELD
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mFIELD(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = FIELD;
+
+
+ // RSP.g:120:7: ( 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' )
+ // RSP.g:120:9: 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z'
+ {
+ MATCHRANGE('a', 'z');
+ if (HASEXCEPTION())
+ {
+ goto ruleFIELDEx;
+ }
+
+
+ // RSP.g:120:18: ( 'a' .. 'z' | '_' )*
+
+ for (;;)
+ {
+ int alt6=2;
+ switch ( LA(1) )
+ {
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ switch ( LA(2) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt6=1;
+ }
+ break;
+
+ }
+
+ }
+ break;
+ case '_':
+ {
+ alt6=1;
+ }
+ break;
+
+ }
+
+ switch (alt6)
+ {
+ case 1:
+ // RSP.g:
+ {
+ if ( LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleFIELDEx;
+ }
+
+
+ }
+ break;
+
+ default:
+ goto loop6; /* break out of the loop */
+ break;
+ }
+ }
+ loop6: ; /* Jump out to here if this rule does not match */
+
+ MATCHRANGE('a', 'z');
+ if (HASEXCEPTION())
+ {
+ goto ruleFIELDEx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleFIELDEx; /* Prevent compiler warnings */
+ ruleFIELDEx: ;
+
+}
+// $ANTLR end FIELD
+
+// Comes from: 122:5: ( DIGIT19 ( DIGIT09 )* )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start INT
+ *
+ * Looks to match the characters the constitute the token INT
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mINT(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = INT;
+
+
+ // RSP.g:122:5: ( DIGIT19 ( DIGIT09 )* )
+ // RSP.g:122:7: DIGIT19 ( DIGIT09 )*
+ {
+ /* 122:7: DIGIT19 ( DIGIT09 )* */
+ mDIGIT19(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTEx;
+ }
+
+
+ // RSP.g:122:15: ( DIGIT09 )*
+
+ for (;;)
+ {
+ int alt7=2;
+ switch ( LA(1) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ alt7=1;
+ }
+ break;
+
+ }
+
+ switch (alt7)
+ {
+ case 1:
+ // RSP.g:122:15: DIGIT09
+ {
+ /* 122:15: DIGIT09 */
+ mDIGIT09(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTEx;
+ }
+
+
+ }
+ break;
+
+ default:
+ goto loop7; /* break out of the loop */
+ break;
+ }
+ }
+ loop7: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleINTEx; /* Prevent compiler warnings */
+ ruleINTEx: ;
+
+}
+// $ANTLR end INT
+
+// Comes from: 125:6: ( DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DATE
+ *
+ * Looks to match the characters the constitute the token DATE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDATE(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = DATE;
+
+
+ // RSP.g:125:6: ( DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) )
+ // RSP.g:125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' )
+ {
+ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
+ mDIGIT19(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
+ mDIGIT09(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
+ mDIGIT09(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
+ mDIGIT09(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ MATCHC('-');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ // RSP.g:125:44: ( '0' DIGIT19 | '1' '0' .. '2' )
+ {
+ int alt8=2;
+ switch ( LA(1) )
+ {
+ case '0':
+ {
+ alt8=1;
+ }
+ break;
+ case '1':
+ {
+ alt8=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 8;
+ EXCEPTION->state = 0;
+
+
+ goto ruleDATEEx;
+ }
+
+ switch (alt8)
+ {
+ case 1:
+ // RSP.g:125:45: '0' DIGIT19
+ {
+ MATCHC('0');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ /* 125:45: '0' DIGIT19 */
+ mDIGIT19(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:125:59: '1' '0' .. '2'
+ {
+ MATCHC('1');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ MATCHRANGE('0', '2');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ MATCHC('-');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ // RSP.g:125:77: ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' )
+ {
+ int alt9=3;
+ switch ( LA(1) )
+ {
+ case '0':
+ {
+ alt9=1;
+ }
+ break;
+ case '1':
+ case '2':
+ {
+ alt9=2;
+ }
+ break;
+ case '3':
+ {
+ alt9=3;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 0;
+
+
+ goto ruleDATEEx;
+ }
+
+ switch (alt9)
+ {
+ case 1:
+ // RSP.g:125:78: '0' DIGIT19
+ {
+ MATCHC('0');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ /* 125:78: '0' DIGIT19 */
+ mDIGIT19(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:125:92: '1' .. '2' DIGIT09
+ {
+ MATCHRANGE('1', '2');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ /* 125:92: '1' .. '2' DIGIT09 */
+ mDIGIT09(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+ break;
+ case 3:
+ // RSP.g:125:111: '3' '0' .. '1'
+ {
+ MATCHC('3');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ MATCHRANGE('0', '1');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDATEEx; /* Prevent compiler warnings */
+ ruleDATEEx: ;
+
+}
+// $ANTLR end DATE
+
+// Comes from: 133:2: ( QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start STR
+ *
+ * Looks to match the characters the constitute the token STR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mSTR(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+ pANTLR3_COMMON_TOKEN esc;
+ ANTLR3_UINT32 reg;
+
+
+ esc = NULL;
+
+ _type = STR;
+
+ pANTLR3_STRING unesc = GETTEXT()->factory->newRaw(GETTEXT()->factory);
+
+ // RSP.g:133:2: ( QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE )
+ // RSP.g:133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE
+ {
+ /* 133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE */
+ mQUOTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ // RSP.g:133:10: (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+
+ {
+ int cnt10=0;
+
+ for (;;)
+ {
+ int alt10=3;
+ {
+ /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
+ */
+ int LA10_0 = LA(1);
+ if ( (((LA10_0 >= 0x0000) && (LA10_0 <= '!')) || ((LA10_0 >= '#') && (LA10_0 <= '[')) || ((LA10_0 >= ']') && (LA10_0 <= 0xFFFF))) )
+ {
+ alt10=1;
+ }
+ else if ( (LA10_0 == '\\') )
+ {
+ alt10=2;
+ }
+
+ }
+ switch (alt10)
+ {
+ case 1:
+ // RSP.g:133:12: reg=~ ( '\\\\' | '\"' )
+ {
+ reg= LA(1);
+ if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleSTREx;
+ }
+
+ {
+ unesc->addc(unesc, reg);
+ }
+
+ }
+ break;
+ case 2:
+ // RSP.g:134:6: esc= ESCAPED
+ {
+ /* 134:6: esc= ESCAPED */
+ {
+ ANTLR3_MARKER escStart381 = GETCHARINDEX();
+ mESCAPED(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ esc = LEXSTATE->tokFactory->newToken(LEXSTATE->tokFactory);
+ esc->setType(esc, ANTLR3_TOKEN_INVALID);
+ esc->setStartIndex(esc, escStart381);
+ esc->setStopIndex(esc, GETCHARINDEX()-1);
+ esc->input = INPUT;
+ }
+ {
+ unesc->appendS(unesc, GETTEXT());
+ }
+
+ }
+ break;
+
+ default:
+
+ if ( cnt10 >= 1 )
+ {
+ goto loop10;
+ }
+ /* mismatchedSetEx()
+ */
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
+
+
+ goto ruleSTREx;
+ }
+ cnt10++;
+ }
+ loop10: ; /* Jump to here if this rule does not match */
+ }
+ /* 133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE */
+ mQUOTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ {
+ SETTEXT(unesc);
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleSTREx; /* Prevent compiler warnings */
+ ruleSTREx: ;
+
+ esc = NULL;
+
+}
+// $ANTLR end STR
+
+// Comes from: 138:9: ( '\\\\' ( '\\\\' | '\"' ) )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start ESCAPED
+ *
+ * Looks to match the characters the constitute the token ESCAPED
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mESCAPED(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // RSP.g:138:9: ( '\\\\' ( '\\\\' | '\"' ) )
+ // RSP.g:138:11: '\\\\' ( '\\\\' | '\"' )
+ {
+ MATCHC('\\');
+ if (HASEXCEPTION())
+ {
+ goto ruleESCAPEDEx;
+ }
+
+
+ // RSP.g:139:3: ( '\\\\' | '\"' )
+ {
+ int alt11=2;
+ switch ( LA(1) )
+ {
+ case '\\':
+ {
+ alt11=1;
+ }
+ break;
+ case '"':
+ {
+ alt11=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 11;
+ EXCEPTION->state = 0;
+
+
+ goto ruleESCAPEDEx;
+ }
+
+ switch (alt11)
+ {
+ case 1:
+ // RSP.g:139:5: '\\\\'
+ {
+ MATCHC('\\');
+ if (HASEXCEPTION())
+ {
+ goto ruleESCAPEDEx;
+ }
+
+ {
+ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\\"));
+ }
+
+ }
+ break;
+ case 2:
+ // RSP.g:140:5: '\"'
+ {
+ MATCHC('"');
+ if (HASEXCEPTION())
+ {
+ goto ruleESCAPEDEx;
+ }
+
+ {
+ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\""));
+ }
+
+ }
+ break;
+
+ }
+ }
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleESCAPEDEx; /* Prevent compiler warnings */
+ ruleESCAPEDEx: ;
+
+}
+// $ANTLR end ESCAPED
+
+// Comes from: 145:9: ( '0' .. '9' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DIGIT09
+ *
+ * Looks to match the characters the constitute the token DIGIT09
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDIGIT09(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // RSP.g:145:9: ( '0' .. '9' )
+ // RSP.g:145:11: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDIGIT09Ex;
+ }
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDIGIT09Ex; /* Prevent compiler warnings */
+ ruleDIGIT09Ex: ;
+
+}
+// $ANTLR end DIGIT09
+
+// Comes from: 148:9: ( '1' .. '9' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DIGIT19
+ *
+ * Looks to match the characters the constitute the token DIGIT19
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDIGIT19(pRSPLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // RSP.g:148:9: ( '1' .. '9' )
+ // RSP.g:148:11: '1' .. '9'
+ {
+ MATCHRANGE('1', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDIGIT19Ex;
+ }
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDIGIT19Ex; /* Prevent compiler warnings */
+ ruleDIGIT19Ex: ;
+
+}
+// $ANTLR end DIGIT19
+
+/** This is the entry point in to the lexer from an object that
+ * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
+ */
+static void
+mTokens(pRSPLexer ctx)
+{
+ {
+ // 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 )
+
+ ANTLR3_UINT32 alt12;
+
+ alt12=27;
+
+ switch ( LA(1) )
+ {
+ case '"':
+ {
+
+ {
+ int LA12_1 = LA(2);
+ if ( (((LA12_1 >= 0x0000) && (LA12_1 <= '!')) || ((LA12_1 >= '#') && (LA12_1 <= 0xFFFF))) )
+ {
+ alt12=27;
+ }
+ else
+ {
+ alt12=1; }
+ }
+ }
+ break;
+ case '(':
+ {
+ alt12=2;
+ }
+ break;
+ case ')':
+ {
+ alt12=3;
+ }
+ break;
+ case 'a':
+ {
+ switch ( LA(2) )
+ {
+ case 'n':
+ {
+ switch ( LA(3) )
+ {
+ case 'd':
+ {
+ switch ( LA(4) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=4;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case 'f':
+ {
+ switch ( LA(3) )
+ {
+ case 't':
+ {
+ switch ( LA(4) )
+ {
+ case 'e':
+ {
+ switch ( LA(5) )
+ {
+ case 'r':
+ {
+ switch ( LA(6) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=16;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 4;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'o':
+ {
+ switch ( LA(2) )
+ {
+ case 'r':
+ {
+ switch ( LA(3) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=5;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 5;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case '!':
+ {
+ alt12=6;
+ }
+ break;
+ case '=':
+ {
+ alt12=7;
+ }
+ break;
+ case 'i':
+ {
+ switch ( LA(2) )
+ {
+ case 'n':
+ {
+ switch ( LA(3) )
+ {
+ case 'c':
+ {
+ switch ( LA(4) )
+ {
+ case 'l':
+ {
+ switch ( LA(5) )
+ {
+ case 'u':
+ {
+ switch ( LA(6) )
+ {
+ case 'd':
+ {
+ switch ( LA(7) )
+ {
+ case 'e':
+ {
+ switch ( LA(8) )
+ {
+ case 's':
+ {
+ switch ( LA(9) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=8;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 8;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 's':
+ {
+ switch ( LA(2) )
+ {
+ case 't':
+ {
+ switch ( LA(3) )
+ {
+ case 'a':
+ {
+ switch ( LA(4) )
+ {
+ case 'r':
+ {
+ switch ( LA(5) )
+ {
+ case 't':
+ {
+ switch ( LA(6) )
+ {
+ case 's':
+ {
+ switch ( LA(7) )
+ {
+ case 'w':
+ {
+ switch ( LA(8) )
+ {
+ case 'i':
+ {
+ switch ( LA(9) )
+ {
+ case 't':
+ {
+ switch ( LA(10) )
+ {
+ case 'h':
+ {
+ switch ( LA(11) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=9;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 9;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'e':
+ {
+ switch ( LA(2) )
+ {
+ case 'n':
+ {
+ switch ( LA(3) )
+ {
+ case 'd':
+ {
+ switch ( LA(4) )
+ {
+ case 's':
+ {
+ switch ( LA(5) )
+ {
+ case 'w':
+ {
+ switch ( LA(6) )
+ {
+ case 'i':
+ {
+ switch ( LA(7) )
+ {
+ case 't':
+ {
+ switch ( LA(8) )
+ {
+ case 'h':
+ {
+ switch ( LA(9) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=10;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 10;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case '>':
+ {
+ switch ( LA(2) )
+ {
+ case '=':
+ {
+ alt12=13;
+ }
+ break;
+
+ default:
+ alt12=11;}
+
+ }
+ break;
+ case '<':
+ {
+ switch ( LA(2) )
+ {
+ case '=':
+ {
+ alt12=14;
+ }
+ break;
+
+ default:
+ alt12=12;}
+
+ }
+ break;
+ case 'b':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ switch ( LA(3) )
+ {
+ case 'f':
+ {
+ switch ( LA(4) )
+ {
+ case 'o':
+ {
+ switch ( LA(5) )
+ {
+ case 'r':
+ {
+ switch ( LA(6) )
+ {
+ case 'e':
+ {
+ switch ( LA(7) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=15;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 13;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'd':
+ {
+ switch ( LA(2) )
+ {
+ case 'a':
+ {
+ switch ( LA(3) )
+ {
+ case 'y':
+ {
+ switch ( LA(4) )
+ {
+ case 's':
+ {
+ switch ( LA(5) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=17;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=17;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 14;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'w':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ switch ( LA(3) )
+ {
+ case 'e':
+ {
+ switch ( LA(4) )
+ {
+ case 'k':
+ {
+ switch ( LA(5) )
+ {
+ case 's':
+ {
+ switch ( LA(6) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=18;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=18;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 15;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'm':
+ {
+ switch ( LA(2) )
+ {
+ case 'o':
+ {
+ switch ( LA(3) )
+ {
+ case 'n':
+ {
+ switch ( LA(4) )
+ {
+ case 't':
+ {
+ switch ( LA(5) )
+ {
+ case 'h':
+ {
+ switch ( LA(6) )
+ {
+ case 's':
+ {
+ switch ( LA(7) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=19;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=19;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 16;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'y':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ switch ( LA(3) )
+ {
+ case 'a':
+ {
+ switch ( LA(4) )
+ {
+ case 'r':
+ {
+ switch ( LA(5) )
+ {
+ case 's':
+ {
+ switch ( LA(6) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=20;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=20;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 17;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 't':
+ {
+ switch ( LA(2) )
+ {
+ case 'o':
+ {
+ switch ( LA(3) )
+ {
+ case 'd':
+ {
+ switch ( LA(4) )
+ {
+ case 'a':
+ {
+ switch ( LA(5) )
+ {
+ case 'y':
+ {
+ switch ( LA(6) )
+ {
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ alt12=21;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+
+ default:
+ alt12=24;}
+
+ }
+ break;
+ case '_':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 18;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case '\n':
+ case '\r':
+ {
+ alt12=22;
+ }
+ break;
+ case '\t':
+ case ' ':
+ {
+ alt12=23;
+ }
+ break;
+ case 'c':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'n':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 'u':
+ case 'v':
+ case 'x':
+ case 'z':
+ {
+ alt12=24;
+ }
+ break;
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(2) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(3) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(4) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(5) )
+ {
+ case '-':
+ {
+ alt12=26;
+ }
+ break;
+
+ default:
+ alt12=25;}
+
+ }
+ break;
+
+ default:
+ alt12=25;}
+
+ }
+ break;
+
+ default:
+ alt12=25;}
+
+ }
+ break;
+
+ default:
+ alt12=25;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 0;
+
+
+ goto ruleTokensEx;
+ }
+
+ switch (alt12)
+ {
+ case 1:
+ // RSP.g:1:10: QUOTE
+ {
+ /* 1:10: QUOTE */
+ mQUOTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:1:16: LPAR
+ {
+ /* 1:16: LPAR */
+ mLPAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 3:
+ // RSP.g:1:21: RPAR
+ {
+ /* 1:21: RPAR */
+ mRPAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 4:
+ // RSP.g:1:26: AND
+ {
+ /* 1:26: AND */
+ mAND(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 5:
+ // RSP.g:1:30: OR
+ {
+ /* 1:30: OR */
+ mOR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 6:
+ // RSP.g:1:33: NOT
+ {
+ /* 1:33: NOT */
+ mNOT(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 7:
+ // RSP.g:1:37: EQUAL
+ {
+ /* 1:37: EQUAL */
+ mEQUAL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 8:
+ // RSP.g:1:43: INCLUDES
+ {
+ /* 1:43: INCLUDES */
+ mINCLUDES(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 9:
+ // RSP.g:1:52: STARTSW
+ {
+ /* 1:52: STARTSW */
+ mSTARTSW(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 10:
+ // RSP.g:1:60: ENDSW
+ {
+ /* 1:60: ENDSW */
+ mENDSW(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 11:
+ // RSP.g:1:66: GREATER
+ {
+ /* 1:66: GREATER */
+ mGREATER(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 12:
+ // RSP.g:1:74: LESS
+ {
+ /* 1:74: LESS */
+ mLESS(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 13:
+ // RSP.g:1:79: GTE
+ {
+ /* 1:79: GTE */
+ mGTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 14:
+ // RSP.g:1:83: LTE
+ {
+ /* 1:83: LTE */
+ mLTE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 15:
+ // RSP.g:1:87: BEFORE
+ {
+ /* 1:87: BEFORE */
+ mBEFORE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 16:
+ // RSP.g:1:94: AFTER
+ {
+ /* 1:94: AFTER */
+ mAFTER(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 17:
+ // RSP.g:1:100: DAY
+ {
+ /* 1:100: DAY */
+ mDAY(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 18:
+ // RSP.g:1:104: WEEK
+ {
+ /* 1:104: WEEK */
+ mWEEK(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 19:
+ // RSP.g:1:109: MONTH
+ {
+ /* 1:109: MONTH */
+ mMONTH(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 20:
+ // RSP.g:1:115: YEAR
+ {
+ /* 1:115: YEAR */
+ mYEAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 21:
+ // RSP.g:1:120: TODAY
+ {
+ /* 1:120: TODAY */
+ mTODAY(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 22:
+ // RSP.g:1:126: NEWLINE
+ {
+ /* 1:126: NEWLINE */
+ mNEWLINE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 23:
+ // RSP.g:1:134: WS
+ {
+ /* 1:134: WS */
+ mWS(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 24:
+ // RSP.g:1:137: FIELD
+ {
+ /* 1:137: FIELD */
+ mFIELD(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 25:
+ // RSP.g:1:143: INT
+ {
+ /* 1:143: INT */
+ mINT(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 26:
+ // RSP.g:1:147: DATE
+ {
+ /* 1:147: DATE */
+ mDATE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 27:
+ // RSP.g:1:152: STR
+ {
+ /* 1:152: STR */
+ mSTR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+
+
+ goto ruleTokensEx; /* Prevent compiler warnings */
+ruleTokensEx: ;
+}
+
+/* =========================================================================
+ * Lexer matching rules end.
+ * =========================================================================
+ */
+/* End of Lexer code
+ * ================================================
+ * ================================================
+ */
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/RSPLexer.h b/src/pregen/RSPLexer.h
new file mode 100644
index 0000000..27bc791
--- /dev/null
+++ b/src/pregen/RSPLexer.h
@@ -0,0 +1,254 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : RSP.g
+ * - On : 2016-01-01 12:23:42
+ * - for the lexer : RSPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The lexer RSPLexer has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pRSPLexer, which is returned from a call to RSPLexerNew().
+ *
+ * As this is a generated lexer, it is unlikely you will call it 'manually'. However
+ * the methods are provided anyway.
+ * * The methods in pRSPLexer are as follows:
+ *
+ * - void pRSPLexer->QUOTE(pRSPLexer)
+ * - void pRSPLexer->LPAR(pRSPLexer)
+ * - void pRSPLexer->RPAR(pRSPLexer)
+ * - void pRSPLexer->AND(pRSPLexer)
+ * - void pRSPLexer->OR(pRSPLexer)
+ * - void pRSPLexer->NOT(pRSPLexer)
+ * - void pRSPLexer->EQUAL(pRSPLexer)
+ * - void pRSPLexer->INCLUDES(pRSPLexer)
+ * - void pRSPLexer->STARTSW(pRSPLexer)
+ * - void pRSPLexer->ENDSW(pRSPLexer)
+ * - void pRSPLexer->GREATER(pRSPLexer)
+ * - void pRSPLexer->LESS(pRSPLexer)
+ * - void pRSPLexer->GTE(pRSPLexer)
+ * - void pRSPLexer->LTE(pRSPLexer)
+ * - void pRSPLexer->BEFORE(pRSPLexer)
+ * - void pRSPLexer->AFTER(pRSPLexer)
+ * - void pRSPLexer->DAY(pRSPLexer)
+ * - void pRSPLexer->WEEK(pRSPLexer)
+ * - void pRSPLexer->MONTH(pRSPLexer)
+ * - void pRSPLexer->YEAR(pRSPLexer)
+ * - void pRSPLexer->TODAY(pRSPLexer)
+ * - void pRSPLexer->NEWLINE(pRSPLexer)
+ * - void pRSPLexer->WS(pRSPLexer)
+ * - void pRSPLexer->FIELD(pRSPLexer)
+ * - void pRSPLexer->INT(pRSPLexer)
+ * - void pRSPLexer->DATE(pRSPLexer)
+ * - void pRSPLexer->STR(pRSPLexer)
+ * - void pRSPLexer->ESCAPED(pRSPLexer)
+ * - void pRSPLexer->DIGIT09(pRSPLexer)
+ * - void pRSPLexer->DIGIT19(pRSPLexer)
+ * - void pRSPLexer->Tokens(pRSPLexer)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _RSPLexer_H
+#define _RSPLexer_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct RSPLexer_Ctx_struct RSPLexer, * pRSPLexer;
+
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+
+/** Context tracking structure for RSPLexer
+ */
+struct RSPLexer_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_LEXER pLexer;
+
+
+ void (*mQUOTE) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mLPAR) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mRPAR) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mAND) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mOR) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mNOT) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mEQUAL) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mINCLUDES) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mSTARTSW) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mENDSW) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mGREATER) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mLESS) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mGTE) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mLTE) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mBEFORE) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mAFTER) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mDAY) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mWEEK) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mMONTH) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mYEAR) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mTODAY) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mNEWLINE) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mWS) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mFIELD) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mINT) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mDATE) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mSTR) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mESCAPED) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mDIGIT09) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mDIGIT19) (struct RSPLexer_Ctx_struct * ctx);
+ void (*mTokens) (struct RSPLexer_Ctx_struct * ctx); const char * (*getGrammarFileName)();
+ void (*free) (struct RSPLexer_Ctx_struct * ctx);
+
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pRSPLexer RSPLexerNew (pANTLR3_INPUT_STREAM instream);
+ANTLR3_API pRSPLexer RSPLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the lexer will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define STARTSW 14
+#define WEEK 26
+#define TODAY 24
+#define YEAR 28
+#define ENDSW 15
+#define GTE 20
+#define BEFORE 21
+#define DAY 25
+#define INT 16
+#define NOT 11
+#define AFTER 22
+#define AND 6
+#define EOF -1
+#define LTE 19
+#define MONTH 27
+#define DIGIT19 31
+#define INCLUDES 13
+#define STR 10
+#define QUOTE 29
+#define GREATER 18
+#define WS 30
+#define LPAR 7
+#define NEWLINE 4
+#define EQUAL 12
+#define OR 5
+#define LESS 17
+#define FIELD 9
+#define RPAR 8
+#define ESCAPED 33
+#define DATE 23
+#define DIGIT09 32
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for RSPLexer
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/RSPParser.c b/src/pregen/RSPParser.c
new file mode 100644
index 0000000..ba8a9d2
--- /dev/null
+++ b/src/pregen/RSPParser.c
@@ -0,0 +1,3152 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : RSP.g
+ * - On : 2016-01-01 12:23:42
+ * - for the parser : RSPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "RSPParser.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pRSPParser_##scope##_SCOPE
+#define SCOPE_STACK(scope) pRSPParser_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pRSPParser_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pRSPParser_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+/* Macros for accessing things in the parser
+ */
+
+#undef PARSER
+#undef RECOGNIZER
+#undef HAVEPARSEDRULE
+#undef MEMOIZE
+#undef INPUT
+#undef STRSTREAM
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef MATCHT
+#undef MATCHANYT
+#undef FOLLOWSTACK
+#undef FOLLOWPUSH
+#undef FOLLOWPOP
+#undef PRECOVER
+#undef PREPORTERROR
+#undef LA
+#undef LT
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef PERRORRECOVERY
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef RECOVERFROMMISMATCHEDSET
+#undef RECOVERFROMMISMATCHEDELEMENT
+#undef INDEX
+#undef ADAPTOR
+#undef SEEK
+#undef RULEMEMO
+#undef DBG
+
+#define PARSER ctx->pParser
+#define RECOGNIZER PARSER->rec
+#define PSRSTATE RECOGNIZER->state
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
+#define INPUT PARSER->tstream
+#define STRSTREAM INPUT
+#define ISTREAM INPUT->istream
+#define INDEX() ISTREAM->index(INPUT->istream)
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION PSRSTATE->exception
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
+#define FOLLOWSTACK PSRSTATE->following
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
+#define LA(n) INPUT->istream->_LA(ISTREAM, n)
+#define LT(n) INPUT->_LT(INPUT, n)
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define CONSUME() ISTREAM->consume(ISTREAM)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define PERRORRECOVERY PSRSTATE->errorRecovery
+#define FAILEDFLAG PSRSTATE->failed
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
+#define BACKTRACKING PSRSTATE->backtracking
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
+#define ADAPTOR ctx->adaptor
+#define RULEMEMO PSRSTATE->ruleMemo
+#define DBG RECOGNIZER->debugger
+
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+
+/** \brief Table of all token names in symbolic order, mainly used for
+ * error reporting.
+ */
+pANTLR3_UINT8 RSPParserTokenNames[30+4]
+ = {
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
+ (pANTLR3_UINT8) "<EOR>",
+ (pANTLR3_UINT8) "<DOWN>",
+ (pANTLR3_UINT8) "<UP>",
+ (pANTLR3_UINT8) "NEWLINE",
+ (pANTLR3_UINT8) "OR",
+ (pANTLR3_UINT8) "AND",
+ (pANTLR3_UINT8) "LPAR",
+ (pANTLR3_UINT8) "RPAR",
+ (pANTLR3_UINT8) "FIELD",
+ (pANTLR3_UINT8) "STR",
+ (pANTLR3_UINT8) "NOT",
+ (pANTLR3_UINT8) "EQUAL",
+ (pANTLR3_UINT8) "INCLUDES",
+ (pANTLR3_UINT8) "STARTSW",
+ (pANTLR3_UINT8) "ENDSW",
+ (pANTLR3_UINT8) "INT",
+ (pANTLR3_UINT8) "LESS",
+ (pANTLR3_UINT8) "GREATER",
+ (pANTLR3_UINT8) "LTE",
+ (pANTLR3_UINT8) "GTE",
+ (pANTLR3_UINT8) "BEFORE",
+ (pANTLR3_UINT8) "AFTER",
+ (pANTLR3_UINT8) "DATE",
+ (pANTLR3_UINT8) "TODAY",
+ (pANTLR3_UINT8) "DAY",
+ (pANTLR3_UINT8) "WEEK",
+ (pANTLR3_UINT8) "MONTH",
+ (pANTLR3_UINT8) "YEAR",
+ (pANTLR3_UINT8) "QUOTE",
+ (pANTLR3_UINT8) "WS",
+ (pANTLR3_UINT8) "DIGIT19",
+ (pANTLR3_UINT8) "DIGIT09",
+ (pANTLR3_UINT8) "ESCAPED"
+ };
+
+
+
+// Forward declare the locally static matching functions we have generated.
+//
+static RSPParser_query_return query (pRSPParser ctx);
+static RSPParser_expr_return expr (pRSPParser ctx);
+static RSPParser_aexpr_return aexpr (pRSPParser ctx);
+static RSPParser_crit_return crit (pRSPParser ctx);
+static RSPParser_strcrit_return strcrit (pRSPParser ctx);
+static RSPParser_strop_return strop (pRSPParser ctx);
+static RSPParser_intcrit_return intcrit (pRSPParser ctx);
+static RSPParser_intop_return intop (pRSPParser ctx);
+static RSPParser_datecrit_return datecrit (pRSPParser ctx);
+static RSPParser_dateop_return dateop (pRSPParser ctx);
+static RSPParser_datespec_return datespec (pRSPParser ctx);
+static RSPParser_dateref_return dateref (pRSPParser ctx);
+static RSPParser_dateintval_return dateintval (pRSPParser ctx);
+static void RSPParserFree(pRSPParser ctx);
+/* For use in tree output where we are accumulating rule labels via label += ruleRef
+ * we need a function that knows how to free a return scope when the list is destroyed.
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
+ */
+static void ANTLR3_CDECL freeScope(void * scope)
+{
+ ANTLR3_FREE(scope);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "RSP.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+/** \brief Create a new RSPParser parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pRSPParser
+RSPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
+{
+ // See if we can create a new parser with the standard constructor
+ //
+ return RSPParserNewSSD(instream, NULL);
+}
+
+/** \brief Create a new RSPParser parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pRSPParser
+RSPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pRSPParser ctx; /* Context structure we will build and return */
+
+ ctx = (pRSPParser) ANTLR3_CALLOC(1, sizeof(RSPParser));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for parser context
+ //
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * the base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 parser function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in RSPParser.h here, in order that you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base parser/recognizer, using the supplied token stream
+ */
+ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
+ /* Install the implementation of our RSPParser interface
+ */
+ ctx->query = query;
+ ctx->expr = expr;
+ ctx->aexpr = aexpr;
+ ctx->crit = crit;
+ ctx->strcrit = strcrit;
+ ctx->strop = strop;
+ ctx->intcrit = intcrit;
+ ctx->intop = intop;
+ ctx->datecrit = datecrit;
+ ctx->dateop = dateop;
+ ctx->datespec = datespec;
+ ctx->dateref = dateref;
+ ctx->dateintval = dateintval;
+ ctx->free = RSPParserFree;
+ ctx->getGrammarFileName = getGrammarFileName;
+
+ /* Install the scope pushing methods.
+ */
+ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
+ ctx->vectors = antlr3VectorFactoryNew(0);
+
+
+
+ /* Install the token table
+ */
+ PSRSTATE->tokenNames = RSPParserTokenNames;
+
+
+ /* Return the newly built parser to the caller
+ */
+ return ctx;
+}
+
+/** Free the parser resources
+ */
+ static void
+ RSPParserFree(pRSPParser ctx)
+ {
+ /* Free any scope memory
+ */
+
+ ctx->vectors->close(ctx->vectors);
+ /* We created the adaptor so we must free it
+ */
+ ADAPTOR->free(ADAPTOR);
+ // Free this parser
+ //
+ ctx->pParser->free(ctx->pParser);
+ ANTLR3_FREE(ctx);
+
+ /* Everything is released, so we can return
+ */
+ return;
+ }
+
+/** Return token names used by this parser
+ *
+ * The returned pointer is used as an index into the token names table (using the token
+ * number as the index).
+ *
+ * \return Pointer to first char * in the table.
+ */
+static pANTLR3_UINT8 *getTokenNames()
+{
+ return RSPParserTokenNames;
+}
+
+
+/* Declare the bitsets
+ */
+
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query42 */
+static ANTLR3_BITWORD FOLLOW_expr_in_query42_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_query42 = { FOLLOW_expr_in_query42_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_query44 */
+static ANTLR3_BITWORD FOLLOW_NEWLINE_in_query44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) };
+static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_query44 = { FOLLOW_NEWLINE_in_query44_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_query47 */
+static ANTLR3_BITWORD FOLLOW_EOF_in_query47_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EOF_in_query47 = { FOLLOW_EOF_in_query47_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr63 */
+static ANTLR3_BITWORD FOLLOW_aexpr_in_expr63_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
+static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr63 = { FOLLOW_aexpr_in_expr63_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expr66 */
+static ANTLR3_BITWORD FOLLOW_OR_in_expr66_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
+static ANTLR3_BITSET_LIST FOLLOW_OR_in_expr66 = { FOLLOW_OR_in_expr66_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr69 */
+static ANTLR3_BITWORD FOLLOW_aexpr_in_expr69_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
+static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr69 = { FOLLOW_aexpr_in_expr69_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr81 */
+static ANTLR3_BITWORD FOLLOW_crit_in_aexpr81_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
+static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr81 = { FOLLOW_crit_in_aexpr81_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_aexpr84 */
+static ANTLR3_BITWORD FOLLOW_AND_in_aexpr84_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
+static ANTLR3_BITSET_LIST FOLLOW_AND_in_aexpr84 = { FOLLOW_AND_in_aexpr84_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr87 */
+static ANTLR3_BITWORD FOLLOW_crit_in_aexpr87_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
+static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr87 = { FOLLOW_crit_in_aexpr87_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit99 */
+static ANTLR3_BITWORD FOLLOW_LPAR_in_crit99_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
+static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit99 = { FOLLOW_LPAR_in_crit99_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_crit101 */
+static ANTLR3_BITWORD FOLLOW_expr_in_crit101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000100) };
+static ANTLR3_BITSET_LIST FOLLOW_expr_in_crit101 = { FOLLOW_expr_in_crit101_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit103 */
+static ANTLR3_BITWORD FOLLOW_RPAR_in_crit103_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit103 = { FOLLOW_RPAR_in_crit103_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_crit114 */
+static ANTLR3_BITWORD FOLLOW_strcrit_in_crit114_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_crit114 = { FOLLOW_strcrit_in_crit114_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_crit119 */
+static ANTLR3_BITWORD FOLLOW_intcrit_in_crit119_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_crit119 = { FOLLOW_intcrit_in_crit119_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_datecrit_in_crit124 */
+static ANTLR3_BITWORD FOLLOW_datecrit_in_crit124_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_datecrit_in_crit124 = { FOLLOW_datecrit_in_crit124_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit134 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit134_bits[] = { ANTLR3_UINT64_LIT(0x000000000000F000) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit134 = { FOLLOW_FIELD_in_strcrit134_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit136 */
+static ANTLR3_BITWORD FOLLOW_strop_in_strcrit136_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
+static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit136 = { FOLLOW_strop_in_strcrit136_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit138 */
+static ANTLR3_BITWORD FOLLOW_STR_in_strcrit138_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit138 = { FOLLOW_STR_in_strcrit138_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit155 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit155_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit155 = { FOLLOW_FIELD_in_strcrit155_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_strcrit157 */
+static ANTLR3_BITWORD FOLLOW_NOT_in_strcrit157_bits[] = { ANTLR3_UINT64_LIT(0x000000000000F000) };
+static ANTLR3_BITSET_LIST FOLLOW_NOT_in_strcrit157 = { FOLLOW_NOT_in_strcrit157_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit159 */
+static ANTLR3_BITWORD FOLLOW_strop_in_strcrit159_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
+static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit159 = { FOLLOW_strop_in_strcrit159_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit161 */
+static ANTLR3_BITWORD FOLLOW_STR_in_strcrit161_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit161 = { FOLLOW_STR_in_strcrit161_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_strop188 */
+static ANTLR3_BITWORD FOLLOW_EQUAL_in_strop188_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_strop188 = { FOLLOW_EQUAL_in_strop188_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INCLUDES_in_strop195 */
+static ANTLR3_BITWORD FOLLOW_INCLUDES_in_strop195_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_INCLUDES_in_strop195 = { FOLLOW_INCLUDES_in_strop195_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STARTSW_in_strop202 */
+static ANTLR3_BITWORD FOLLOW_STARTSW_in_strop202_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STARTSW_in_strop202 = { FOLLOW_STARTSW_in_strop202_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENDSW_in_strop209 */
+static ANTLR3_BITWORD FOLLOW_ENDSW_in_strop209_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_ENDSW_in_strop209 = { FOLLOW_ENDSW_in_strop209_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit219 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit219_bits[] = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit219 = { FOLLOW_FIELD_in_intcrit219_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit221 */
+static ANTLR3_BITWORD FOLLOW_intop_in_intcrit221_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
+static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit221 = { FOLLOW_intop_in_intcrit221_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit223 */
+static ANTLR3_BITWORD FOLLOW_INT_in_intcrit223_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit223 = { FOLLOW_INT_in_intcrit223_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit240 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit240_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit240 = { FOLLOW_FIELD_in_intcrit240_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_intcrit242 */
+static ANTLR3_BITWORD FOLLOW_NOT_in_intcrit242_bits[] = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
+static ANTLR3_BITSET_LIST FOLLOW_NOT_in_intcrit242 = { FOLLOW_NOT_in_intcrit242_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit244 */
+static ANTLR3_BITWORD FOLLOW_intop_in_intcrit244_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
+static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit244 = { FOLLOW_intop_in_intcrit244_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit246 */
+static ANTLR3_BITWORD FOLLOW_INT_in_intcrit246_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit246 = { FOLLOW_INT_in_intcrit246_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_intop273 */
+static ANTLR3_BITWORD FOLLOW_EQUAL_in_intop273_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_intop273 = { FOLLOW_EQUAL_in_intop273_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LESS_in_intop280 */
+static ANTLR3_BITWORD FOLLOW_LESS_in_intop280_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_LESS_in_intop280 = { FOLLOW_LESS_in_intop280_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_in_intop287 */
+static ANTLR3_BITWORD FOLLOW_GREATER_in_intop287_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_GREATER_in_intop287 = { FOLLOW_GREATER_in_intop287_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LTE_in_intop294 */
+static ANTLR3_BITWORD FOLLOW_LTE_in_intop294_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_LTE_in_intop294 = { FOLLOW_LTE_in_intop294_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_GTE_in_intop301 */
+static ANTLR3_BITWORD FOLLOW_GTE_in_intop301_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_GTE_in_intop301 = { FOLLOW_GTE_in_intop301_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit310 */
+static ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit310_bits[] = { ANTLR3_UINT64_LIT(0x0000000000600000) };
+static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit310 = { FOLLOW_FIELD_in_datecrit310_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit312 */
+static ANTLR3_BITWORD FOLLOW_dateop_in_datecrit312_bits[] = { ANTLR3_UINT64_LIT(0x0000000001810000) };
+static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit312 = { FOLLOW_dateop_in_datecrit312_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit314 */
+static ANTLR3_BITWORD FOLLOW_datespec_in_datecrit314_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit314 = { FOLLOW_datespec_in_datecrit314_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateop337 */
+static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateop337_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateop337 = { FOLLOW_BEFORE_in_dateop337_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateop344 */
+static ANTLR3_BITWORD FOLLOW_AFTER_in_dateop344_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateop344 = { FOLLOW_AFTER_in_dateop344_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec353 */
+static ANTLR3_BITWORD FOLLOW_dateref_in_datespec353_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec353 = { FOLLOW_dateref_in_datespec353_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec358 */
+static ANTLR3_BITWORD FOLLOW_INT_in_datespec358_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec358 = { FOLLOW_INT_in_datespec358_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec360 */
+static ANTLR3_BITWORD FOLLOW_dateintval_in_datespec360_bits[] = { ANTLR3_UINT64_LIT(0x0000000000600000) };
+static ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec360 = { FOLLOW_dateintval_in_datespec360_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec362 */
+static ANTLR3_BITWORD FOLLOW_dateop_in_datespec362_bits[] = { ANTLR3_UINT64_LIT(0x0000000001800000) };
+static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec362 = { FOLLOW_dateop_in_datespec362_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec364 */
+static ANTLR3_BITWORD FOLLOW_dateref_in_datespec364_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec364 = { FOLLOW_dateref_in_datespec364_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateref388 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateref388_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateref388 = { FOLLOW_DATE_in_dateref388_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_TODAY_in_dateref395 */
+static ANTLR3_BITWORD FOLLOW_TODAY_in_dateref395_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_TODAY_in_dateref395 = { FOLLOW_TODAY_in_dateref395_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DAY_in_dateintval408 */
+static ANTLR3_BITWORD FOLLOW_DAY_in_dateintval408_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DAY_in_dateintval408 = { FOLLOW_DAY_in_dateintval408_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_WEEK_in_dateintval415 */
+static ANTLR3_BITWORD FOLLOW_WEEK_in_dateintval415_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_WEEK_in_dateintval415 = { FOLLOW_WEEK_in_dateintval415_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_MONTH_in_dateintval422 */
+static ANTLR3_BITWORD FOLLOW_MONTH_in_dateintval422_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_MONTH_in_dateintval422 = { FOLLOW_MONTH_in_dateintval422_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_YEAR_in_dateintval429 */
+static ANTLR3_BITWORD FOLLOW_YEAR_in_dateintval429_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_YEAR_in_dateintval429 = { FOLLOW_YEAR_in_dateintval429_bits, 1 };
+
+
+
+
+/* ==============================================
+ * Parsing rules
+ */
+/**
+ * $ANTLR start query
+ * RSP.g:27:1: query : expr ( NEWLINE )? EOF -> expr ;
+ */
+static RSPParser_query_return
+query(pRSPParser ctx)
+{
+ RSPParser_query_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN NEWLINE2;
+ pANTLR3_COMMON_TOKEN EOF3;
+ RSPParser_expr_return expr1;
+ #undef RETURN_TYPE_expr1
+ #define RETURN_TYPE_expr1 RSPParser_expr_return
+
+ pANTLR3_BASE_TREE NEWLINE2_tree;
+ pANTLR3_BASE_TREE EOF3_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NEWLINE;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_EOF;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ NEWLINE2 = NULL;
+ EOF3 = NULL;
+ expr1.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ NEWLINE2_tree = NULL;
+ EOF3_tree = NULL;
+
+ stream_NEWLINE = NULL;
+ #define CREATE_stream_NEWLINE if (stream_NEWLINE == NULL) {stream_NEWLINE = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NEWLINE"); }
+ stream_EOF = NULL;
+ #define CREATE_stream_EOF if (stream_EOF == NULL) {stream_EOF = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token EOF"); }
+ stream_expr = NULL;
+ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
+
+ retval.tree = NULL;
+ {
+ // RSP.g:27:7: ( expr ( NEWLINE )? EOF -> expr )
+ // RSP.g:27:9: expr ( NEWLINE )? EOF
+ {
+ FOLLOWPUSH(FOLLOW_expr_in_query42);
+ expr1=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ CREATE_stream_expr; stream_expr->add(stream_expr, expr1.tree, NULL);
+
+ // RSP.g:27:14: ( NEWLINE )?
+ {
+ int alt1=2;
+ switch ( LA(1) )
+ {
+ case NEWLINE:
+ {
+ alt1=1;
+ }
+ break;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // RSP.g:27:14: NEWLINE
+ {
+ NEWLINE2 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_query44);
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ CREATE_stream_NEWLINE; stream_NEWLINE->add(stream_NEWLINE, NEWLINE2, NULL);
+
+
+ }
+ break;
+
+ }
+ }
+ EOF3 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_query47);
+ if (HASEXCEPTION())
+ {
+ goto rulequeryEx;
+ }
+
+ CREATE_stream_EOF; stream_EOF->add(stream_EOF, EOF3, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : expr
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 27:28: -> expr
+ {
+ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulequeryEx; /* Prevent compiler warnings */
+ rulequeryEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_NEWLINE != NULL) stream_NEWLINE->free(stream_NEWLINE);
+ if (stream_EOF != NULL) stream_EOF->free(stream_EOF);
+ if (stream_expr != NULL) stream_expr->free(stream_expr);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end query */
+
+/**
+ * $ANTLR start expr
+ * RSP.g:30:1: expr : aexpr ( OR aexpr )* ;
+ */
+static RSPParser_expr_return
+expr(pRSPParser ctx)
+{
+ RSPParser_expr_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN OR5;
+ RSPParser_aexpr_return aexpr4;
+ #undef RETURN_TYPE_aexpr4
+ #define RETURN_TYPE_aexpr4 RSPParser_aexpr_return
+
+ RSPParser_aexpr_return aexpr6;
+ #undef RETURN_TYPE_aexpr6
+ #define RETURN_TYPE_aexpr6 RSPParser_aexpr_return
+
+ pANTLR3_BASE_TREE OR5_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ OR5 = NULL;
+ aexpr4.tree = NULL;
+
+ aexpr6.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ OR5_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // RSP.g:30:6: ( aexpr ( OR aexpr )* )
+ // RSP.g:30:8: aexpr ( OR aexpr )*
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_aexpr_in_expr63);
+ aexpr4=aexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, aexpr4.tree);
+
+ // RSP.g:30:14: ( OR aexpr )*
+
+ for (;;)
+ {
+ int alt2=2;
+ switch ( LA(1) )
+ {
+ case OR:
+ {
+ alt2=1;
+ }
+ break;
+
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // RSP.g:30:15: OR aexpr
+ {
+ OR5 = (pANTLR3_COMMON_TOKEN) MATCHT(OR, &FOLLOW_OR_in_expr66);
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ OR5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OR5));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OR5_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_aexpr_in_expr69);
+ aexpr6=aexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree);
+
+ }
+ break;
+
+ default:
+ goto loop2; /* break out of the loop */
+ break;
+ }
+ }
+ loop2: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleexprEx; /* Prevent compiler warnings */
+ ruleexprEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end expr */
+
+/**
+ * $ANTLR start aexpr
+ * RSP.g:33:1: aexpr : crit ( AND crit )* ;
+ */
+static RSPParser_aexpr_return
+aexpr(pRSPParser ctx)
+{
+ RSPParser_aexpr_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN AND8;
+ RSPParser_crit_return crit7;
+ #undef RETURN_TYPE_crit7
+ #define RETURN_TYPE_crit7 RSPParser_crit_return
+
+ RSPParser_crit_return crit9;
+ #undef RETURN_TYPE_crit9
+ #define RETURN_TYPE_crit9 RSPParser_crit_return
+
+ pANTLR3_BASE_TREE AND8_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ AND8 = NULL;
+ crit7.tree = NULL;
+
+ crit9.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ AND8_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // RSP.g:33:7: ( crit ( AND crit )* )
+ // RSP.g:33:9: crit ( AND crit )*
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_crit_in_aexpr81);
+ crit7=crit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, crit7.tree);
+
+ // RSP.g:33:14: ( AND crit )*
+
+ for (;;)
+ {
+ int alt3=2;
+ switch ( LA(1) )
+ {
+ case AND:
+ {
+ alt3=1;
+ }
+ break;
+
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // RSP.g:33:15: AND crit
+ {
+ AND8 = (pANTLR3_COMMON_TOKEN) MATCHT(AND, &FOLLOW_AND_in_aexpr84);
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ AND8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AND8));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, AND8_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_crit_in_aexpr87);
+ crit9=crit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, crit9.tree);
+
+ }
+ break;
+
+ default:
+ goto loop3; /* break out of the loop */
+ break;
+ }
+ }
+ loop3: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleaexprEx; /* Prevent compiler warnings */
+ ruleaexprEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end aexpr */
+
+/**
+ * $ANTLR start crit
+ * RSP.g:36:1: crit : ( LPAR expr RPAR -> expr | strcrit | intcrit | datecrit );
+ */
+static RSPParser_crit_return
+crit(pRSPParser ctx)
+{
+ RSPParser_crit_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN LPAR10;
+ pANTLR3_COMMON_TOKEN RPAR12;
+ RSPParser_expr_return expr11;
+ #undef RETURN_TYPE_expr11
+ #define RETURN_TYPE_expr11 RSPParser_expr_return
+
+ RSPParser_strcrit_return strcrit13;
+ #undef RETURN_TYPE_strcrit13
+ #define RETURN_TYPE_strcrit13 RSPParser_strcrit_return
+
+ RSPParser_intcrit_return intcrit14;
+ #undef RETURN_TYPE_intcrit14
+ #define RETURN_TYPE_intcrit14 RSPParser_intcrit_return
+
+ RSPParser_datecrit_return datecrit15;
+ #undef RETURN_TYPE_datecrit15
+ #define RETURN_TYPE_datecrit15 RSPParser_datecrit_return
+
+ pANTLR3_BASE_TREE LPAR10_tree;
+ pANTLR3_BASE_TREE RPAR12_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ LPAR10 = NULL;
+ RPAR12 = NULL;
+ expr11.tree = NULL;
+
+ strcrit13.tree = NULL;
+
+ intcrit14.tree = NULL;
+
+ datecrit15.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ LPAR10_tree = NULL;
+ RPAR12_tree = NULL;
+
+ stream_RPAR = NULL;
+ #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); }
+ stream_LPAR = NULL;
+ #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); }
+ stream_expr = NULL;
+ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:36:6: ( LPAR expr RPAR -> expr | strcrit | intcrit | datecrit )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=4;
+
+ switch ( LA(1) )
+ {
+ case LPAR:
+ {
+ alt4=1;
+ }
+ break;
+ case FIELD:
+ {
+ switch ( LA(2) )
+ {
+ case NOT:
+ {
+ switch ( LA(3) )
+ {
+ case EQUAL:
+ {
+ switch ( LA(4) )
+ {
+ case STR:
+ {
+ alt4=2;
+ }
+ break;
+ case INT:
+ {
+ alt4=3;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 8;
+
+
+ goto rulecritEx;
+ }
+
+ }
+ break;
+ case LESS:
+ case GREATER:
+ case LTE:
+ case GTE:
+ {
+ alt4=3;
+ }
+ break;
+ case INCLUDES:
+ case STARTSW:
+ case ENDSW:
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 3;
+
+
+ goto rulecritEx;
+ }
+
+ }
+ break;
+ case BEFORE:
+ case AFTER:
+ {
+ alt4=4;
+ }
+ break;
+ case EQUAL:
+ {
+ switch ( LA(3) )
+ {
+ case INT:
+ {
+ alt4=3;
+ }
+ break;
+ case STR:
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 5;
+
+
+ goto rulecritEx;
+ }
+
+ }
+ break;
+ case LESS:
+ case GREATER:
+ case LTE:
+ case GTE:
+ {
+ alt4=3;
+ }
+ break;
+ case INCLUDES:
+ case STARTSW:
+ case ENDSW:
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 2;
+
+
+ goto rulecritEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto rulecritEx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // RSP.g:36:8: LPAR expr RPAR
+ {
+ LPAR10 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit99);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR10, NULL);
+
+ FOLLOWPUSH(FOLLOW_expr_in_crit101);
+ expr11=expr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_expr; stream_expr->add(stream_expr, expr11.tree, NULL);
+ RPAR12 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit103);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR12, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : expr
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 36:25: -> expr
+ {
+ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+ case 2:
+ // RSP.g:37:4: strcrit
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_strcrit_in_crit114);
+ strcrit13=strcrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, strcrit13.tree);
+
+ }
+ break;
+ case 3:
+ // RSP.g:38:4: intcrit
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_intcrit_in_crit119);
+ intcrit14=intcrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, intcrit14.tree);
+
+ }
+ break;
+ case 4:
+ // RSP.g:39:4: datecrit
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_datecrit_in_crit124);
+ datecrit15=datecrit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, datecrit15.tree);
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulecritEx; /* Prevent compiler warnings */
+ rulecritEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR);
+ if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR);
+ if (stream_expr != NULL) stream_expr->free(stream_expr);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end crit */
+
+/**
+ * $ANTLR start strcrit
+ * RSP.g:42:1: strcrit : ( FIELD strop STR -> ^( strop FIELD STR ) | FIELD NOT strop STR -> ^( NOT ^( strop FIELD STR ) ) );
+ */
+static RSPParser_strcrit_return
+strcrit(pRSPParser ctx)
+{
+ RSPParser_strcrit_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN FIELD16;
+ pANTLR3_COMMON_TOKEN STR18;
+ pANTLR3_COMMON_TOKEN FIELD19;
+ pANTLR3_COMMON_TOKEN NOT20;
+ pANTLR3_COMMON_TOKEN STR22;
+ RSPParser_strop_return strop17;
+ #undef RETURN_TYPE_strop17
+ #define RETURN_TYPE_strop17 RSPParser_strop_return
+
+ RSPParser_strop_return strop21;
+ #undef RETURN_TYPE_strop21
+ #define RETURN_TYPE_strop21 RSPParser_strop_return
+
+ pANTLR3_BASE_TREE FIELD16_tree;
+ pANTLR3_BASE_TREE STR18_tree;
+ pANTLR3_BASE_TREE FIELD19_tree;
+ pANTLR3_BASE_TREE NOT20_tree;
+ pANTLR3_BASE_TREE STR22_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_STR;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_strop;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ FIELD16 = NULL;
+ STR18 = NULL;
+ FIELD19 = NULL;
+ NOT20 = NULL;
+ STR22 = NULL;
+ strop17.tree = NULL;
+
+ strop21.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ FIELD16_tree = NULL;
+ STR18_tree = NULL;
+ FIELD19_tree = NULL;
+ NOT20_tree = NULL;
+ STR22_tree = NULL;
+
+ stream_STR = NULL;
+ #define CREATE_stream_STR if (stream_STR == NULL) {stream_STR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token STR"); }
+ stream_FIELD = NULL;
+ #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); }
+ stream_NOT = NULL;
+ #define CREATE_stream_NOT if (stream_NOT == NULL) {stream_NOT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NOT"); }
+ stream_strop = NULL;
+ #define CREATE_stream_strop if (stream_strop == NULL) {stream_strop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule strop"); }
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:42:9: ( FIELD strop STR -> ^( strop FIELD STR ) | FIELD NOT strop STR -> ^( NOT ^( strop FIELD STR ) ) )
+
+ ANTLR3_UINT32 alt5;
+
+ alt5=2;
+
+ switch ( LA(1) )
+ {
+ case FIELD:
+ {
+ switch ( LA(2) )
+ {
+ case NOT:
+ {
+ alt5=2;
+ }
+ break;
+ case EQUAL:
+ case INCLUDES:
+ case STARTSW:
+ case ENDSW:
+ {
+ alt5=1;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 1;
+
+
+ goto rulestrcritEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 0;
+
+
+ goto rulestrcritEx;
+ }
+
+ switch (alt5)
+ {
+ case 1:
+ // RSP.g:42:11: FIELD strop STR
+ {
+ FIELD16 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit134);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD16, NULL);
+
+ FOLLOWPUSH(FOLLOW_strop_in_strcrit136);
+ strop17=strop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_strop; stream_strop->add(stream_strop, strop17.tree, NULL);
+ STR18 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_strcrit138);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_STR; stream_STR->add(stream_STR, STR18, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : FIELD, STR, strop
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 42:29: -> ^( strop FIELD STR )
+ {
+ // RSP.g:42:32: ^( strop FIELD STR )
+ {
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_strop == NULL ? NULL : stream_strop->nextNode(stream_strop), root_1));
+
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_STR == NULL ? NULL : stream_STR->nextNode(stream_STR));
+
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+ case 2:
+ // RSP.g:43:4: FIELD NOT strop STR
+ {
+ FIELD19 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit155);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD19, NULL);
+
+ NOT20 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_strcrit157);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT20, NULL);
+
+ FOLLOWPUSH(FOLLOW_strop_in_strcrit159);
+ strop21=strop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_strop; stream_strop->add(stream_strop, strop21.tree, NULL);
+ STR22 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_strcrit161);
+ if (HASEXCEPTION())
+ {
+ goto rulestrcritEx;
+ }
+
+ CREATE_stream_STR; stream_STR->add(stream_STR, STR22, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : STR, FIELD, strop, NOT
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 43:25: -> ^( NOT ^( strop FIELD STR ) )
+ {
+ // RSP.g:43:28: ^( NOT ^( strop FIELD STR ) )
+ {
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_NOT == NULL ? NULL : stream_NOT->nextNode(stream_NOT), root_1));
+
+ // RSP.g:43:34: ^( strop FIELD STR )
+ {
+ pANTLR3_BASE_TREE root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_strop == NULL ? NULL : stream_strop->nextNode(stream_strop), root_2));
+
+ ADAPTOR->addChild(ADAPTOR, root_2, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
+ ADAPTOR->addChild(ADAPTOR, root_2, stream_STR == NULL ? NULL : stream_STR->nextNode(stream_STR));
+
+ ADAPTOR->addChild(ADAPTOR, root_1, root_2);
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulestrcritEx; /* Prevent compiler warnings */
+ rulestrcritEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_STR != NULL) stream_STR->free(stream_STR);
+ if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD);
+ if (stream_NOT != NULL) stream_NOT->free(stream_NOT);
+ if (stream_strop != NULL) stream_strop->free(stream_strop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end strcrit */
+
+/**
+ * $ANTLR start strop
+ * RSP.g:46:1: strop : (equal= EQUAL | includes= INCLUDES | startsw= STARTSW | endsw= ENDSW );
+ */
+static RSPParser_strop_return
+strop(pRSPParser ctx)
+{
+ RSPParser_strop_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN equal;
+ pANTLR3_COMMON_TOKEN includes;
+ pANTLR3_COMMON_TOKEN startsw;
+ pANTLR3_COMMON_TOKEN endsw;
+
+ pANTLR3_BASE_TREE equal_tree;
+ pANTLR3_BASE_TREE includes_tree;
+ pANTLR3_BASE_TREE startsw_tree;
+ pANTLR3_BASE_TREE endsw_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ equal = NULL;
+ includes = NULL;
+ startsw = NULL;
+ endsw = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ equal_tree = NULL;
+ includes_tree = NULL;
+ startsw_tree = NULL;
+ endsw_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:46:7: (equal= EQUAL | includes= INCLUDES | startsw= STARTSW | endsw= ENDSW )
+
+ ANTLR3_UINT32 alt6;
+
+ alt6=4;
+
+ switch ( LA(1) )
+ {
+ case EQUAL:
+ {
+ alt6=1;
+ }
+ break;
+ case INCLUDES:
+ {
+ alt6=2;
+ }
+ break;
+ case STARTSW:
+ {
+ alt6=3;
+ }
+ break;
+ case ENDSW:
+ {
+ alt6=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 6;
+ EXCEPTION->state = 0;
+
+
+ goto rulestropEx;
+ }
+
+ switch (alt6)
+ {
+ case 1:
+ // RSP.g:46:9: equal= EQUAL
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ equal = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_strop188);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ equal_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, equal));
+ ADAPTOR->addChild(ADAPTOR, root_0, equal_tree);
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:47:4: includes= INCLUDES
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ includes = (pANTLR3_COMMON_TOKEN) MATCHT(INCLUDES, &FOLLOW_INCLUDES_in_strop195);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ includes_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, includes));
+ ADAPTOR->addChild(ADAPTOR, root_0, includes_tree);
+
+
+ }
+ break;
+ case 3:
+ // RSP.g:48:4: startsw= STARTSW
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ startsw = (pANTLR3_COMMON_TOKEN) MATCHT(STARTSW, &FOLLOW_STARTSW_in_strop202);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ startsw_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, startsw));
+ ADAPTOR->addChild(ADAPTOR, root_0, startsw_tree);
+
+
+ }
+ break;
+ case 4:
+ // RSP.g:49:4: endsw= ENDSW
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ endsw = (pANTLR3_COMMON_TOKEN) MATCHT(ENDSW, &FOLLOW_ENDSW_in_strop209);
+ if (HASEXCEPTION())
+ {
+ goto rulestropEx;
+ }
+
+ endsw_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, endsw));
+ ADAPTOR->addChild(ADAPTOR, root_0, endsw_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulestropEx; /* Prevent compiler warnings */
+ rulestropEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end strop */
+
+/**
+ * $ANTLR start intcrit
+ * RSP.g:52:1: intcrit : ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) );
+ */
+static RSPParser_intcrit_return
+intcrit(pRSPParser ctx)
+{
+ RSPParser_intcrit_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN FIELD23;
+ pANTLR3_COMMON_TOKEN INT25;
+ pANTLR3_COMMON_TOKEN FIELD26;
+ pANTLR3_COMMON_TOKEN NOT27;
+ pANTLR3_COMMON_TOKEN INT29;
+ RSPParser_intop_return intop24;
+ #undef RETURN_TYPE_intop24
+ #define RETURN_TYPE_intop24 RSPParser_intop_return
+
+ RSPParser_intop_return intop28;
+ #undef RETURN_TYPE_intop28
+ #define RETURN_TYPE_intop28 RSPParser_intop_return
+
+ pANTLR3_BASE_TREE FIELD23_tree;
+ pANTLR3_BASE_TREE INT25_tree;
+ pANTLR3_BASE_TREE FIELD26_tree;
+ pANTLR3_BASE_TREE NOT27_tree;
+ pANTLR3_BASE_TREE INT29_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_intop;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ FIELD23 = NULL;
+ INT25 = NULL;
+ FIELD26 = NULL;
+ NOT27 = NULL;
+ INT29 = NULL;
+ intop24.tree = NULL;
+
+ intop28.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ FIELD23_tree = NULL;
+ INT25_tree = NULL;
+ FIELD26_tree = NULL;
+ NOT27_tree = NULL;
+ INT29_tree = NULL;
+
+ stream_FIELD = NULL;
+ #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); }
+ stream_INT = NULL;
+ #define CREATE_stream_INT if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); }
+ stream_NOT = NULL;
+ #define CREATE_stream_NOT if (stream_NOT == NULL) {stream_NOT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NOT"); }
+ stream_intop = NULL;
+ #define CREATE_stream_intop if (stream_intop == NULL) {stream_intop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule intop"); }
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:52:9: ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) )
+
+ ANTLR3_UINT32 alt7;
+
+ alt7=2;
+
+ switch ( LA(1) )
+ {
+ case FIELD:
+ {
+ switch ( LA(2) )
+ {
+ case NOT:
+ {
+ alt7=2;
+ }
+ break;
+ case EQUAL:
+ case LESS:
+ case GREATER:
+ case LTE:
+ case GTE:
+ {
+ alt7=1;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 7;
+ EXCEPTION->state = 1;
+
+
+ goto ruleintcritEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 7;
+ EXCEPTION->state = 0;
+
+
+ goto ruleintcritEx;
+ }
+
+ switch (alt7)
+ {
+ case 1:
+ // RSP.g:52:11: FIELD intop INT
+ {
+ FIELD23 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit219);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD23, NULL);
+
+ FOLLOWPUSH(FOLLOW_intop_in_intcrit221);
+ intop24=intop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_intop; stream_intop->add(stream_intop, intop24.tree, NULL);
+ INT25 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit223);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_INT; stream_INT->add(stream_INT, INT25, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : FIELD, INT, intop
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 52:29: -> ^( intop FIELD INT )
+ {
+ // RSP.g:52:32: ^( intop FIELD INT )
+ {
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_intop == NULL ? NULL : stream_intop->nextNode(stream_intop), root_1));
+
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT));
+
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+ case 2:
+ // RSP.g:53:4: FIELD NOT intop INT
+ {
+ FIELD26 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit240);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD26, NULL);
+
+ NOT27 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_intcrit242);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT27, NULL);
+
+ FOLLOWPUSH(FOLLOW_intop_in_intcrit244);
+ intop28=intop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_intop; stream_intop->add(stream_intop, intop28.tree, NULL);
+ INT29 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit246);
+ if (HASEXCEPTION())
+ {
+ goto ruleintcritEx;
+ }
+
+ CREATE_stream_INT; stream_INT->add(stream_INT, INT29, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : intop, NOT, INT, FIELD
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 53:25: -> ^( NOT ^( intop FIELD INT ) )
+ {
+ // RSP.g:53:28: ^( NOT ^( intop FIELD INT ) )
+ {
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_NOT == NULL ? NULL : stream_NOT->nextNode(stream_NOT), root_1));
+
+ // RSP.g:53:34: ^( intop FIELD INT )
+ {
+ pANTLR3_BASE_TREE root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_intop == NULL ? NULL : stream_intop->nextNode(stream_intop), root_2));
+
+ ADAPTOR->addChild(ADAPTOR, root_2, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
+ ADAPTOR->addChild(ADAPTOR, root_2, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT));
+
+ ADAPTOR->addChild(ADAPTOR, root_1, root_2);
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleintcritEx; /* Prevent compiler warnings */
+ ruleintcritEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD);
+ if (stream_INT != NULL) stream_INT->free(stream_INT);
+ if (stream_NOT != NULL) stream_NOT->free(stream_NOT);
+ if (stream_intop != NULL) stream_intop->free(stream_intop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end intcrit */
+
+/**
+ * $ANTLR start intop
+ * RSP.g:56:1: intop : (equal= EQUAL | less= LESS | greater= GREATER | lte= LTE | gte= GTE );
+ */
+static RSPParser_intop_return
+intop(pRSPParser ctx)
+{
+ RSPParser_intop_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN equal;
+ pANTLR3_COMMON_TOKEN less;
+ pANTLR3_COMMON_TOKEN greater;
+ pANTLR3_COMMON_TOKEN lte;
+ pANTLR3_COMMON_TOKEN gte;
+
+ pANTLR3_BASE_TREE equal_tree;
+ pANTLR3_BASE_TREE less_tree;
+ pANTLR3_BASE_TREE greater_tree;
+ pANTLR3_BASE_TREE lte_tree;
+ pANTLR3_BASE_TREE gte_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ equal = NULL;
+ less = NULL;
+ greater = NULL;
+ lte = NULL;
+ gte = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ equal_tree = NULL;
+ less_tree = NULL;
+ greater_tree = NULL;
+ lte_tree = NULL;
+ gte_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:56:7: (equal= EQUAL | less= LESS | greater= GREATER | lte= LTE | gte= GTE )
+
+ ANTLR3_UINT32 alt8;
+
+ alt8=5;
+
+ switch ( LA(1) )
+ {
+ case EQUAL:
+ {
+ alt8=1;
+ }
+ break;
+ case LESS:
+ {
+ alt8=2;
+ }
+ break;
+ case GREATER:
+ {
+ alt8=3;
+ }
+ break;
+ case LTE:
+ {
+ alt8=4;
+ }
+ break;
+ case GTE:
+ {
+ alt8=5;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 8;
+ EXCEPTION->state = 0;
+
+
+ goto ruleintopEx;
+ }
+
+ switch (alt8)
+ {
+ case 1:
+ // RSP.g:56:9: equal= EQUAL
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ equal = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_intop273);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ equal_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, equal));
+ ADAPTOR->addChild(ADAPTOR, root_0, equal_tree);
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:57:4: less= LESS
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ less = (pANTLR3_COMMON_TOKEN) MATCHT(LESS, &FOLLOW_LESS_in_intop280);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ less_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, less));
+ ADAPTOR->addChild(ADAPTOR, root_0, less_tree);
+
+
+ }
+ break;
+ case 3:
+ // RSP.g:58:4: greater= GREATER
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ greater = (pANTLR3_COMMON_TOKEN) MATCHT(GREATER, &FOLLOW_GREATER_in_intop287);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ greater_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, greater));
+ ADAPTOR->addChild(ADAPTOR, root_0, greater_tree);
+
+
+ }
+ break;
+ case 4:
+ // RSP.g:59:4: lte= LTE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ lte = (pANTLR3_COMMON_TOKEN) MATCHT(LTE, &FOLLOW_LTE_in_intop294);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ lte_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, lte));
+ ADAPTOR->addChild(ADAPTOR, root_0, lte_tree);
+
+
+ }
+ break;
+ case 5:
+ // RSP.g:60:4: gte= GTE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ gte = (pANTLR3_COMMON_TOKEN) MATCHT(GTE, &FOLLOW_GTE_in_intop301);
+ if (HASEXCEPTION())
+ {
+ goto ruleintopEx;
+ }
+
+ gte_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, gte));
+ ADAPTOR->addChild(ADAPTOR, root_0, gte_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleintopEx; /* Prevent compiler warnings */
+ ruleintopEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end intop */
+
+/**
+ * $ANTLR start datecrit
+ * RSP.g:63:1: datecrit : FIELD dateop datespec -> ^( dateop FIELD datespec ) ;
+ */
+static RSPParser_datecrit_return
+datecrit(pRSPParser ctx)
+{
+ RSPParser_datecrit_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN FIELD30;
+ RSPParser_dateop_return dateop31;
+ #undef RETURN_TYPE_dateop31
+ #define RETURN_TYPE_dateop31 RSPParser_dateop_return
+
+ RSPParser_datespec_return datespec32;
+ #undef RETURN_TYPE_datespec32
+ #define RETURN_TYPE_datespec32 RSPParser_datespec_return
+
+ pANTLR3_BASE_TREE FIELD30_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_datespec;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ FIELD30 = NULL;
+ dateop31.tree = NULL;
+
+ datespec32.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ FIELD30_tree = NULL;
+
+ stream_FIELD = NULL;
+ #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); }
+ stream_datespec = NULL;
+ #define CREATE_stream_datespec if (stream_datespec == NULL) {stream_datespec = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule datespec"); }
+ stream_dateop = NULL;
+ #define CREATE_stream_dateop if (stream_dateop == NULL) {stream_dateop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateop"); }
+
+ retval.tree = NULL;
+ {
+ // RSP.g:63:9: ( FIELD dateop datespec -> ^( dateop FIELD datespec ) )
+ // RSP.g:63:11: FIELD dateop datespec
+ {
+ FIELD30 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit310);
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD30, NULL);
+
+ FOLLOWPUSH(FOLLOW_dateop_in_datecrit312);
+ dateop31=dateop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+ CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop31.tree, NULL);
+ FOLLOWPUSH(FOLLOW_datespec_in_datecrit314);
+ datespec32=datespec(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatecritEx;
+ }
+
+ CREATE_stream_datespec; stream_datespec->add(stream_datespec, datespec32.tree, NULL);
+
+
+ /* AST REWRITE
+ * elements : FIELD, dateop, datespec
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 63:34: -> ^( dateop FIELD datespec )
+ {
+ // RSP.g:63:37: ^( dateop FIELD datespec )
+ {
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_dateop == NULL ? NULL : stream_dateop->nextNode(stream_dateop), root_1));
+
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_datespec == NULL ? NULL : stream_datespec->nextTree(stream_datespec));
+
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledatecritEx; /* Prevent compiler warnings */
+ ruledatecritEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD);
+ if (stream_datespec != NULL) stream_datespec->free(stream_datespec);
+ if (stream_dateop != NULL) stream_dateop->free(stream_dateop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end datecrit */
+
+/**
+ * $ANTLR start dateop
+ * RSP.g:66:1: dateop : (before= BEFORE | after= AFTER );
+ */
+static RSPParser_dateop_return
+dateop(pRSPParser ctx)
+{
+ RSPParser_dateop_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN before;
+ pANTLR3_COMMON_TOKEN after;
+
+ pANTLR3_BASE_TREE before_tree;
+ pANTLR3_BASE_TREE after_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ before = NULL;
+ after = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ before_tree = NULL;
+ after_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:66:8: (before= BEFORE | after= AFTER )
+
+ ANTLR3_UINT32 alt9;
+
+ alt9=2;
+
+ switch ( LA(1) )
+ {
+ case BEFORE:
+ {
+ alt9=1;
+ }
+ break;
+ case AFTER:
+ {
+ alt9=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 0;
+
+
+ goto ruledateopEx;
+ }
+
+ switch (alt9)
+ {
+ case 1:
+ // RSP.g:66:10: before= BEFORE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ before = (pANTLR3_COMMON_TOKEN) MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateop337);
+ if (HASEXCEPTION())
+ {
+ goto ruledateopEx;
+ }
+
+ before_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, before));
+ ADAPTOR->addChild(ADAPTOR, root_0, before_tree);
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:67:4: after= AFTER
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ after = (pANTLR3_COMMON_TOKEN) MATCHT(AFTER, &FOLLOW_AFTER_in_dateop344);
+ if (HASEXCEPTION())
+ {
+ goto ruledateopEx;
+ }
+
+ after_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, after));
+ ADAPTOR->addChild(ADAPTOR, root_0, after_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledateopEx; /* Prevent compiler warnings */
+ ruledateopEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end dateop */
+
+/**
+ * $ANTLR start datespec
+ * RSP.g:70:1: datespec : ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) );
+ */
+static RSPParser_datespec_return
+datespec(pRSPParser ctx)
+{
+ RSPParser_datespec_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN INT34;
+ RSPParser_dateref_return dateref33;
+ #undef RETURN_TYPE_dateref33
+ #define RETURN_TYPE_dateref33 RSPParser_dateref_return
+
+ RSPParser_dateintval_return dateintval35;
+ #undef RETURN_TYPE_dateintval35
+ #define RETURN_TYPE_dateintval35 RSPParser_dateintval_return
+
+ RSPParser_dateop_return dateop36;
+ #undef RETURN_TYPE_dateop36
+ #define RETURN_TYPE_dateop36 RSPParser_dateop_return
+
+ RSPParser_dateref_return dateref37;
+ #undef RETURN_TYPE_dateref37
+ #define RETURN_TYPE_dateref37 RSPParser_dateref_return
+
+ pANTLR3_BASE_TREE INT34_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateintval;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateref;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ INT34 = NULL;
+ dateref33.tree = NULL;
+
+ dateintval35.tree = NULL;
+
+ dateop36.tree = NULL;
+
+ dateref37.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ INT34_tree = NULL;
+
+ stream_INT = NULL;
+ #define CREATE_stream_INT if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); }
+ stream_dateintval = NULL;
+ #define CREATE_stream_dateintval if (stream_dateintval == NULL) {stream_dateintval = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateintval"); }
+ stream_dateref = NULL;
+ #define CREATE_stream_dateref if (stream_dateref == NULL) {stream_dateref = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateref"); }
+ stream_dateop = NULL;
+ #define CREATE_stream_dateop if (stream_dateop == NULL) {stream_dateop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateop"); }
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:70:9: ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) )
+
+ ANTLR3_UINT32 alt10;
+
+ alt10=2;
+
+ switch ( LA(1) )
+ {
+ case DATE:
+ case TODAY:
+ {
+ alt10=1;
+ }
+ break;
+ case INT:
+ {
+ alt10=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 10;
+ EXCEPTION->state = 0;
+
+
+ goto ruledatespecEx;
+ }
+
+ switch (alt10)
+ {
+ case 1:
+ // RSP.g:70:11: dateref
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_dateref_in_datespec353);
+ dateref33=dateref(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, dateref33.tree);
+
+ }
+ break;
+ case 2:
+ // RSP.g:71:4: INT dateintval dateop dateref
+ {
+ INT34 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_datespec358);
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ CREATE_stream_INT; stream_INT->add(stream_INT, INT34, NULL);
+
+ FOLLOWPUSH(FOLLOW_dateintval_in_datespec360);
+ dateintval35=dateintval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ CREATE_stream_dateintval; stream_dateintval->add(stream_dateintval, dateintval35.tree, NULL);
+ FOLLOWPUSH(FOLLOW_dateop_in_datespec362);
+ dateop36=dateop(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop36.tree, NULL);
+ FOLLOWPUSH(FOLLOW_dateref_in_datespec364);
+ dateref37=dateref(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatespecEx;
+ }
+
+ CREATE_stream_dateref; stream_dateref->add(stream_dateref, dateref37.tree, NULL);
+
+
+ /* AST REWRITE
+ * elements : dateop, INT, dateintval, dateref
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 71:34: -> ^( dateop dateref INT dateintval )
+ {
+ // RSP.g:71:37: ^( dateop dateref INT dateintval )
+ {
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_dateop == NULL ? NULL : stream_dateop->nextNode(stream_dateop), root_1));
+
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_dateref == NULL ? NULL : stream_dateref->nextTree(stream_dateref));
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT));
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_dateintval == NULL ? NULL : stream_dateintval->nextTree(stream_dateintval));
+
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
+ }
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledatespecEx; /* Prevent compiler warnings */
+ ruledatespecEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_INT != NULL) stream_INT->free(stream_INT);
+ if (stream_dateintval != NULL) stream_dateintval->free(stream_dateintval);
+ if (stream_dateref != NULL) stream_dateref->free(stream_dateref);
+ if (stream_dateop != NULL) stream_dateop->free(stream_dateop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end datespec */
+
+/**
+ * $ANTLR start dateref
+ * RSP.g:74:1: dateref : (date= DATE | today= TODAY );
+ */
+static RSPParser_dateref_return
+dateref(pRSPParser ctx)
+{
+ RSPParser_dateref_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN date;
+ pANTLR3_COMMON_TOKEN today;
+
+ pANTLR3_BASE_TREE date_tree;
+ pANTLR3_BASE_TREE today_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ date = NULL;
+ today = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ date_tree = NULL;
+ today_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:74:9: (date= DATE | today= TODAY )
+
+ ANTLR3_UINT32 alt11;
+
+ alt11=2;
+
+ switch ( LA(1) )
+ {
+ case DATE:
+ {
+ alt11=1;
+ }
+ break;
+ case TODAY:
+ {
+ alt11=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 11;
+ EXCEPTION->state = 0;
+
+
+ goto ruledaterefEx;
+ }
+
+ switch (alt11)
+ {
+ case 1:
+ // RSP.g:74:11: date= DATE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ date = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateref388);
+ if (HASEXCEPTION())
+ {
+ goto ruledaterefEx;
+ }
+
+ date_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, date));
+ ADAPTOR->addChild(ADAPTOR, root_0, date_tree);
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:75:4: today= TODAY
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ today = (pANTLR3_COMMON_TOKEN) MATCHT(TODAY, &FOLLOW_TODAY_in_dateref395);
+ if (HASEXCEPTION())
+ {
+ goto ruledaterefEx;
+ }
+
+ today_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, today));
+ ADAPTOR->addChild(ADAPTOR, root_0, today_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledaterefEx; /* Prevent compiler warnings */
+ ruledaterefEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end dateref */
+
+/**
+ * $ANTLR start dateintval
+ * RSP.g:78:1: dateintval : (day= DAY | week= WEEK | month= MONTH | year= YEAR );
+ */
+static RSPParser_dateintval_return
+dateintval(pRSPParser ctx)
+{
+ RSPParser_dateintval_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN day;
+ pANTLR3_COMMON_TOKEN week;
+ pANTLR3_COMMON_TOKEN month;
+ pANTLR3_COMMON_TOKEN year;
+
+ pANTLR3_BASE_TREE day_tree;
+ pANTLR3_BASE_TREE week_tree;
+ pANTLR3_BASE_TREE month_tree;
+ pANTLR3_BASE_TREE year_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ day = NULL;
+ week = NULL;
+ month = NULL;
+ year = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ day_tree = NULL;
+ week_tree = NULL;
+ month_tree = NULL;
+ year_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // RSP.g:79:2: (day= DAY | week= WEEK | month= MONTH | year= YEAR )
+
+ ANTLR3_UINT32 alt12;
+
+ alt12=4;
+
+ switch ( LA(1) )
+ {
+ case DAY:
+ {
+ alt12=1;
+ }
+ break;
+ case WEEK:
+ {
+ alt12=2;
+ }
+ break;
+ case MONTH:
+ {
+ alt12=3;
+ }
+ break;
+ case YEAR:
+ {
+ alt12=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 12;
+ EXCEPTION->state = 0;
+
+
+ goto ruledateintvalEx;
+ }
+
+ switch (alt12)
+ {
+ case 1:
+ // RSP.g:79:4: day= DAY
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ day = (pANTLR3_COMMON_TOKEN) MATCHT(DAY, &FOLLOW_DAY_in_dateintval408);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ day_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, day));
+ ADAPTOR->addChild(ADAPTOR, root_0, day_tree);
+
+
+ }
+ break;
+ case 2:
+ // RSP.g:80:4: week= WEEK
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ week = (pANTLR3_COMMON_TOKEN) MATCHT(WEEK, &FOLLOW_WEEK_in_dateintval415);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ week_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, week));
+ ADAPTOR->addChild(ADAPTOR, root_0, week_tree);
+
+
+ }
+ break;
+ case 3:
+ // RSP.g:81:4: month= MONTH
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ month = (pANTLR3_COMMON_TOKEN) MATCHT(MONTH, &FOLLOW_MONTH_in_dateintval422);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ month_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, month));
+ ADAPTOR->addChild(ADAPTOR, root_0, month_tree);
+
+
+ }
+ break;
+ case 4:
+ // RSP.g:82:4: year= YEAR
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ year = (pANTLR3_COMMON_TOKEN) MATCHT(YEAR, &FOLLOW_YEAR_in_dateintval429);
+ if (HASEXCEPTION())
+ {
+ goto ruledateintvalEx;
+ }
+
+ year_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, year));
+ ADAPTOR->addChild(ADAPTOR, root_0, year_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledateintvalEx; /* Prevent compiler warnings */
+ ruledateintvalEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end dateintval */
+/* End of parsing rules
+ * ==============================================
+ */
+
+/* ==============================================
+ * Syntactic predicates
+ */
+/* End of syntactic predicates
+ * ==============================================
+ */
+
+
+
+
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/RSPParser.h b/src/pregen/RSPParser.h
new file mode 100644
index 0000000..1796c0a
--- /dev/null
+++ b/src/pregen/RSPParser.h
@@ -0,0 +1,365 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : RSP.g
+ * - On : 2016-01-01 12:23:42
+ * - for the parser : RSPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The parser RSPParser has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pRSPParser, which is returned from a call to RSPParserNew().
+ *
+ * The methods in pRSPParser are as follows:
+ *
+ * - RSPParser_query_return pRSPParser->query(pRSPParser)
+ * - RSPParser_expr_return pRSPParser->expr(pRSPParser)
+ * - RSPParser_aexpr_return pRSPParser->aexpr(pRSPParser)
+ * - RSPParser_crit_return pRSPParser->crit(pRSPParser)
+ * - RSPParser_strcrit_return pRSPParser->strcrit(pRSPParser)
+ * - RSPParser_strop_return pRSPParser->strop(pRSPParser)
+ * - RSPParser_intcrit_return pRSPParser->intcrit(pRSPParser)
+ * - RSPParser_intop_return pRSPParser->intop(pRSPParser)
+ * - RSPParser_datecrit_return pRSPParser->datecrit(pRSPParser)
+ * - RSPParser_dateop_return pRSPParser->dateop(pRSPParser)
+ * - RSPParser_datespec_return pRSPParser->datespec(pRSPParser)
+ * - RSPParser_dateref_return pRSPParser->dateref(pRSPParser)
+ * - RSPParser_dateintval_return pRSPParser->dateintval(pRSPParser)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _RSPParser_H
+#define _RSPParser_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct RSPParser_Ctx_struct RSPParser, * pRSPParser;
+
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+typedef struct RSPParser_query_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_query_return;
+
+typedef struct RSPParser_expr_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_expr_return;
+
+typedef struct RSPParser_aexpr_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_aexpr_return;
+
+typedef struct RSPParser_crit_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_crit_return;
+
+typedef struct RSPParser_strcrit_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_strcrit_return;
+
+typedef struct RSPParser_strop_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_strop_return;
+
+typedef struct RSPParser_intcrit_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_intcrit_return;
+
+typedef struct RSPParser_intop_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_intop_return;
+
+typedef struct RSPParser_datecrit_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_datecrit_return;
+
+typedef struct RSPParser_dateop_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_dateop_return;
+
+typedef struct RSPParser_datespec_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_datespec_return;
+
+typedef struct RSPParser_dateref_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_dateref_return;
+
+typedef struct RSPParser_dateintval_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ RSPParser_dateintval_return;
+
+
+
+/** Context tracking structure for RSPParser
+ */
+struct RSPParser_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_PARSER pParser;
+
+
+ RSPParser_query_return (*query) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_expr_return (*expr) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_aexpr_return (*aexpr) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_crit_return (*crit) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_strcrit_return (*strcrit) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_strop_return (*strop) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_intcrit_return (*intcrit) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_intop_return (*intop) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_datecrit_return (*datecrit) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_dateop_return (*dateop) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_datespec_return (*datespec) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_dateref_return (*dateref) (struct RSPParser_Ctx_struct * ctx);
+ RSPParser_dateintval_return (*dateintval) (struct RSPParser_Ctx_struct * ctx);
+ // Delegated rules
+ const char * (*getGrammarFileName)();
+ void (*free) (struct RSPParser_Ctx_struct * ctx);
+ /* @headerFile.members() */
+ pANTLR3_BASE_TREE_ADAPTOR adaptor;
+ pANTLR3_VECTOR_FACTORY vectors;
+ /* End @headerFile.members() */
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pRSPParser RSPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream);
+ANTLR3_API pRSPParser RSPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the parser will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define STARTSW 14
+#define WEEK 26
+#define TODAY 24
+#define YEAR 28
+#define ENDSW 15
+#define GTE 20
+#define BEFORE 21
+#define DAY 25
+#define INT 16
+#define NOT 11
+#define AFTER 22
+#define AND 6
+#define EOF -1
+#define LTE 19
+#define MONTH 27
+#define DIGIT19 31
+#define INCLUDES 13
+#define STR 10
+#define QUOTE 29
+#define WS 30
+#define GREATER 18
+#define NEWLINE 4
+#define LPAR 7
+#define EQUAL 12
+#define OR 5
+#define LESS 17
+#define RPAR 8
+#define FIELD 9
+#define ESCAPED 33
+#define DATE 23
+#define DIGIT09 32
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for RSPParser
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/SMARTPL.u b/src/pregen/SMARTPL.u
new file mode 100644
index 0000000..2a66bf3
--- /dev/null
+++ b/src/pregen/SMARTPL.u
@@ -0,0 +1,6 @@
+SMARTPLParser.c : SMARTPL.g
+./SMARTPL.tokens : SMARTPL.g
+SMARTPLParser.h : SMARTPL.g
+SMARTPLLexer.c : SMARTPL.g
+SMARTPLLexer.h : SMARTPL.g
+ANTLR_PRODUCTS += SMARTPLParser.c ./SMARTPL.tokens SMARTPLParser.h SMARTPLLexer.c SMARTPLLexer.h
\ No newline at end of file
diff --git a/src/pregen/SMARTPL2SQL.c b/src/pregen/SMARTPL2SQL.c
new file mode 100644
index 0000000..bd93752
--- /dev/null
+++ b/src/pregen/SMARTPL2SQL.c
@@ -0,0 +1,1649 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : SMARTPL2SQL.g
+ * - On : 2016-01-01 12:23:44
+ * - for the tree parser : SMARTPL2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+/* =============================================================================
+ * This is what the grammar programmer asked us to put at the top of every file.
+ */
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <limits.h>
+ #include <errno.h>
+ #include <time.h>
+ #include <sqlite3.h>
+
+ #include "logger.h"
+ #include "db.h"
+
+/* End of Header action.
+ * =============================================================================
+ */
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "SMARTPL2SQL.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pSMARTPL2SQL_##scope##_SCOPE
+#define SCOPE_STACK(scope) pSMARTPL2SQL_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pSMARTPL2SQL_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pSMARTPL2SQL_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+/* Macros for accessing things in the parser
+ */
+
+#undef PARSER
+#undef RECOGNIZER
+#undef HAVEPARSEDRULE
+#undef INPUT
+#undef STRSTREAM
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef MATCHT
+#undef MATCHANYT
+#undef FOLLOWSTACK
+#undef FOLLOWPUSH
+#undef FOLLOWPOP
+#undef PRECOVER
+#undef PREPORTERROR
+#undef LA
+#undef LT
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef PERRORRECOVERY
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef RECOVERFROMMISMATCHEDSET
+#undef RECOVERFROMMISMATCHEDELEMENT
+#undef BACKTRACKING
+#undef ADAPTOR
+#undef RULEMEMO
+#undef SEEK
+#undef INDEX
+#undef DBG
+
+#define PARSER ctx->pTreeParser
+#define RECOGNIZER PARSER->rec
+#define PSRSTATE RECOGNIZER->state
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define INPUT PARSER->ctnstream
+#define ISTREAM INPUT->tnstream->istream
+#define STRSTREAM INPUT->tnstream
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION PSRSTATE->exception
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
+#define FOLLOWSTACK PSRSTATE->following
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
+#define LA(n) ISTREAM->_LA(ISTREAM, n)
+#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define CONSUME() ISTREAM->consume(ISTREAM)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define PERRORRECOVERY PSRSTATE->errorRecovery
+#define FAILEDFLAG PSRSTATE->failed
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
+#define BACKTRACKING PSRSTATE->backtracking
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
+#define ADAPTOR INPUT->adaptor
+#define RULEMEMO PSRSTATE->ruleMemo
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define INDEX() ISTREAM->index(ISTREAM)
+#define DBG RECOGNIZER->debugger
+
+
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+
+/** \brief Table of all token names in symbolic order, mainly used for
+ * error reporting.
+ */
+pANTLR3_UINT8 SMARTPL2SQLTokenNames[28+4]
+ = {
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
+ (pANTLR3_UINT8) "<EOR>",
+ (pANTLR3_UINT8) "<DOWN>",
+ (pANTLR3_UINT8) "<UP>",
+ (pANTLR3_UINT8) "STR",
+ (pANTLR3_UINT8) "OR",
+ (pANTLR3_UINT8) "AND",
+ (pANTLR3_UINT8) "NOT",
+ (pANTLR3_UINT8) "LPAR",
+ (pANTLR3_UINT8) "RPAR",
+ (pANTLR3_UINT8) "STRTAG",
+ (pANTLR3_UINT8) "INCLUDES",
+ (pANTLR3_UINT8) "IS",
+ (pANTLR3_UINT8) "INTTAG",
+ (pANTLR3_UINT8) "INTBOOL",
+ (pANTLR3_UINT8) "INT",
+ (pANTLR3_UINT8) "DATETAG",
+ (pANTLR3_UINT8) "AFTER",
+ (pANTLR3_UINT8) "BEFORE",
+ (pANTLR3_UINT8) "ENUMTAG",
+ (pANTLR3_UINT8) "ENUMVAL",
+ (pANTLR3_UINT8) "DATE",
+ (pANTLR3_UINT8) "AGO",
+ (pANTLR3_UINT8) "DATINTERVAL",
+ (pANTLR3_UINT8) "GREATER",
+ (pANTLR3_UINT8) "GREATEREQUAL",
+ (pANTLR3_UINT8) "LESS",
+ (pANTLR3_UINT8) "LESSEQUAL",
+ (pANTLR3_UINT8) "EQUAL",
+ (pANTLR3_UINT8) "WHITESPACE",
+ (pANTLR3_UINT8) "'{'",
+ (pANTLR3_UINT8) "'}'"
+ };
+
+
+
+// Forward declare the locally static matching functions we have generated.
+//
+static SMARTPL2SQL_playlist_return playlist (pSMARTPL2SQL ctx);
+static pANTLR3_STRING expression (pSMARTPL2SQL ctx);
+static int dateval (pSMARTPL2SQL ctx);
+static int interval (pSMARTPL2SQL ctx);
+static void SMARTPL2SQLFree(pSMARTPL2SQL ctx);
+/* For use in tree output where we are accumulating rule labels via label += ruleRef
+ * we need a function that knows how to free a return scope when the list is destroyed.
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
+ */
+static void ANTLR3_CDECL freeScope(void * scope)
+{
+ ANTLR3_FREE(scope);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "SMARTPL2SQL.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+/** \brief Create a new SMARTPL2SQL parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pSMARTPL2SQL
+SMARTPL2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
+{
+ // See if we can create a new parser with the standard constructor
+ //
+ return SMARTPL2SQLNewSSD(instream, NULL);
+}
+
+/** \brief Create a new SMARTPL2SQL parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pSMARTPL2SQL
+SMARTPL2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pSMARTPL2SQL ctx; /* Context structure we will build and return */
+
+ ctx = (pSMARTPL2SQL) ANTLR3_CALLOC(1, sizeof(SMARTPL2SQL));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for parser context
+ //
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * the base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 parser function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in SMARTPL2SQL.h here, in order that you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base Tree parser/recognizer, using the supplied tree node stream
+ */
+ ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
+ /* Install the implementation of our SMARTPL2SQL interface
+ */
+ ctx->playlist = playlist;
+ ctx->expression = expression;
+ ctx->dateval = dateval;
+ ctx->interval = interval;
+ ctx->free = SMARTPL2SQLFree;
+ ctx->getGrammarFileName = getGrammarFileName;
+
+ /* Install the scope pushing methods.
+ */
+
+
+
+
+
+ /* Install the token table
+ */
+ PSRSTATE->tokenNames = SMARTPL2SQLTokenNames;
+
+
+ /* Return the newly built parser to the caller
+ */
+ return ctx;
+}
+
+/** Free the parser resources
+ */
+ static void
+ SMARTPL2SQLFree(pSMARTPL2SQL ctx)
+ {
+ /* Free any scope memory
+ */
+
+
+ // Free this parser
+ //
+ ctx->pTreeParser->free(ctx->pTreeParser);
+ ANTLR3_FREE(ctx);
+
+ /* Everything is released, so we can return
+ */
+ return;
+ }
+
+/** Return token names used by this tree parser
+ *
+ * The returned pointer is used as an index into the token names table (using the token
+ * number as the index).
+ *
+ * \return Pointer to first char * in the table.
+ */
+static pANTLR3_UINT8 *getTokenNames()
+{
+ return SMARTPL2SQLTokenNames;
+}
+
+
+
+
+/* Declare the bitsets
+ */
+
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_playlist66 */
+static ANTLR3_BITWORD FOLLOW_STR_in_playlist66_bits[] = { ANTLR3_UINT64_LIT(0x0000000040000000) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_playlist66 = { FOLLOW_STR_in_playlist66_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_30_in_playlist68 */
+static ANTLR3_BITWORD FOLLOW_30_in_playlist68_bits[] = { ANTLR3_UINT64_LIT(0x00000000000924E0) };
+static ANTLR3_BITSET_LIST FOLLOW_30_in_playlist68 = { FOLLOW_30_in_playlist68_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_playlist74 */
+static ANTLR3_BITWORD FOLLOW_expression_in_playlist74_bits[] = { ANTLR3_UINT64_LIT(0x0000000080000000) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_playlist74 = { FOLLOW_expression_in_playlist74_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_31_in_playlist76 */
+static ANTLR3_BITWORD FOLLOW_31_in_playlist76_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_31_in_playlist76 = { FOLLOW_31_in_playlist76_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_expression101 */
+static ANTLR3_BITWORD FOLLOW_NOT_in_expression101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_NOT_in_expression101 = { FOLLOW_NOT_in_expression101_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression107 */
+static ANTLR3_BITWORD FOLLOW_expression_in_expression107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression107 = { FOLLOW_expression_in_expression107_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_expression118 */
+static ANTLR3_BITWORD FOLLOW_AND_in_expression118_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_AND_in_expression118 = { FOLLOW_AND_in_expression118_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression124 */
+static ANTLR3_BITWORD FOLLOW_expression_in_expression124_bits[] = { ANTLR3_UINT64_LIT(0x00000000000924E0) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression124 = { FOLLOW_expression_in_expression124_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression130 */
+static ANTLR3_BITWORD FOLLOW_expression_in_expression130_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression130 = { FOLLOW_expression_in_expression130_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expression141 */
+static ANTLR3_BITWORD FOLLOW_OR_in_expression141_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
+static ANTLR3_BITSET_LIST FOLLOW_OR_in_expression141 = { FOLLOW_OR_in_expression141_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression147 */
+static ANTLR3_BITWORD FOLLOW_expression_in_expression147_bits[] = { ANTLR3_UINT64_LIT(0x00000000000924E0) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression147 = { FOLLOW_expression_in_expression147_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression153 */
+static ANTLR3_BITWORD FOLLOW_expression_in_expression153_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression153 = { FOLLOW_expression_in_expression153_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRTAG_in_expression163 */
+static ANTLR3_BITWORD FOLLOW_STRTAG_in_expression163_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) };
+static ANTLR3_BITSET_LIST FOLLOW_STRTAG_in_expression163 = { FOLLOW_STRTAG_in_expression163_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INCLUDES_in_expression165 */
+static ANTLR3_BITWORD FOLLOW_INCLUDES_in_expression165_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
+static ANTLR3_BITSET_LIST FOLLOW_INCLUDES_in_expression165 = { FOLLOW_INCLUDES_in_expression165_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_expression167 */
+static ANTLR3_BITWORD FOLLOW_STR_in_expression167_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_expression167 = { FOLLOW_STR_in_expression167_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRTAG_in_expression176 */
+static ANTLR3_BITWORD FOLLOW_STRTAG_in_expression176_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001000) };
+static ANTLR3_BITSET_LIST FOLLOW_STRTAG_in_expression176 = { FOLLOW_STRTAG_in_expression176_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_IS_in_expression178 */
+static ANTLR3_BITWORD FOLLOW_IS_in_expression178_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
+static ANTLR3_BITSET_LIST FOLLOW_IS_in_expression178 = { FOLLOW_IS_in_expression178_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_expression180 */
+static ANTLR3_BITWORD FOLLOW_STR_in_expression180_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_expression180 = { FOLLOW_STR_in_expression180_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTTAG_in_expression189 */
+static ANTLR3_BITWORD FOLLOW_INTTAG_in_expression189_bits[] = { ANTLR3_UINT64_LIT(0x0000000000004000) };
+static ANTLR3_BITSET_LIST FOLLOW_INTTAG_in_expression189 = { FOLLOW_INTTAG_in_expression189_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTBOOL_in_expression191 */
+static ANTLR3_BITWORD FOLLOW_INTBOOL_in_expression191_bits[] = { ANTLR3_UINT64_LIT(0x0000000000008000) };
+static ANTLR3_BITSET_LIST FOLLOW_INTBOOL_in_expression191 = { FOLLOW_INTBOOL_in_expression191_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_expression193 */
+static ANTLR3_BITWORD FOLLOW_INT_in_expression193_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_expression193 = { FOLLOW_INT_in_expression193_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATETAG_in_expression202 */
+static ANTLR3_BITWORD FOLLOW_DATETAG_in_expression202_bits[] = { ANTLR3_UINT64_LIT(0x0000000000020000) };
+static ANTLR3_BITSET_LIST FOLLOW_DATETAG_in_expression202 = { FOLLOW_DATETAG_in_expression202_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_expression204 */
+static ANTLR3_BITWORD FOLLOW_AFTER_in_expression204_bits[] = { ANTLR3_UINT64_LIT(0x0000000000208000) };
+static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_expression204 = { FOLLOW_AFTER_in_expression204_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateval_in_expression206 */
+static ANTLR3_BITWORD FOLLOW_dateval_in_expression206_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_dateval_in_expression206 = { FOLLOW_dateval_in_expression206_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATETAG_in_expression215 */
+static ANTLR3_BITWORD FOLLOW_DATETAG_in_expression215_bits[] = { ANTLR3_UINT64_LIT(0x0000000000040000) };
+static ANTLR3_BITSET_LIST FOLLOW_DATETAG_in_expression215 = { FOLLOW_DATETAG_in_expression215_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_expression217 */
+static ANTLR3_BITWORD FOLLOW_BEFORE_in_expression217_bits[] = { ANTLR3_UINT64_LIT(0x0000000000208000) };
+static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_expression217 = { FOLLOW_BEFORE_in_expression217_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateval_in_expression219 */
+static ANTLR3_BITWORD FOLLOW_dateval_in_expression219_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_dateval_in_expression219 = { FOLLOW_dateval_in_expression219_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMTAG_in_expression228 */
+static ANTLR3_BITWORD FOLLOW_ENUMTAG_in_expression228_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001000) };
+static ANTLR3_BITSET_LIST FOLLOW_ENUMTAG_in_expression228 = { FOLLOW_ENUMTAG_in_expression228_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_IS_in_expression230 */
+static ANTLR3_BITWORD FOLLOW_IS_in_expression230_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) };
+static ANTLR3_BITSET_LIST FOLLOW_IS_in_expression230 = { FOLLOW_IS_in_expression230_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMVAL_in_expression232 */
+static ANTLR3_BITWORD FOLLOW_ENUMVAL_in_expression232_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_ENUMVAL_in_expression232 = { FOLLOW_ENUMVAL_in_expression232_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval257 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateval257_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval257 = { FOLLOW_DATE_in_dateval257_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval266 */
+static ANTLR3_BITWORD FOLLOW_interval_in_dateval266_bits[] = { ANTLR3_UINT64_LIT(0x0000000000040000) };
+static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval266 = { FOLLOW_interval_in_dateval266_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateval268 */
+static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateval268_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
+static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateval268 = { FOLLOW_BEFORE_in_dateval268_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval270 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateval270_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval270 = { FOLLOW_DATE_in_dateval270_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval279 */
+static ANTLR3_BITWORD FOLLOW_interval_in_dateval279_bits[] = { ANTLR3_UINT64_LIT(0x0000000000020000) };
+static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval279 = { FOLLOW_interval_in_dateval279_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateval281 */
+static ANTLR3_BITWORD FOLLOW_AFTER_in_dateval281_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
+static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateval281 = { FOLLOW_AFTER_in_dateval281_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval283 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateval283_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval283 = { FOLLOW_DATE_in_dateval283_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval292 */
+static ANTLR3_BITWORD FOLLOW_interval_in_dateval292_bits[] = { ANTLR3_UINT64_LIT(0x0000000000400000) };
+static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval292 = { FOLLOW_interval_in_dateval292_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AGO_in_dateval294 */
+static ANTLR3_BITWORD FOLLOW_AGO_in_dateval294_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_AGO_in_dateval294 = { FOLLOW_AGO_in_dateval294_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_interval318 */
+static ANTLR3_BITWORD FOLLOW_INT_in_interval318_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_interval318 = { FOLLOW_INT_in_interval318_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATINTERVAL_in_interval320 */
+static ANTLR3_BITWORD FOLLOW_DATINTERVAL_in_interval320_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATINTERVAL_in_interval320 = { FOLLOW_DATINTERVAL_in_interval320_bits, 1 };
+
+
+
+
+/* ==============================================
+ * Parsing rules
+ */
+/**
+ * $ANTLR start playlist
+ * SMARTPL2SQL.g:43:1: playlist returns [ pANTLR3_STRING title, pANTLR3_STRING query ] : STR '{' e= expression '}' ;
+ */
+static SMARTPL2SQL_playlist_return
+playlist(pSMARTPL2SQL ctx)
+{
+ SMARTPL2SQL_playlist_return retval;
+
+ pANTLR3_BASE_TREE STR1;
+ pANTLR3_STRING e;
+ #undef RETURN_TYPE_e
+ #define RETURN_TYPE_e pANTLR3_STRING
+
+ /* Initialize rule variables
+ */
+
+
+ retval.title= NULL; retval.query= NULL;
+ STR1 = NULL;
+ e = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ {
+ // SMARTPL2SQL.g:45:2: ( STR '{' e= expression '}' )
+ // SMARTPL2SQL.g:45:4: STR '{' e= expression '}'
+ {
+ STR1 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_playlist66);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ MATCHT(30, &FOLLOW_30_in_playlist68);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expression_in_playlist74);
+ e=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ MATCHT(31, &FOLLOW_31_in_playlist76);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 val;
+ val = (STR1->getText(STR1))->toUTF8((STR1->getText(STR1)))->chars;
+ val++;
+ val[strlen((const char *)val) - 1] = '\0';
+
+ retval.title= (STR1->getText(STR1))->factory->newRaw((STR1->getText(STR1))->factory);
+ retval.title->append8(retval.title, (const char *)val);
+
+ retval.query= e->factory->newRaw(e->factory);
+ retval.query->append8(retval.query, "(");
+ retval.query->appendS(retval.query, e);
+ retval.query->append8(retval.query, ")");
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleplaylistEx; /* Prevent compiler warnings */
+ ruleplaylistEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return retval;
+}
+/* $ANTLR end playlist */
+
+/**
+ * $ANTLR start expression
+ * SMARTPL2SQL.g:62:1: expression returns [ pANTLR3_STRING result ] : ( ^( NOT a= expression ) | ^( AND a= expression b= expression ) | ^( OR a= expression b= expression ) | STRTAG INCLUDES STR | STRTAG IS STR | INTTAG INTBOOL INT | DATETAG AFTER dateval | DATETAG BEFORE dateval | ENUMTAG IS ENUMVAL );
+ */
+static pANTLR3_STRING
+expression(pSMARTPL2SQL ctx)
+{
+ pANTLR3_STRING result = NULL;
+
+ pANTLR3_BASE_TREE STR2;
+ pANTLR3_BASE_TREE STRTAG3;
+ pANTLR3_BASE_TREE STR4;
+ pANTLR3_BASE_TREE STRTAG5;
+ pANTLR3_BASE_TREE INTTAG6;
+ pANTLR3_BASE_TREE INTBOOL7;
+ pANTLR3_BASE_TREE INT8;
+ pANTLR3_BASE_TREE DATETAG10;
+ pANTLR3_BASE_TREE DATETAG12;
+ pANTLR3_BASE_TREE ENUMTAG13;
+ pANTLR3_BASE_TREE ENUMVAL14;
+ pANTLR3_STRING a;
+ #undef RETURN_TYPE_a
+ #define RETURN_TYPE_a pANTLR3_STRING
+
+ pANTLR3_STRING b;
+ #undef RETURN_TYPE_b
+ #define RETURN_TYPE_b pANTLR3_STRING
+
+ int dateval9;
+ #undef RETURN_TYPE_dateval9
+ #define RETURN_TYPE_dateval9 int
+
+ int dateval11;
+ #undef RETURN_TYPE_dateval11
+ #define RETURN_TYPE_dateval11 int
+
+ /* Initialize rule variables
+ */
+
+
+ result= NULL;
+ STR2 = NULL;
+ STRTAG3 = NULL;
+ STR4 = NULL;
+ STRTAG5 = NULL;
+ INTTAG6 = NULL;
+ INTBOOL7 = NULL;
+ INT8 = NULL;
+ DATETAG10 = NULL;
+ DATETAG12 = NULL;
+ ENUMTAG13 = NULL;
+ ENUMVAL14 = NULL;
+ a = NULL;
+ b = NULL;
+ dateval9 = 0;
+ dateval11 = 0;
+
+ {
+ {
+ // SMARTPL2SQL.g:64:2: ( ^( NOT a= expression ) | ^( AND a= expression b= expression ) | ^( OR a= expression b= expression ) | STRTAG INCLUDES STR | STRTAG IS STR | INTTAG INTBOOL INT | DATETAG AFTER dateval | DATETAG BEFORE dateval | ENUMTAG IS ENUMVAL )
+
+ ANTLR3_UINT32 alt1;
+
+ alt1=9;
+
+ switch ( LA(1) )
+ {
+ case NOT:
+ {
+ alt1=1;
+ }
+ break;
+ case AND:
+ {
+ alt1=2;
+ }
+ break;
+ case OR:
+ {
+ alt1=3;
+ }
+ break;
+ case STRTAG:
+ {
+ switch ( LA(2) )
+ {
+ case INCLUDES:
+ {
+ alt1=4;
+ }
+ break;
+ case IS:
+ {
+ alt1=5;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 4;
+
+
+ goto ruleexpressionEx;
+ }
+
+ }
+ break;
+ case INTTAG:
+ {
+ alt1=6;
+ }
+ break;
+ case DATETAG:
+ {
+ switch ( LA(2) )
+ {
+ case AFTER:
+ {
+ alt1=7;
+ }
+ break;
+ case BEFORE:
+ {
+ alt1=8;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 6;
+
+
+ goto ruleexpressionEx;
+ }
+
+ }
+ break;
+ case ENUMTAG:
+ {
+ alt1=9;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 0;
+
+
+ goto ruleexpressionEx;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // SMARTPL2SQL.g:64:4: ^( NOT a= expression )
+ {
+ MATCHT(NOT, &FOLLOW_NOT_in_expression101);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expression_in_expression107);
+ a=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ result= a->factory->newRaw(a->factory);
+ result->append8(result, "NOT(");
+ result->appendS(result, a);
+ result->append8(result, ")");
+
+ }
+
+ }
+ break;
+ case 2:
+ // SMARTPL2SQL.g:71:4: ^( AND a= expression b= expression )
+ {
+ MATCHT(AND, &FOLLOW_AND_in_expression118);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expression_in_expression124);
+ a=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expression_in_expression130);
+ b=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ result= a->factory->newRaw(a->factory);
+ result->append8(result, "(");
+ result->appendS(result, a);
+ result->append8(result, " AND ");
+ result->appendS(result, b);
+ result->append8(result, ")");
+
+ }
+
+ }
+ break;
+ case 3:
+ // SMARTPL2SQL.g:80:4: ^( OR a= expression b= expression )
+ {
+ MATCHT(OR, &FOLLOW_OR_in_expression141);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expression_in_expression147);
+ a=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_expression_in_expression153);
+ b=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+
+ MATCHT(ANTLR3_TOKEN_UP, NULL);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ result= a->factory->newRaw(a->factory);
+ result->append8(result, "(");
+ result->appendS(result, a);
+ result->append8(result, " OR ");
+ result->appendS(result, b);
+ result->append8(result, ")");
+
+ }
+
+ }
+ break;
+ case 4:
+ // SMARTPL2SQL.g:89:4: STRTAG INCLUDES STR
+ {
+ STRTAG3 = (pANTLR3_BASE_TREE) MATCHT(STRTAG, &FOLLOW_STRTAG_in_expression163);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ MATCHT(INCLUDES, &FOLLOW_INCLUDES_in_expression165);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ STR2 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expression167);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 val;
+ val = (STR2->getText(STR2))->toUTF8((STR2->getText(STR2)))->chars;
+ val++;
+ val[strlen((const char *)val) - 1] = '\0';
+
+ result= (STR2->getText(STR2))->factory->newRaw((STR2->getText(STR2))->factory);
+ result->append8(result, "f.");
+ result->appendS(result, (STRTAG3->getText(STRTAG3))->toUTF8((STRTAG3->getText(STRTAG3))));
+ result->append8(result, " LIKE '%");
+ result->append8(result, sqlite3_mprintf("%q", (const char *)val));
+ result->append8(result, "%'");
+
+ }
+
+ }
+ break;
+ case 5:
+ // SMARTPL2SQL.g:103:4: STRTAG IS STR
+ {
+ STRTAG5 = (pANTLR3_BASE_TREE) MATCHT(STRTAG, &FOLLOW_STRTAG_in_expression176);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ MATCHT(IS, &FOLLOW_IS_in_expression178);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ STR4 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expression180);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 val;
+ val = (STR4->getText(STR4))->toUTF8((STR4->getText(STR4)))->chars;
+ val++;
+ val[strlen((const char *)val) - 1] = '\0';
+
+ result= (STR4->getText(STR4))->factory->newRaw((STR4->getText(STR4))->factory);
+ result->append8(result, "f.");
+ result->appendS(result, (STRTAG5->getText(STRTAG5))->toUTF8((STRTAG5->getText(STRTAG5))));
+ result->append8(result, " LIKE '");
+ result->append8(result, sqlite3_mprintf("%q", (const char *)val));
+ result->append8(result, "'");
+
+ }
+
+ }
+ break;
+ case 6:
+ // SMARTPL2SQL.g:117:4: INTTAG INTBOOL INT
+ {
+ INTTAG6 = (pANTLR3_BASE_TREE) MATCHT(INTTAG, &FOLLOW_INTTAG_in_expression189);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ INTBOOL7 = (pANTLR3_BASE_TREE) MATCHT(INTBOOL, &FOLLOW_INTBOOL_in_expression191);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ INT8 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_expression193);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ result= (INTTAG6->getText(INTTAG6))->factory->newRaw((INTTAG6->getText(INTTAG6))->factory);
+ result->append8(result, "f.");
+ result->appendS(result, (INTTAG6->getText(INTTAG6))->toUTF8((INTTAG6->getText(INTTAG6))));
+ result->append8(result, " ");
+ result->appendS(result, (INTBOOL7->getText(INTBOOL7))->toUTF8((INTBOOL7->getText(INTBOOL7))));
+ result->append8(result, " ");
+ result->appendS(result, (INT8->getText(INT8))->toUTF8((INT8->getText(INT8))));
+
+ }
+
+ }
+ break;
+ case 7:
+ // SMARTPL2SQL.g:127:4: DATETAG AFTER dateval
+ {
+ DATETAG10 = (pANTLR3_BASE_TREE) MATCHT(DATETAG, &FOLLOW_DATETAG_in_expression202);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ MATCHT(AFTER, &FOLLOW_AFTER_in_expression204);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_dateval_in_expression206);
+ dateval9=dateval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ char str[15];
+ sprintf(str, "%d", dateval9);
+
+ result= (DATETAG10->getText(DATETAG10))->factory->newRaw((DATETAG10->getText(DATETAG10))->factory);
+ result->append8(result, "f.");
+ result->appendS(result, (DATETAG10->getText(DATETAG10))->toUTF8((DATETAG10->getText(DATETAG10))));
+ result->append8(result, " > ");
+ result->append8(result, str);
+
+ }
+
+ }
+ break;
+ case 8:
+ // SMARTPL2SQL.g:138:4: DATETAG BEFORE dateval
+ {
+ DATETAG12 = (pANTLR3_BASE_TREE) MATCHT(DATETAG, &FOLLOW_DATETAG_in_expression215);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ MATCHT(BEFORE, &FOLLOW_BEFORE_in_expression217);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_dateval_in_expression219);
+ dateval11=dateval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ char str[15];
+ sprintf(str, "%d", dateval11);
+
+ result= (DATETAG12->getText(DATETAG12))->factory->newRaw((DATETAG12->getText(DATETAG12))->factory);
+ result->append8(result, "f.");
+ result->appendS(result, (DATETAG12->getText(DATETAG12))->toUTF8((DATETAG12->getText(DATETAG12))));
+ result->append8(result, " > ");
+ result->append8(result, str);
+
+ }
+
+ }
+ break;
+ case 9:
+ // SMARTPL2SQL.g:149:4: ENUMTAG IS ENUMVAL
+ {
+ ENUMTAG13 = (pANTLR3_BASE_TREE) MATCHT(ENUMTAG, &FOLLOW_ENUMTAG_in_expression228);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ MATCHT(IS, &FOLLOW_IS_in_expression230);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ ENUMVAL14 = (pANTLR3_BASE_TREE) MATCHT(ENUMVAL, &FOLLOW_ENUMVAL_in_expression232);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 tag;
+ pANTLR3_UINT8 val;
+ char str[20];
+
+ sprintf(str, "1=1");
+
+ tag = (ENUMTAG13->getText(ENUMTAG13))->chars;
+ val = (ENUMVAL14->getText(ENUMVAL14))->chars;
+ if (strcmp((char *)tag, "media_kind") == 0)
+ {
+ if (strcmp((char *)val, "music") == 0)
+ {
+ sprintf(str, "f.media_kind = %d", MEDIA_KIND_MUSIC);
+ }
+ else if (strcmp((char *)val, "movie") == 0)
+ {
+ sprintf(str, "f.media_kind = %d", MEDIA_KIND_MOVIE);
+ }
+ else if (strcmp((char *)val, "podcast") == 0)
+ {
+ sprintf(str, "f.media_kind = %d", MEDIA_KIND_PODCAST);
+ }
+ else if (strcmp((char *)val, "audiobook") == 0)
+ {
+ sprintf(str, "f.media_kind = %d", MEDIA_KIND_AUDIOBOOK);
+ }
+ else if (strcmp((char *)val, "tvshow") == 0)
+ {
+ sprintf(str, "f.media_kind = %d", MEDIA_KIND_TVSHOW);
+ }
+ }
+ else if (strcmp((char *)tag, "data_kind") == 0)
+ {
+ if (strcmp((char *)val, "file") == 0)
+ {
+ sprintf(str, "f.data_kind = %d", DATA_KIND_FILE);
+ }
+ else if (strcmp((char *)val, "url") == 0)
+ {
+ sprintf(str, "f.data_kind = %d", DATA_KIND_HTTP);
+ }
+ else if (strcmp((char *)val, "spotify") == 0)
+ {
+ sprintf(str, "f.data_kind = %d", DATA_KIND_SPOTIFY);
+ }
+ else if (strcmp((char *)val, "pipe") == 0)
+ {
+ sprintf(str, "f.data_kind = %d", DATA_KIND_PIPE);
+ }
+ }
+
+ result= (ENUMTAG13->getText(ENUMTAG13))->factory->newRaw((ENUMTAG13->getText(ENUMTAG13))->factory);
+ result->append8(result, str);
+
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleexpressionEx; /* Prevent compiler warnings */
+ ruleexpressionEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return result;
+}
+/* $ANTLR end expression */
+
+/**
+ * $ANTLR start dateval
+ * SMARTPL2SQL.g:207:1: dateval returns [ int result ] : ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO );
+ */
+static int
+dateval(pSMARTPL2SQL ctx)
+{
+ int result = 0;
+
+ pANTLR3_BASE_TREE DATE15;
+ pANTLR3_BASE_TREE DATE16;
+ pANTLR3_BASE_TREE DATE18;
+ int interval17;
+ #undef RETURN_TYPE_interval17
+ #define RETURN_TYPE_interval17 int
+
+ int interval19;
+ #undef RETURN_TYPE_interval19
+ #define RETURN_TYPE_interval19 int
+
+ int interval20;
+ #undef RETURN_TYPE_interval20
+ #define RETURN_TYPE_interval20 int
+
+ /* Initialize rule variables
+ */
+
+
+ result= 0;
+ DATE15 = NULL;
+ DATE16 = NULL;
+ DATE18 = NULL;
+ interval17 = 0;
+ interval19 = 0;
+ interval20 = 0;
+
+ {
+ {
+ // SMARTPL2SQL.g:209:2: ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO )
+
+ ANTLR3_UINT32 alt2;
+
+ alt2=4;
+
+ switch ( LA(1) )
+ {
+ case DATE:
+ {
+ alt2=1;
+ }
+ break;
+ case INT:
+ {
+ switch ( LA(2) )
+ {
+ case DATINTERVAL:
+ {
+ switch ( LA(3) )
+ {
+ case AGO:
+ {
+ alt2=4;
+ }
+ break;
+ case BEFORE:
+ {
+ alt2=2;
+ }
+ break;
+ case AFTER:
+ {
+ alt2=3;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 3;
+
+
+ goto ruledatevalEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 2;
+
+
+ goto ruledatevalEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 0;
+
+
+ goto ruledatevalEx;
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // SMARTPL2SQL.g:209:4: DATE
+ {
+ DATE15 = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateval257);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 datval;
+
+ datval = (DATE15->getText(DATE15))->chars;
+
+ if (strcmp((char *)datval, "today") == 0)
+ {
+ result= time(NULL);
+ }
+ else if (strcmp((char *)datval, "yesterday") == 0)
+ {
+ result= time(NULL) - 24 * 3600;
+ }
+ else if (strcmp((char *)datval, "last week") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 7;
+ }
+ else if (strcmp((char *)datval, "last month") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 30;
+ }
+ else if (strcmp((char *)datval, "last year") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 365;
+ }
+ else
+ {
+ struct tm tm;
+ char year[5];
+ char month[3];
+ char day[3];
+
+ memset((void*)&tm,0,sizeof(tm));
+ memset(year, 0, sizeof(year));
+ memset(month, 0, sizeof(month));
+ memset(day, 0, sizeof(day));
+
+ strncpy(year, (const char *)datval, 4);
+ strncpy(month, (const char *)datval + 5, 2);
+ strncpy(day, (const char *)datval + 8, 2);
+
+ tm.tm_year = atoi(year) - 1900;
+ tm.tm_mon = atoi(month) - 1;
+ tm.tm_mday = atoi(day);
+
+ result= mktime(&tm);
+ }
+
+ }
+
+ }
+ break;
+ case 2:
+ // SMARTPL2SQL.g:258:4: interval BEFORE DATE
+ {
+ FOLLOWPUSH(FOLLOW_interval_in_dateval266);
+ interval17=interval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateval268);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ DATE16 = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateval270);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 datval;
+
+ datval = (DATE16->getText(DATE16))->chars;
+
+ if (strcmp((char *)datval, "yesterday") == 0)
+ {
+ result= time(NULL) - 24 * 3600;
+ }
+ else if (strcmp((char *)datval, "last week") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 7;
+ }
+ else if (strcmp((char *)datval, "last month") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 30;
+ }
+ else if (strcmp((char *)datval, "last year") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 365;
+ }
+ else
+ {
+ result= time(NULL);
+ }
+
+ result= result - interval17;
+
+ }
+
+ }
+ break;
+ case 3:
+ // SMARTPL2SQL.g:287:4: interval AFTER DATE
+ {
+ FOLLOWPUSH(FOLLOW_interval_in_dateval279);
+ interval19=interval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ MATCHT(AFTER, &FOLLOW_AFTER_in_dateval281);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ DATE18 = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateval283);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 datval;
+
+ datval = (DATE18->getText(DATE18))->chars;
+
+ if (strcmp((char *)datval, "yesterday") == 0)
+ {
+ result= time(NULL) - 24 * 3600;
+ }
+ else if (strcmp((char *)datval, "last week") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 7;
+ }
+ else if (strcmp((char *)datval, "last month") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 30;
+ }
+ else if (strcmp((char *)datval, "last year") == 0)
+ {
+ result= time(NULL) - 24 * 3600 * 365;
+ }
+ else
+ {
+ result= time(NULL);
+ }
+
+ result= result + interval19;
+
+ }
+
+ }
+ break;
+ case 4:
+ // SMARTPL2SQL.g:316:4: interval AGO
+ {
+ FOLLOWPUSH(FOLLOW_interval_in_dateval292);
+ interval20=interval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ MATCHT(AGO, &FOLLOW_AGO_in_dateval294);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ {
+
+ result= time(NULL) - interval20;
+
+ }
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledatevalEx; /* Prevent compiler warnings */
+ ruledatevalEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return result;
+}
+/* $ANTLR end dateval */
+
+/**
+ * $ANTLR start interval
+ * SMARTPL2SQL.g:322:1: interval returns [ int result ] : INT DATINTERVAL ;
+ */
+static int
+interval(pSMARTPL2SQL ctx)
+{
+ int result = 0;
+
+ pANTLR3_BASE_TREE INT21;
+ pANTLR3_BASE_TREE DATINTERVAL22;
+
+ /* Initialize rule variables
+ */
+
+
+ result= 0;
+ INT21 = NULL;
+ DATINTERVAL22 = NULL;
+
+ {
+ // SMARTPL2SQL.g:324:2: ( INT DATINTERVAL )
+ // SMARTPL2SQL.g:324:4: INT DATINTERVAL
+ {
+ INT21 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_interval318);
+ if (HASEXCEPTION())
+ {
+ goto ruleintervalEx;
+ }
+
+ DATINTERVAL22 = (pANTLR3_BASE_TREE) MATCHT(DATINTERVAL, &FOLLOW_DATINTERVAL_in_interval320);
+ if (HASEXCEPTION())
+ {
+ goto ruleintervalEx;
+ }
+
+ {
+
+ pANTLR3_UINT8 interval;
+
+ result= atoi((const char *)(INT21->getText(INT21))->chars);
+ interval = (DATINTERVAL22->getText(DATINTERVAL22))->chars;
+
+ if (strcmp((char *)interval, "days") == 0)
+ {
+ result= result * 24 * 3600;
+ }
+ else if (strcmp((char *)interval, "weeks") == 0)
+ {
+ result= result * 24 * 3600 * 7;
+ }
+ else if (strcmp((char *)interval, "months") == 0)
+ {
+ result= result * 24 * 3600 * 30;
+ }
+ else if (strcmp((char *)interval, "weeks") == 0)
+ {
+ result= result * 24 * 3600 * 365;
+ }
+ else
+ {
+ result= 0;
+ }
+
+ }
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleintervalEx; /* Prevent compiler warnings */
+ ruleintervalEx: ;
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ }
+
+
+ return result;
+}
+/* $ANTLR end interval */
+/* End of parsing rules
+ * ==============================================
+ */
+
+/* ==============================================
+ * Syntactic predicates
+ */
+/* End of syntactic predicates
+ * ==============================================
+ */
+
+
+
+
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/SMARTPL2SQL.h b/src/pregen/SMARTPL2SQL.h
new file mode 100644
index 0000000..8e06de7
--- /dev/null
+++ b/src/pregen/SMARTPL2SQL.h
@@ -0,0 +1,220 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : SMARTPL2SQL.g
+ * - On : 2016-01-01 12:23:44
+ * - for the tree parser : SMARTPL2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The tree parser SMARTPL2SQL has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pSMARTPL2SQL, which is returned from a call to SMARTPL2SQLNew().
+ *
+ * The methods in pSMARTPL2SQL are as follows:
+ *
+ * - SMARTPL2SQL_playlist_return pSMARTPL2SQL->playlist(pSMARTPL2SQL)
+ * - pANTLR3_STRING pSMARTPL2SQL->expression(pSMARTPL2SQL)
+ * - int pSMARTPL2SQL->dateval(pSMARTPL2SQL)
+ * - int pSMARTPL2SQL->interval(pSMARTPL2SQL)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _SMARTPL2SQL_H
+#define _SMARTPL2SQL_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct SMARTPL2SQL_Ctx_struct SMARTPL2SQL, * pSMARTPL2SQL;
+
+
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <limits.h>
+ #include <errno.h>
+ #include <time.h>
+ #include <sqlite3.h>
+
+ #include "logger.h"
+ #include "db.h"
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+typedef struct SMARTPL2SQL_playlist_return_struct
+{
+ pANTLR3_BASE_TREE start;
+ pANTLR3_BASE_TREE stop;
+ pANTLR3_STRING title;
+ pANTLR3_STRING query;
+}
+ SMARTPL2SQL_playlist_return;
+
+
+
+/** Context tracking structure for SMARTPL2SQL
+ */
+struct SMARTPL2SQL_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_TREE_PARSER pTreeParser;
+
+
+ SMARTPL2SQL_playlist_return (*playlist) (struct SMARTPL2SQL_Ctx_struct * ctx);
+ pANTLR3_STRING (*expression) (struct SMARTPL2SQL_Ctx_struct * ctx);
+ int (*dateval) (struct SMARTPL2SQL_Ctx_struct * ctx);
+ int (*interval) (struct SMARTPL2SQL_Ctx_struct * ctx);
+ // Delegated rules
+ const char * (*getGrammarFileName)();
+ void (*free) (struct SMARTPL2SQL_Ctx_struct * ctx);
+
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pSMARTPL2SQL SMARTPL2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream);
+ANTLR3_API pSMARTPL2SQL SMARTPL2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the tree parser will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define INTBOOL 14
+#define STRTAG 10
+#define AGO 22
+#define WHITESPACE 29
+#define GREATEREQUAL 25
+#define BEFORE 18
+#define DATETAG 16
+#define INT 15
+#define NOT 7
+#define AFTER 17
+#define AND 6
+#define EOF -1
+#define INCLUDES 11
+#define STR 4
+#define T__30 30
+#define T__31 31
+#define GREATER 24
+#define LPAR 8
+#define ENUMTAG 19
+#define IS 12
+#define ENUMVAL 20
+#define EQUAL 28
+#define OR 5
+#define LESS 26
+#define RPAR 9
+#define DATE 21
+#define LESSEQUAL 27
+#define INTTAG 13
+#define DATINTERVAL 23
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for SMARTPL2SQL
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/SMARTPL2SQL.u b/src/pregen/SMARTPL2SQL.u
new file mode 100644
index 0000000..85567d1
--- /dev/null
+++ b/src/pregen/SMARTPL2SQL.u
@@ -0,0 +1,5 @@
+SMARTPL2SQL.g: SMARTPL.tokens
+SMARTPL2SQL.c : SMARTPL2SQL.g
+./SMARTPL2SQL.tokens : SMARTPL2SQL.g
+SMARTPL2SQL.h : SMARTPL2SQL.g
+ANTLR_PRODUCTS += SMARTPL2SQL.c ./SMARTPL2SQL.tokens SMARTPL2SQL.h
\ No newline at end of file
diff --git a/src/pregen/SMARTPLLexer.c b/src/pregen/SMARTPLLexer.c
new file mode 100644
index 0000000..91d6e99
--- /dev/null
+++ b/src/pregen/SMARTPLLexer.c
@@ -0,0 +1,4168 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : SMARTPL.g
+ * - On : 2016-01-01 12:23:40
+ * - for the lexer : SMARTPLLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "SMARTPLLexer.h"
+/* ----------------------------------------- */
+
+
+/** String literals used by SMARTPLLexer that we must do things like MATCHS() with.
+ * C will normally just lay down 8 bit characters, and you can use L"xxx" to
+ * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
+ * we perform this little trick of defining the literals as arrays of UINT32
+ * and passing in the address of these.
+ */
+static ANTLR3_UCHAR lit_1[] = { 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_2[] = { 0x61, 0x6C, 0x62, 0x75, 0x6D, 0x5F, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_3[] = { 0x61, 0x6C, 0x62, 0x75, 0x6D, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_4[] = { 0x74, 0x69, 0x74, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_5[] = { 0x67, 0x65, 0x6E, 0x72, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_6[] = { 0x63, 0x6F, 0x6D, 0x70, 0x6F, 0x73, 0x65, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_7[] = { 0x70, 0x61, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_8[] = { 0x74, 0x79, 0x70, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_9[] = { 0x67, 0x72, 0x6F, 0x75, 0x70, 0x69, 0x6E, 0x67, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_10[] = { 0x70, 0x6C, 0x61, 0x79, 0x5F, 0x63, 0x6F, 0x75, 0x6E, 0x74, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_11[] = { 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_12[] = { 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_13[] = { 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_14[] = { 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x61, 0x64, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_15[] = { 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x70, 0x6C, 0x61, 0x79, 0x65, 0x64, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_16[] = { 0x64, 0x61, 0x74, 0x61, 0x5F, 0x6B, 0x69, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_17[] = { 0x6D, 0x65, 0x64, 0x69, 0x61, 0x5F, 0x6B, 0x69, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_18[] = { 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_19[] = { 0x69, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_20[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_21[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_22[] = { 0x61, 0x66, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_23[] = { 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_24[] = { 0x61, 0x67, 0x6F, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_25[] = { 0x41, 0x4E, 0x44, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_26[] = { 0x61, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_27[] = { 0x4F, 0x52, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_28[] = { 0x6F, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_29[] = { 0x4E, 0x4F, 0x54, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_30[] = { 0x6E, 0x6F, 0x74, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_31[] = { 0x74, 0x6F, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_32[] = { 0x79, 0x65, 0x73, 0x74, 0x65, 0x72, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_33[] = { 0x6C, 0x61, 0x73, 0x74, 0x20, 0x77, 0x65, 0x65, 0x6B, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_34[] = { 0x6C, 0x61, 0x73, 0x74, 0x20, 0x6D, 0x6F, 0x6E, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_35[] = { 0x6C, 0x61, 0x73, 0x74, 0x20, 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_36[] = { 0x64, 0x61, 0x79, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_37[] = { 0x77, 0x65, 0x65, 0x6B, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_38[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_39[] = { 0x79, 0x65, 0x61, 0x72, 0x73, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_40[] = { 0x6D, 0x75, 0x73, 0x69, 0x63, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_41[] = { 0x6D, 0x6F, 0x76, 0x69, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_42[] = { 0x70, 0x6F, 0x64, 0x63, 0x61, 0x73, 0x74, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_43[] = { 0x61, 0x75, 0x64, 0x69, 0x6F, 0x62, 0x6F, 0x6F, 0x6B, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_44[] = { 0x74, 0x76, 0x73, 0x68, 0x6F, 0x77, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_45[] = { 0x66, 0x69, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_46[] = { 0x75, 0x72, 0x6C, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_47[] = { 0x73, 0x70, 0x6F, 0x74, 0x69, 0x66, 0x79, ANTLR3_STRING_TERMINATOR};
+static ANTLR3_UCHAR lit_48[] = { 0x70, 0x69, 0x70, 0x65, ANTLR3_STRING_TERMINATOR};
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pSMARTPLLexer_##scope##_SCOPE
+#define SCOPE_STACK(scope) pSMARTPLLexer_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pSMARTPLLexer_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pSMARTPLLexer_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+
+/* Macros for accessing things in a lexer
+ */
+#undef LEXER
+#undef RECOGNIZER
+#undef RULEMEMO
+#undef GETCHARINDEX
+#undef GETLINE
+#undef GETCHARPOSITIONINLINE
+#undef EMIT
+#undef EMITNEW
+#undef MATCHC
+#undef MATCHS
+#undef MATCHRANGE
+#undef LTOKEN
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef INPUT
+#undef STRSTREAM
+#undef LA
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef LRECOVER
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef BACKTRACKING
+#undef MATCHANY
+#undef MEMOIZE
+#undef HAVEPARSEDRULE
+#undef GETTEXT
+#undef INDEX
+#undef SEEK
+#undef PUSHSTREAM
+#undef POPSTREAM
+#undef SETTEXT
+#undef SETTEXT8
+
+#define LEXER ctx->pLexer
+#define RECOGNIZER LEXER->rec
+#define LEXSTATE RECOGNIZER->state
+#define TOKSOURCE LEXSTATE->tokSource
+#define GETCHARINDEX() LEXER->getCharIndex(LEXER)
+#define GETLINE() LEXER->getLine(LEXER)
+#define GETTEXT() LEXER->getText(LEXER)
+#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
+#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER)
+#define EMITNEW(t) LEXER->emitNew(LEXER, t)
+#define MATCHC(c) LEXER->matchc(LEXER, c)
+#define MATCHS(s) LEXER->matchs(LEXER, s)
+#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2)
+#define MATCHANY() LEXER->matchAny(LEXER)
+#define LTOKEN LEXSTATE->token
+#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE)
+#define BACKTRACKING LEXSTATE->backtracking
+#define FAILEDFLAG LEXSTATE->failed
+#define INPUT LEXER->input
+#define STRSTREAM INPUT
+#define ISTREAM INPUT->istream
+#define INDEX() ISTREAM->index(ISTREAM)
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken)
+#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION LEXSTATE->exception
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define LRECOVER() LEXER->recover(LEXER)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str)
+#define POPSTREAM() LEXER->popCharStream(LEXER)
+#define SETTEXT(str) LEXSTATE->text = str
+#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken)
+#define USER1 LEXSTATE->user1
+#define USER2 LEXSTATE->user2
+#define USER3 LEXSTATE->user3
+#define CUSTOM LEXSTATE->custom
+#define RULEMEMO LEXSTATE->ruleMemo
+#define DBG RECOGNIZER->debugger
+
+/* If we have been told we can rely on the standard 8 bit or 16 bit input
+ * stream, then we can define our macros to use the direct pointers
+ * in the input object, which is much faster than indirect calls. This
+ * is really only significant to lexers with a lot of fragment rules (which
+ * do not place LA(1) in a temporary at the moment) and even then
+ * only if there is a lot of input (order of say 1M or so).
+ */
+#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
+
+# ifdef ANTLR3_INLINE_INPUT_ASCII
+
+/* 8 bit "ASCII" (actually any 8 bit character set) */
+
+# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar))
+# define DATAP ((pANTLR3_UINT8)(INPUT->data))
+
+# else
+
+# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar))
+# define DATAP ((pANTLR3_UINT16)(INPUT->data))
+
+# endif
+
+# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
+# define CONSUME() \
+{ \
+ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \
+ { \
+ INPUT->charPositionInLine++; \
+ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \
+ { \
+ INPUT->line++; \
+ INPUT->charPositionInLine = 0; \
+ INPUT->currentLine = (void *)(NEXTCHAR + 1); \
+ } \
+ INPUT->nextChar = (void *)(NEXTCHAR + 1); \
+ } \
+}
+
+#else
+
+// Pick up the input character by calling the input stream implementation.
+//
+#define CONSUME() INPUT->istream->consume(INPUT->istream)
+#define LA(n) INPUT->istream->_LA(INPUT->istream, n)
+
+#endif
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+/* Forward declare the locally static matching functions we have generated and any predicate functions.
+ */
+static ANTLR3_INLINE void mT__30 (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mT__31 (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mSTRTAG (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mINTTAG (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mDATETAG (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mENUMTAG (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mINCLUDES (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mIS (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mINTBOOL (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mGREATER (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mGREATEREQUAL (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mLESS (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mLESSEQUAL (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mEQUAL (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mAFTER (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mBEFORE (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mAGO (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mAND (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mOR (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mNOT (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mLPAR (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mRPAR (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mDATE (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mDATINTERVAL (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mENUMVAL (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mSTR (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mINT (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mWHITESPACE (pSMARTPLLexer ctx);
+static ANTLR3_INLINE void mTokens (pSMARTPLLexer ctx);
+static void SMARTPLLexerFree(pSMARTPLLexer ctx);
+
+/* =========================================================================
+ * Lexer matching rules end.
+ * =========================================================================
+ */
+
+
+
+static void
+SMARTPLLexerFree (pSMARTPLLexer ctx)
+{
+ LEXER->free(LEXER);
+
+ ANTLR3_FREE(ctx);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "SMARTPL.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+
+/** \brief Create a new lexer called SMARTPLLexer
+ *
+ * \param[in] instream Pointer to an initialized input stream
+ * \return
+ * - Success pSMARTPLLexer initialized for the lex start
+ * - Fail NULL
+ */
+ANTLR3_API pSMARTPLLexer SMARTPLLexerNew
+(pANTLR3_INPUT_STREAM instream)
+{
+ // See if we can create a new lexer with the standard constructor
+ //
+ return SMARTPLLexerNewSSD(instream, NULL);
+}
+
+/** \brief Create a new lexer called SMARTPLLexer
+ *
+ * \param[in] instream Pointer to an initialized input stream
+ * \param[state] state Previously created shared recognizer stat
+ * \return
+ * - Success pSMARTPLLexer initialized for the lex start
+ * - Fail NULL
+ */
+ANTLR3_API pSMARTPLLexer SMARTPLLexerNewSSD
+(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pSMARTPLLexer ctx; // Context structure we will build and return
+
+ ctx = (pSMARTPLLexer) ANTLR3_CALLOC(1, sizeof(SMARTPLLexer));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for lexer context
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * in base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 lexer function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in SMARTPLLexer.h here so you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base lexer, using the supplied input stream
+ */
+ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
+
+ /* Check that we allocated the memory correctly
+ */
+ if (ctx->pLexer == NULL)
+ {
+ ANTLR3_FREE(ctx);
+ return NULL;
+ }
+ /* Install the implementation of our SMARTPLLexer interface
+ */
+ ctx->mT__30 = mT__30;
+ ctx->mT__31 = mT__31;
+ ctx->mSTRTAG = mSTRTAG;
+ ctx->mINTTAG = mINTTAG;
+ ctx->mDATETAG = mDATETAG;
+ ctx->mENUMTAG = mENUMTAG;
+ ctx->mINCLUDES = mINCLUDES;
+ ctx->mIS = mIS;
+ ctx->mINTBOOL = mINTBOOL;
+ ctx->mGREATER = mGREATER;
+ ctx->mGREATEREQUAL = mGREATEREQUAL;
+ ctx->mLESS = mLESS;
+ ctx->mLESSEQUAL = mLESSEQUAL;
+ ctx->mEQUAL = mEQUAL;
+ ctx->mAFTER = mAFTER;
+ ctx->mBEFORE = mBEFORE;
+ ctx->mAGO = mAGO;
+ ctx->mAND = mAND;
+ ctx->mOR = mOR;
+ ctx->mNOT = mNOT;
+ ctx->mLPAR = mLPAR;
+ ctx->mRPAR = mRPAR;
+ ctx->mDATE = mDATE;
+ ctx->mDATINTERVAL = mDATINTERVAL;
+ ctx->mENUMVAL = mENUMVAL;
+ ctx->mSTR = mSTR;
+ ctx->mINT = mINT;
+ ctx->mWHITESPACE = mWHITESPACE;
+ ctx->mTokens = mTokens;
+
+ /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
+ * it will call mTokens() in this generated code, and will pass it the ctx
+ * pointer of this lexer, not the context of the base lexer, so store that now.
+ */
+ ctx->pLexer->ctx = ctx;
+
+ /**Install the token matching function
+ */
+ ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
+
+ ctx->getGrammarFileName = getGrammarFileName;
+ ctx->free = SMARTPLLexerFree;
+
+
+
+
+
+ /* Return the newly built lexer to the caller
+ */
+ return ctx;
+}
+
+
+/* =========================================================================
+ * Functions to match the lexer grammar defined tokens from the input stream
+ */
+
+// Comes from: 7:7: ( '{' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start T__30
+ *
+ * Looks to match the characters the constitute the token T__30
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mT__30(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = T__30;
+
+
+ // SMARTPL.g:7:7: ( '{' )
+ // SMARTPL.g:7:9: '{'
+ {
+ MATCHC('{');
+ if (HASEXCEPTION())
+ {
+ goto ruleT__30Ex;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleT__30Ex; /* Prevent compiler warnings */
+ ruleT__30Ex: ;
+
+}
+// $ANTLR end T__30
+
+// Comes from: 8:7: ( '}' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start T__31
+ *
+ * Looks to match the characters the constitute the token T__31
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mT__31(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = T__31;
+
+
+ // SMARTPL.g:8:7: ( '}' )
+ // SMARTPL.g:8:9: '}'
+ {
+ MATCHC('}');
+ if (HASEXCEPTION())
+ {
+ goto ruleT__31Ex;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleT__31Ex; /* Prevent compiler warnings */
+ ruleT__31Ex: ;
+
+}
+// $ANTLR end T__31
+
+// Comes from: 56:9: ( 'artist' | 'album_artist' | 'album' | 'title' | 'genre' | 'composer' | 'path' | 'type' | 'grouping' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start STRTAG
+ *
+ * Looks to match the characters the constitute the token STRTAG
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mSTRTAG(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = STRTAG;
+
+
+ {
+ // SMARTPL.g:56:9: ( 'artist' | 'album_artist' | 'album' | 'title' | 'genre' | 'composer' | 'path' | 'type' | 'grouping' )
+
+ ANTLR3_UINT32 alt1;
+
+ alt1=9;
+
+ switch ( LA(1) )
+ {
+ case 'a':
+ {
+ switch ( LA(2) )
+ {
+ case 'r':
+ {
+ alt1=1;
+ }
+ break;
+ case 'l':
+ {
+ switch ( LA(3) )
+ {
+ case 'b':
+ {
+ switch ( LA(4) )
+ {
+ case 'u':
+ {
+ switch ( LA(5) )
+ {
+ case 'm':
+ {
+ switch ( LA(6) )
+ {
+ case '_':
+ {
+ alt1=2;
+ }
+ break;
+
+ default:
+ alt1=3;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 13;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 12;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 7;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 1;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ }
+ break;
+ case 't':
+ {
+ switch ( LA(2) )
+ {
+ case 'i':
+ {
+ alt1=4;
+ }
+ break;
+ case 'y':
+ {
+ alt1=8;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 2;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ }
+ break;
+ case 'g':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ alt1=5;
+ }
+ break;
+ case 'r':
+ {
+ alt1=9;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 3;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ }
+ break;
+ case 'c':
+ {
+ alt1=6;
+ }
+ break;
+ case 'p':
+ {
+ alt1=7;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 1;
+ EXCEPTION->state = 0;
+
+
+ goto ruleSTRTAGEx;
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // SMARTPL.g:56:11: 'artist'
+ {
+ MATCHS(lit_1);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:57:6: 'album_artist'
+ {
+ MATCHS(lit_2);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:58:6: 'album'
+ {
+ MATCHS(lit_3);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:59:6: 'title'
+ {
+ MATCHS(lit_4);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 5:
+ // SMARTPL.g:60:6: 'genre'
+ {
+ MATCHS(lit_5);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 6:
+ // SMARTPL.g:61:6: 'composer'
+ {
+ MATCHS(lit_6);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 7:
+ // SMARTPL.g:62:6: 'path'
+ {
+ MATCHS(lit_7);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 8:
+ // SMARTPL.g:63:6: 'type'
+ {
+ MATCHS(lit_8);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 9:
+ // SMARTPL.g:64:6: 'grouping'
+ {
+ MATCHS(lit_9);
+ if (HASEXCEPTION())
+ {
+ goto ruleSTRTAGEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleSTRTAGEx; /* Prevent compiler warnings */
+ ruleSTRTAGEx: ;
+
+}
+// $ANTLR end STRTAG
+
+// Comes from: 67:9: ( 'play_count' | 'rating' | 'year' | 'compilation' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start INTTAG
+ *
+ * Looks to match the characters the constitute the token INTTAG
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mINTTAG(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = INTTAG;
+
+
+ {
+ // SMARTPL.g:67:9: ( 'play_count' | 'rating' | 'year' | 'compilation' )
+
+ ANTLR3_UINT32 alt2;
+
+ alt2=4;
+
+ switch ( LA(1) )
+ {
+ case 'p':
+ {
+ alt2=1;
+ }
+ break;
+ case 'r':
+ {
+ alt2=2;
+ }
+ break;
+ case 'y':
+ {
+ alt2=3;
+ }
+ break;
+ case 'c':
+ {
+ alt2=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 2;
+ EXCEPTION->state = 0;
+
+
+ goto ruleINTTAGEx;
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // SMARTPL.g:67:11: 'play_count'
+ {
+ MATCHS(lit_10);
+ if (HASEXCEPTION())
+ {
+ goto ruleINTTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:68:6: 'rating'
+ {
+ MATCHS(lit_11);
+ if (HASEXCEPTION())
+ {
+ goto ruleINTTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:69:6: 'year'
+ {
+ MATCHS(lit_12);
+ if (HASEXCEPTION())
+ {
+ goto ruleINTTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:70:6: 'compilation'
+ {
+ MATCHS(lit_13);
+ if (HASEXCEPTION())
+ {
+ goto ruleINTTAGEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleINTTAGEx; /* Prevent compiler warnings */
+ ruleINTTAGEx: ;
+
+}
+// $ANTLR end INTTAG
+
+// Comes from: 73:10: ( 'time_added' | 'time_played' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DATETAG
+ *
+ * Looks to match the characters the constitute the token DATETAG
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDATETAG(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = DATETAG;
+
+
+ {
+ // SMARTPL.g:73:10: ( 'time_added' | 'time_played' )
+
+ ANTLR3_UINT32 alt3;
+
+ alt3=2;
+
+ switch ( LA(1) )
+ {
+ case 't':
+ {
+ switch ( LA(2) )
+ {
+ case 'i':
+ {
+ switch ( LA(3) )
+ {
+ case 'm':
+ {
+ switch ( LA(4) )
+ {
+ case 'e':
+ {
+ switch ( LA(5) )
+ {
+ case '_':
+ {
+ switch ( LA(6) )
+ {
+ case 'a':
+ {
+ alt3=1;
+ }
+ break;
+ case 'p':
+ {
+ alt3=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 5;
+
+
+ goto ruleDATETAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 4;
+
+
+ goto ruleDATETAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 3;
+
+
+ goto ruleDATETAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 2;
+
+
+ goto ruleDATETAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 1;
+
+
+ goto ruleDATETAGEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 0;
+
+
+ goto ruleDATETAGEx;
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // SMARTPL.g:73:12: 'time_added'
+ {
+ MATCHS(lit_14);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATETAGEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:74:6: 'time_played'
+ {
+ MATCHS(lit_15);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATETAGEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDATETAGEx; /* Prevent compiler warnings */
+ ruleDATETAGEx: ;
+
+}
+// $ANTLR end DATETAG
+
+// Comes from: 77:10: ( 'data_kind' | 'media_kind' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start ENUMTAG
+ *
+ * Looks to match the characters the constitute the token ENUMTAG
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mENUMTAG(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = ENUMTAG;
+
+
+ {
+ // SMARTPL.g:77:10: ( 'data_kind' | 'media_kind' )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=2;
+
+ switch ( LA(1) )
+ {
+ case 'd':
+ {
+ alt4=1;
+ }
+ break;
+ case 'm':
+ {
+ alt4=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto ruleENUMTAGEx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // SMARTPL.g:77:12: 'data_kind'
+ {
+ MATCHS(lit_16);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMTAGEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:78:6: 'media_kind'
+ {
+ MATCHS(lit_17);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMTAGEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleENUMTAGEx; /* Prevent compiler warnings */
+ ruleENUMTAGEx: ;
+
+}
+// $ANTLR end ENUMTAG
+
+// Comes from: 81:10: ( 'includes' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start INCLUDES
+ *
+ * Looks to match the characters the constitute the token INCLUDES
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mINCLUDES(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = INCLUDES;
+
+
+ // SMARTPL.g:81:10: ( 'includes' )
+ // SMARTPL.g:81:12: 'includes'
+ {
+ MATCHS(lit_18);
+ if (HASEXCEPTION())
+ {
+ goto ruleINCLUDESEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleINCLUDESEx; /* Prevent compiler warnings */
+ ruleINCLUDESEx: ;
+
+}
+// $ANTLR end INCLUDES
+
+// Comes from: 84:6: ( 'is' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start IS
+ *
+ * Looks to match the characters the constitute the token IS
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mIS(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = IS;
+
+
+ // SMARTPL.g:84:6: ( 'is' )
+ // SMARTPL.g:84:8: 'is'
+ {
+ MATCHS(lit_19);
+ if (HASEXCEPTION())
+ {
+ goto ruleISEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleISEx; /* Prevent compiler warnings */
+ ruleISEx: ;
+
+}
+// $ANTLR end IS
+
+// Comes from: 87:10: ( ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL ) )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start INTBOOL
+ *
+ * Looks to match the characters the constitute the token INTBOOL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mINTBOOL(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = INTBOOL;
+
+
+ // SMARTPL.g:87:10: ( ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL ) )
+ // SMARTPL.g:87:12: ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL )
+ {
+
+ // SMARTPL.g:87:12: ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL )
+ {
+ int alt5=5;
+ switch ( LA(1) )
+ {
+ case '>':
+ {
+ switch ( LA(2) )
+ {
+ case '=':
+ {
+ alt5=2;
+ }
+ break;
+
+ default:
+ alt5=1;}
+
+ }
+ break;
+ case '<':
+ {
+ switch ( LA(2) )
+ {
+ case '=':
+ {
+ alt5=4;
+ }
+ break;
+
+ default:
+ alt5=3;}
+
+ }
+ break;
+ case '=':
+ {
+ alt5=5;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 0;
+
+
+ goto ruleINTBOOLEx;
+ }
+
+ switch (alt5)
+ {
+ case 1:
+ // SMARTPL.g:87:13: GREATER
+ {
+ /* 87:13: GREATER */
+ mGREATER(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTBOOLEx;
+ }
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:87:21: GREATEREQUAL
+ {
+ /* 87:21: GREATEREQUAL */
+ mGREATEREQUAL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTBOOLEx;
+ }
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:87:34: LESS
+ {
+ /* 87:34: LESS */
+ mLESS(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTBOOLEx;
+ }
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:87:39: LESSEQUAL
+ {
+ /* 87:39: LESSEQUAL */
+ mLESSEQUAL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTBOOLEx;
+ }
+
+
+ }
+ break;
+ case 5:
+ // SMARTPL.g:87:49: EQUAL
+ {
+ /* 87:49: EQUAL */
+ mEQUAL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleINTBOOLEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleINTBOOLEx; /* Prevent compiler warnings */
+ ruleINTBOOLEx: ;
+
+}
+// $ANTLR end INTBOOL
+
+// Comes from: 91:10: ( '>' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start GREATER
+ *
+ * Looks to match the characters the constitute the token GREATER
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mGREATER(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // SMARTPL.g:91:10: ( '>' )
+ // SMARTPL.g:91:12: '>'
+ {
+ MATCHC('>');
+ if (HASEXCEPTION())
+ {
+ goto ruleGREATEREx;
+ }
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleGREATEREx; /* Prevent compiler warnings */
+ ruleGREATEREx: ;
+
+}
+// $ANTLR end GREATER
+
+// Comes from: 95:13: ( '>=' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start GREATEREQUAL
+ *
+ * Looks to match the characters the constitute the token GREATEREQUAL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mGREATEREQUAL(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // SMARTPL.g:95:13: ( '>=' )
+ // SMARTPL.g:95:15: '>='
+ {
+ MATCHS(lit_20);
+ if (HASEXCEPTION())
+ {
+ goto ruleGREATEREQUALEx;
+ }
+
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleGREATEREQUALEx; /* Prevent compiler warnings */
+ ruleGREATEREQUALEx: ;
+
+}
+// $ANTLR end GREATEREQUAL
+
+// Comes from: 99:7: ( '<' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LESS
+ *
+ * Looks to match the characters the constitute the token LESS
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLESS(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // SMARTPL.g:99:7: ( '<' )
+ // SMARTPL.g:99:9: '<'
+ {
+ MATCHC('<');
+ if (HASEXCEPTION())
+ {
+ goto ruleLESSEx;
+ }
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLESSEx; /* Prevent compiler warnings */
+ ruleLESSEx: ;
+
+}
+// $ANTLR end LESS
+
+// Comes from: 103:11: ( '<=' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LESSEQUAL
+ *
+ * Looks to match the characters the constitute the token LESSEQUAL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLESSEQUAL(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // SMARTPL.g:103:11: ( '<=' )
+ // SMARTPL.g:103:13: '<='
+ {
+ MATCHS(lit_21);
+ if (HASEXCEPTION())
+ {
+ goto ruleLESSEQUALEx;
+ }
+
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLESSEQUALEx; /* Prevent compiler warnings */
+ ruleLESSEQUALEx: ;
+
+}
+// $ANTLR end LESSEQUAL
+
+// Comes from: 107:8: ( '=' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start EQUAL
+ *
+ * Looks to match the characters the constitute the token EQUAL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mEQUAL(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+
+ // SMARTPL.g:107:8: ( '=' )
+ // SMARTPL.g:107:10: '='
+ {
+ MATCHC('=');
+ if (HASEXCEPTION())
+ {
+ goto ruleEQUALEx;
+ }
+
+
+ }
+
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleEQUALEx; /* Prevent compiler warnings */
+ ruleEQUALEx: ;
+
+}
+// $ANTLR end EQUAL
+
+// Comes from: 110:8: ( 'after' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start AFTER
+ *
+ * Looks to match the characters the constitute the token AFTER
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mAFTER(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = AFTER;
+
+
+ // SMARTPL.g:110:8: ( 'after' )
+ // SMARTPL.g:110:10: 'after'
+ {
+ MATCHS(lit_22);
+ if (HASEXCEPTION())
+ {
+ goto ruleAFTEREx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleAFTEREx; /* Prevent compiler warnings */
+ ruleAFTEREx: ;
+
+}
+// $ANTLR end AFTER
+
+// Comes from: 113:9: ( 'before' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start BEFORE
+ *
+ * Looks to match the characters the constitute the token BEFORE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mBEFORE(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = BEFORE;
+
+
+ // SMARTPL.g:113:9: ( 'before' )
+ // SMARTPL.g:113:11: 'before'
+ {
+ MATCHS(lit_23);
+ if (HASEXCEPTION())
+ {
+ goto ruleBEFOREEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleBEFOREEx; /* Prevent compiler warnings */
+ ruleBEFOREEx: ;
+
+}
+// $ANTLR end BEFORE
+
+// Comes from: 116:7: ( 'ago' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start AGO
+ *
+ * Looks to match the characters the constitute the token AGO
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mAGO(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = AGO;
+
+
+ // SMARTPL.g:116:7: ( 'ago' )
+ // SMARTPL.g:116:9: 'ago'
+ {
+ MATCHS(lit_24);
+ if (HASEXCEPTION())
+ {
+ goto ruleAGOEx;
+ }
+
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleAGOEx; /* Prevent compiler warnings */
+ ruleAGOEx: ;
+
+}
+// $ANTLR end AGO
+
+// Comes from: 119:7: ( 'AND' | 'and' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start AND
+ *
+ * Looks to match the characters the constitute the token AND
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mAND(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = AND;
+
+
+ {
+ // SMARTPL.g:119:7: ( 'AND' | 'and' )
+
+ ANTLR3_UINT32 alt6;
+
+ alt6=2;
+
+ switch ( LA(1) )
+ {
+ case 'A':
+ {
+ alt6=1;
+ }
+ break;
+ case 'a':
+ {
+ alt6=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 6;
+ EXCEPTION->state = 0;
+
+
+ goto ruleANDEx;
+ }
+
+ switch (alt6)
+ {
+ case 1:
+ // SMARTPL.g:119:9: 'AND'
+ {
+ MATCHS(lit_25);
+ if (HASEXCEPTION())
+ {
+ goto ruleANDEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:120:6: 'and'
+ {
+ MATCHS(lit_26);
+ if (HASEXCEPTION())
+ {
+ goto ruleANDEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleANDEx; /* Prevent compiler warnings */
+ ruleANDEx: ;
+
+}
+// $ANTLR end AND
+
+// Comes from: 123:6: ( 'OR' | 'or' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start OR
+ *
+ * Looks to match the characters the constitute the token OR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mOR(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = OR;
+
+
+ {
+ // SMARTPL.g:123:6: ( 'OR' | 'or' )
+
+ ANTLR3_UINT32 alt7;
+
+ alt7=2;
+
+ switch ( LA(1) )
+ {
+ case 'O':
+ {
+ alt7=1;
+ }
+ break;
+ case 'o':
+ {
+ alt7=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 7;
+ EXCEPTION->state = 0;
+
+
+ goto ruleOREx;
+ }
+
+ switch (alt7)
+ {
+ case 1:
+ // SMARTPL.g:123:8: 'OR'
+ {
+ MATCHS(lit_27);
+ if (HASEXCEPTION())
+ {
+ goto ruleOREx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:124:6: 'or'
+ {
+ MATCHS(lit_28);
+ if (HASEXCEPTION())
+ {
+ goto ruleOREx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleOREx; /* Prevent compiler warnings */
+ ruleOREx: ;
+
+}
+// $ANTLR end OR
+
+// Comes from: 127:7: ( 'NOT' | 'not' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start NOT
+ *
+ * Looks to match the characters the constitute the token NOT
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mNOT(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = NOT;
+
+
+ {
+ // SMARTPL.g:127:7: ( 'NOT' | 'not' )
+
+ ANTLR3_UINT32 alt8;
+
+ alt8=2;
+
+ switch ( LA(1) )
+ {
+ case 'N':
+ {
+ alt8=1;
+ }
+ break;
+ case 'n':
+ {
+ alt8=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 8;
+ EXCEPTION->state = 0;
+
+
+ goto ruleNOTEx;
+ }
+
+ switch (alt8)
+ {
+ case 1:
+ // SMARTPL.g:127:9: 'NOT'
+ {
+ MATCHS(lit_29);
+ if (HASEXCEPTION())
+ {
+ goto ruleNOTEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:128:6: 'not'
+ {
+ MATCHS(lit_30);
+ if (HASEXCEPTION())
+ {
+ goto ruleNOTEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleNOTEx; /* Prevent compiler warnings */
+ ruleNOTEx: ;
+
+}
+// $ANTLR end NOT
+
+// Comes from: 131:7: ( '(' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start LPAR
+ *
+ * Looks to match the characters the constitute the token LPAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mLPAR(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = LPAR;
+
+
+ // SMARTPL.g:131:7: ( '(' )
+ // SMARTPL.g:131:9: '('
+ {
+ MATCHC('(');
+ if (HASEXCEPTION())
+ {
+ goto ruleLPAREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleLPAREx; /* Prevent compiler warnings */
+ ruleLPAREx: ;
+
+}
+// $ANTLR end LPAR
+
+// Comes from: 134:7: ( ')' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start RPAR
+ *
+ * Looks to match the characters the constitute the token RPAR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mRPAR(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = RPAR;
+
+
+ // SMARTPL.g:134:7: ( ')' )
+ // SMARTPL.g:134:9: ')'
+ {
+ MATCHC(')');
+ if (HASEXCEPTION())
+ {
+ goto ruleRPAREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleRPAREx; /* Prevent compiler warnings */
+ ruleRPAREx: ;
+
+}
+// $ANTLR end RPAR
+
+// Comes from: 137:7: ( ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) '-' ( '0' .. '1' ) ( '0' .. '9' ) '-' ( '0' .. '3' ) ( '0' .. '9' ) | 'today' | 'yesterday' | 'last week' | 'last month' | 'last year' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DATE
+ *
+ * Looks to match the characters the constitute the token DATE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDATE(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = DATE;
+
+
+ {
+ // SMARTPL.g:137:7: ( ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) '-' ( '0' .. '1' ) ( '0' .. '9' ) '-' ( '0' .. '3' ) ( '0' .. '9' ) | 'today' | 'yesterday' | 'last week' | 'last month' | 'last year' )
+
+ ANTLR3_UINT32 alt9;
+
+ alt9=6;
+
+ switch ( LA(1) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ alt9=1;
+ }
+ break;
+ case 't':
+ {
+ alt9=2;
+ }
+ break;
+ case 'y':
+ {
+ alt9=3;
+ }
+ break;
+ case 'l':
+ {
+ switch ( LA(2) )
+ {
+ case 'a':
+ {
+ switch ( LA(3) )
+ {
+ case 's':
+ {
+ switch ( LA(4) )
+ {
+ case 't':
+ {
+ switch ( LA(5) )
+ {
+ case ' ':
+ {
+ switch ( LA(6) )
+ {
+ case 'w':
+ {
+ alt9=4;
+ }
+ break;
+ case 'm':
+ {
+ alt9=5;
+ }
+ break;
+ case 'y':
+ {
+ alt9=6;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 8;
+
+
+ goto ruleDATEEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 7;
+
+
+ goto ruleDATEEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 6;
+
+
+ goto ruleDATEEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 5;
+
+
+ goto ruleDATEEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 4;
+
+
+ goto ruleDATEEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 9;
+ EXCEPTION->state = 0;
+
+
+ goto ruleDATEEx;
+ }
+
+ switch (alt9)
+ {
+ case 1:
+ // SMARTPL.g:137:9: ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) '-' ( '0' .. '1' ) ( '0' .. '9' ) '-' ( '0' .. '3' ) ( '0' .. '9' )
+ {
+ // SMARTPL.g:137:9: ( '0' .. '9' )
+ // SMARTPL.g:137:10: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ // SMARTPL.g:137:19: ( '0' .. '9' )
+ // SMARTPL.g:137:20: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ // SMARTPL.g:137:29: ( '0' .. '9' )
+ // SMARTPL.g:137:30: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ // SMARTPL.g:137:39: ( '0' .. '9' )
+ // SMARTPL.g:137:40: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ MATCHC('-');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ // SMARTPL.g:137:52: ( '0' .. '1' )
+ // SMARTPL.g:137:53: '0' .. '1'
+ {
+ MATCHRANGE('0', '1');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ // SMARTPL.g:137:62: ( '0' .. '9' )
+ // SMARTPL.g:137:63: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ MATCHC('-');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+ // SMARTPL.g:137:75: ( '0' .. '3' )
+ // SMARTPL.g:137:76: '0' .. '3'
+ {
+ MATCHRANGE('0', '3');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+ // SMARTPL.g:137:85: ( '0' .. '9' )
+ // SMARTPL.g:137:86: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:138:6: 'today'
+ {
+ MATCHS(lit_31);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:139:6: 'yesterday'
+ {
+ MATCHS(lit_32);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:140:6: 'last week'
+ {
+ MATCHS(lit_33);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+
+ }
+ break;
+ case 5:
+ // SMARTPL.g:141:6: 'last month'
+ {
+ MATCHS(lit_34);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+
+ }
+ break;
+ case 6:
+ // SMARTPL.g:142:6: 'last year'
+ {
+ MATCHS(lit_35);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATEEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDATEEx; /* Prevent compiler warnings */
+ ruleDATEEx: ;
+
+}
+// $ANTLR end DATE
+
+// Comes from: 145:13: ( 'days' | 'weeks' | 'months' | 'years' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start DATINTERVAL
+ *
+ * Looks to match the characters the constitute the token DATINTERVAL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mDATINTERVAL(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = DATINTERVAL;
+
+
+ {
+ // SMARTPL.g:145:13: ( 'days' | 'weeks' | 'months' | 'years' )
+
+ ANTLR3_UINT32 alt10;
+
+ alt10=4;
+
+ switch ( LA(1) )
+ {
+ case 'd':
+ {
+ alt10=1;
+ }
+ break;
+ case 'w':
+ {
+ alt10=2;
+ }
+ break;
+ case 'm':
+ {
+ alt10=3;
+ }
+ break;
+ case 'y':
+ {
+ alt10=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 10;
+ EXCEPTION->state = 0;
+
+
+ goto ruleDATINTERVALEx;
+ }
+
+ switch (alt10)
+ {
+ case 1:
+ // SMARTPL.g:145:15: 'days'
+ {
+ MATCHS(lit_36);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATINTERVALEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:146:6: 'weeks'
+ {
+ MATCHS(lit_37);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATINTERVALEx;
+ }
+
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:147:6: 'months'
+ {
+ MATCHS(lit_38);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATINTERVALEx;
+ }
+
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:148:6: 'years'
+ {
+ MATCHS(lit_39);
+ if (HASEXCEPTION())
+ {
+ goto ruleDATINTERVALEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleDATINTERVALEx; /* Prevent compiler warnings */
+ ruleDATINTERVALEx: ;
+
+}
+// $ANTLR end DATINTERVAL
+
+// Comes from: 151:10: ( 'music' | 'movie' | 'podcast' | 'audiobook' | 'tvshow' | 'file' | 'url' | 'spotify' | 'pipe' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start ENUMVAL
+ *
+ * Looks to match the characters the constitute the token ENUMVAL
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mENUMVAL(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = ENUMVAL;
+
+
+ {
+ // SMARTPL.g:151:10: ( 'music' | 'movie' | 'podcast' | 'audiobook' | 'tvshow' | 'file' | 'url' | 'spotify' | 'pipe' )
+
+ ANTLR3_UINT32 alt11;
+
+ alt11=9;
+
+ switch ( LA(1) )
+ {
+ case 'm':
+ {
+ switch ( LA(2) )
+ {
+ case 'u':
+ {
+ alt11=1;
+ }
+ break;
+ case 'o':
+ {
+ alt11=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 11;
+ EXCEPTION->state = 1;
+
+
+ goto ruleENUMVALEx;
+ }
+
+ }
+ break;
+ case 'p':
+ {
+ switch ( LA(2) )
+ {
+ case 'o':
+ {
+ alt11=3;
+ }
+ break;
+ case 'i':
+ {
+ alt11=9;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 11;
+ EXCEPTION->state = 2;
+
+
+ goto ruleENUMVALEx;
+ }
+
+ }
+ break;
+ case 'a':
+ {
+ alt11=4;
+ }
+ break;
+ case 't':
+ {
+ alt11=5;
+ }
+ break;
+ case 'f':
+ {
+ alt11=6;
+ }
+ break;
+ case 'u':
+ {
+ alt11=7;
+ }
+ break;
+ case 's':
+ {
+ alt11=8;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 11;
+ EXCEPTION->state = 0;
+
+
+ goto ruleENUMVALEx;
+ }
+
+ switch (alt11)
+ {
+ case 1:
+ // SMARTPL.g:151:12: 'music'
+ {
+ MATCHS(lit_40);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:152:6: 'movie'
+ {
+ MATCHS(lit_41);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:153:6: 'podcast'
+ {
+ MATCHS(lit_42);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:154:6: 'audiobook'
+ {
+ MATCHS(lit_43);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 5:
+ // SMARTPL.g:155:6: 'tvshow'
+ {
+ MATCHS(lit_44);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 6:
+ // SMARTPL.g:156:6: 'file'
+ {
+ MATCHS(lit_45);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 7:
+ // SMARTPL.g:157:6: 'url'
+ {
+ MATCHS(lit_46);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 8:
+ // SMARTPL.g:158:6: 'spotify'
+ {
+ MATCHS(lit_47);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+ case 9:
+ // SMARTPL.g:159:6: 'pipe'
+ {
+ MATCHS(lit_48);
+ if (HASEXCEPTION())
+ {
+ goto ruleENUMVALEx;
+ }
+
+
+
+ }
+ break;
+
+ }
+ }
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleENUMVALEx; /* Prevent compiler warnings */
+ ruleENUMVALEx: ;
+
+}
+// $ANTLR end ENUMVAL
+
+// Comes from: 162:7: ( '\"' (~ ( '\"' ) )+ '\"' )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start STR
+ *
+ * Looks to match the characters the constitute the token STR
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mSTR(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = STR;
+
+
+ // SMARTPL.g:162:7: ( '\"' (~ ( '\"' ) )+ '\"' )
+ // SMARTPL.g:162:9: '\"' (~ ( '\"' ) )+ '\"'
+ {
+ MATCHC('"');
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+ // SMARTPL.g:162:13: (~ ( '\"' ) )+
+ {
+ int cnt12=0;
+
+ for (;;)
+ {
+ int alt12=2;
+ {
+ /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
+ */
+ int LA12_0 = LA(1);
+ if ( (((LA12_0 >= 0x0000) && (LA12_0 <= '!')) || ((LA12_0 >= '#') && (LA12_0 <= 0xFFFF))) )
+ {
+ alt12=1;
+ }
+
+ }
+ switch (alt12)
+ {
+ case 1:
+ // SMARTPL.g:162:13: ~ ( '\"' )
+ {
+ if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleSTREx;
+ }
+
+
+ }
+ break;
+
+ default:
+
+ if ( cnt12 >= 1 )
+ {
+ goto loop12;
+ }
+ /* mismatchedSetEx()
+ */
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
+
+
+ goto ruleSTREx;
+ }
+ cnt12++;
+ }
+ loop12: ; /* Jump to here if this rule does not match */
+ }
+ MATCHC('"');
+ if (HASEXCEPTION())
+ {
+ goto ruleSTREx;
+ }
+
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleSTREx; /* Prevent compiler warnings */
+ ruleSTREx: ;
+
+}
+// $ANTLR end STR
+
+// Comes from: 165:7: ( ( '0' .. '9' )+ )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start INT
+ *
+ * Looks to match the characters the constitute the token INT
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mINT(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = INT;
+
+
+ // SMARTPL.g:165:7: ( ( '0' .. '9' )+ )
+ // SMARTPL.g:165:9: ( '0' .. '9' )+
+ {
+ // SMARTPL.g:165:9: ( '0' .. '9' )+
+ {
+ int cnt13=0;
+
+ for (;;)
+ {
+ int alt13=2;
+ switch ( LA(1) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ alt13=1;
+ }
+ break;
+
+ }
+
+ switch (alt13)
+ {
+ case 1:
+ // SMARTPL.g:165:10: '0' .. '9'
+ {
+ MATCHRANGE('0', '9');
+ if (HASEXCEPTION())
+ {
+ goto ruleINTEx;
+ }
+
+
+ }
+ break;
+
+ default:
+
+ if ( cnt13 >= 1 )
+ {
+ goto loop13;
+ }
+ /* mismatchedSetEx()
+ */
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
+
+
+ goto ruleINTEx;
+ }
+ cnt13++;
+ }
+ loop13: ; /* Jump to here if this rule does not match */
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleINTEx; /* Prevent compiler warnings */
+ ruleINTEx: ;
+
+}
+// $ANTLR end INT
+
+// Comes from: 168:12: ( ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' ) )
+/** \brief Lexer rule generated by ANTLR3
+ *
+ * $ANTLR start WHITESPACE
+ *
+ * Looks to match the characters the constitute the token WHITESPACE
+ * from the attached input stream.
+ *
+ *
+ * \remark
+ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
+ */
+static ANTLR3_INLINE
+void mWHITESPACE(pSMARTPLLexer ctx)
+{
+ ANTLR3_UINT32 _type;
+
+ _type = WHITESPACE;
+
+
+ // SMARTPL.g:168:12: ( ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' ) )
+ // SMARTPL.g:168:14: ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )
+ {
+ if ( ((LA(1) >= '\t') && (LA(1) <= '\n')) || ((LA(1) >= '\f') && (LA(1) <= '\r')) || LA(1) == ' ' )
+ {
+ CONSUME();
+
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+
+ LRECOVER(); goto ruleWHITESPACEEx;
+ }
+
+ {
+ LEXSTATE->channel = HIDDEN;
+ }
+
+ }
+
+ LEXSTATE->type = _type;
+
+ // This is where rules clean up and exit
+ //
+ goto ruleWHITESPACEEx; /* Prevent compiler warnings */
+ ruleWHITESPACEEx: ;
+
+}
+// $ANTLR end WHITESPACE
+
+/** This is the entry point in to the lexer from an object that
+ * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
+ */
+static void
+mTokens(pSMARTPLLexer ctx)
+{
+ {
+ // SMARTPL.g:1:8: ( T__30 | T__31 | STRTAG | INTTAG | DATETAG | ENUMTAG | INCLUDES | IS | INTBOOL | AFTER | BEFORE | AGO | AND | OR | NOT | LPAR | RPAR | DATE | DATINTERVAL | ENUMVAL | STR | INT | WHITESPACE )
+
+ ANTLR3_UINT32 alt14;
+
+ alt14=23;
+
+ switch ( LA(1) )
+ {
+ case '{':
+ {
+ alt14=1;
+ }
+ break;
+ case '}':
+ {
+ alt14=2;
+ }
+ break;
+ case 'a':
+ {
+ switch ( LA(2) )
+ {
+ case 'l':
+ case 'r':
+ {
+ alt14=3;
+ }
+ break;
+ case 'f':
+ {
+ alt14=10;
+ }
+ break;
+ case 'g':
+ {
+ alt14=12;
+ }
+ break;
+ case 'n':
+ {
+ alt14=13;
+ }
+ break;
+ case 'u':
+ {
+ alt14=20;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 3;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 't':
+ {
+ switch ( LA(2) )
+ {
+ case 'i':
+ {
+ switch ( LA(3) )
+ {
+ case 't':
+ {
+ alt14=3;
+ }
+ break;
+ case 'm':
+ {
+ alt14=5;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 28;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'y':
+ {
+ alt14=3;
+ }
+ break;
+ case 'o':
+ {
+ alt14=18;
+ }
+ break;
+ case 'v':
+ {
+ alt14=20;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 4;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'g':
+ {
+ alt14=3;
+ }
+ break;
+ case 'c':
+ {
+ switch ( LA(2) )
+ {
+ case 'o':
+ {
+ switch ( LA(3) )
+ {
+ case 'm':
+ {
+ switch ( LA(4) )
+ {
+ case 'p':
+ {
+ switch ( LA(5) )
+ {
+ case 'o':
+ {
+ alt14=3;
+ }
+ break;
+ case 'i':
+ {
+ alt14=4;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 42;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 39;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 29;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 6;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'p':
+ {
+ switch ( LA(2) )
+ {
+ case 'a':
+ {
+ alt14=3;
+ }
+ break;
+ case 'l':
+ {
+ alt14=4;
+ }
+ break;
+ case 'i':
+ case 'o':
+ {
+ alt14=20;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 7;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'r':
+ {
+ alt14=4;
+ }
+ break;
+ case 'y':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ switch ( LA(3) )
+ {
+ case 'a':
+ {
+ switch ( LA(4) )
+ {
+ case 'r':
+ {
+ switch ( LA(5) )
+ {
+ case 's':
+ {
+ alt14=19;
+ }
+ break;
+
+ default:
+ alt14=4;}
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 40;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 's':
+ {
+ alt14=18;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 30;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 9;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'd':
+ {
+ switch ( LA(2) )
+ {
+ case 'a':
+ {
+ switch ( LA(3) )
+ {
+ case 't':
+ {
+ alt14=6;
+ }
+ break;
+ case 'y':
+ {
+ alt14=19;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 31;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 10;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'm':
+ {
+ switch ( LA(2) )
+ {
+ case 'e':
+ {
+ alt14=6;
+ }
+ break;
+ case 'o':
+ {
+ switch ( LA(3) )
+ {
+ case 'n':
+ {
+ alt14=19;
+ }
+ break;
+ case 'v':
+ {
+ alt14=20;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 33;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'u':
+ {
+ alt14=20;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 11;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case 'i':
+ {
+ switch ( LA(2) )
+ {
+ case 'n':
+ {
+ alt14=7;
+ }
+ break;
+ case 's':
+ {
+ alt14=8;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 12;
+
+
+ goto ruleTokensEx;
+ }
+
+ }
+ break;
+ case '<':
+ case '=':
+ case '>':
+ {
+ alt14=9;
+ }
+ break;
+ case 'b':
+ {
+ alt14=11;
+ }
+ break;
+ case 'A':
+ {
+ alt14=13;
+ }
+ break;
+ case 'O':
+ case 'o':
+ {
+ alt14=14;
+ }
+ break;
+ case 'N':
+ case 'n':
+ {
+ alt14=15;
+ }
+ break;
+ case '(':
+ {
+ alt14=16;
+ }
+ break;
+ case ')':
+ {
+ alt14=17;
+ }
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(2) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(3) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(4) )
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ switch ( LA(5) )
+ {
+ case '-':
+ {
+ alt14=18;
+ }
+ break;
+
+ default:
+ alt14=22;}
+
+ }
+ break;
+
+ default:
+ alt14=22;}
+
+ }
+ break;
+
+ default:
+ alt14=22;}
+
+ }
+ break;
+
+ default:
+ alt14=22;}
+
+ }
+ break;
+ case 'l':
+ {
+ alt14=18;
+ }
+ break;
+ case 'w':
+ {
+ alt14=19;
+ }
+ break;
+ case 'f':
+ case 's':
+ case 'u':
+ {
+ alt14=20;
+ }
+ break;
+ case '"':
+ {
+ alt14=21;
+ }
+ break;
+ case '\t':
+ case '\n':
+ case '\f':
+ case '\r':
+ case ' ':
+ {
+ alt14=23;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 14;
+ EXCEPTION->state = 0;
+
+
+ goto ruleTokensEx;
+ }
+
+ switch (alt14)
+ {
+ case 1:
+ // SMARTPL.g:1:10: T__30
+ {
+ /* 1:10: T__30 */
+ mT__30(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:1:16: T__31
+ {
+ /* 1:16: T__31 */
+ mT__31(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:1:22: STRTAG
+ {
+ /* 1:22: STRTAG */
+ mSTRTAG(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:1:29: INTTAG
+ {
+ /* 1:29: INTTAG */
+ mINTTAG(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 5:
+ // SMARTPL.g:1:36: DATETAG
+ {
+ /* 1:36: DATETAG */
+ mDATETAG(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 6:
+ // SMARTPL.g:1:44: ENUMTAG
+ {
+ /* 1:44: ENUMTAG */
+ mENUMTAG(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 7:
+ // SMARTPL.g:1:52: INCLUDES
+ {
+ /* 1:52: INCLUDES */
+ mINCLUDES(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 8:
+ // SMARTPL.g:1:61: IS
+ {
+ /* 1:61: IS */
+ mIS(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 9:
+ // SMARTPL.g:1:64: INTBOOL
+ {
+ /* 1:64: INTBOOL */
+ mINTBOOL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 10:
+ // SMARTPL.g:1:72: AFTER
+ {
+ /* 1:72: AFTER */
+ mAFTER(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 11:
+ // SMARTPL.g:1:78: BEFORE
+ {
+ /* 1:78: BEFORE */
+ mBEFORE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 12:
+ // SMARTPL.g:1:85: AGO
+ {
+ /* 1:85: AGO */
+ mAGO(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 13:
+ // SMARTPL.g:1:89: AND
+ {
+ /* 1:89: AND */
+ mAND(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 14:
+ // SMARTPL.g:1:93: OR
+ {
+ /* 1:93: OR */
+ mOR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 15:
+ // SMARTPL.g:1:96: NOT
+ {
+ /* 1:96: NOT */
+ mNOT(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 16:
+ // SMARTPL.g:1:100: LPAR
+ {
+ /* 1:100: LPAR */
+ mLPAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 17:
+ // SMARTPL.g:1:105: RPAR
+ {
+ /* 1:105: RPAR */
+ mRPAR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 18:
+ // SMARTPL.g:1:110: DATE
+ {
+ /* 1:110: DATE */
+ mDATE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 19:
+ // SMARTPL.g:1:115: DATINTERVAL
+ {
+ /* 1:115: DATINTERVAL */
+ mDATINTERVAL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 20:
+ // SMARTPL.g:1:127: ENUMVAL
+ {
+ /* 1:127: ENUMVAL */
+ mENUMVAL(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 21:
+ // SMARTPL.g:1:135: STR
+ {
+ /* 1:135: STR */
+ mSTR(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 22:
+ // SMARTPL.g:1:139: INT
+ {
+ /* 1:139: INT */
+ mINT(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+ case 23:
+ // SMARTPL.g:1:143: WHITESPACE
+ {
+ /* 1:143: WHITESPACE */
+ mWHITESPACE(ctx );
+ if (HASEXCEPTION())
+ {
+ goto ruleTokensEx;
+ }
+
+
+ }
+ break;
+
+ }
+ }
+
+
+ goto ruleTokensEx; /* Prevent compiler warnings */
+ruleTokensEx: ;
+}
+
+/* =========================================================================
+ * Lexer matching rules end.
+ * =========================================================================
+ */
+/* End of Lexer code
+ * ================================================
+ * ================================================
+ */
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/SMARTPLLexer.h b/src/pregen/SMARTPLLexer.h
new file mode 100644
index 0000000..87e8c7e
--- /dev/null
+++ b/src/pregen/SMARTPLLexer.h
@@ -0,0 +1,248 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : SMARTPL.g
+ * - On : 2016-01-01 12:23:40
+ * - for the lexer : SMARTPLLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The lexer SMARTPLLexer has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pSMARTPLLexer, which is returned from a call to SMARTPLLexerNew().
+ *
+ * As this is a generated lexer, it is unlikely you will call it 'manually'. However
+ * the methods are provided anyway.
+ * * The methods in pSMARTPLLexer are as follows:
+ *
+ * - void pSMARTPLLexer->T__30(pSMARTPLLexer)
+ * - void pSMARTPLLexer->T__31(pSMARTPLLexer)
+ * - void pSMARTPLLexer->STRTAG(pSMARTPLLexer)
+ * - void pSMARTPLLexer->INTTAG(pSMARTPLLexer)
+ * - void pSMARTPLLexer->DATETAG(pSMARTPLLexer)
+ * - void pSMARTPLLexer->ENUMTAG(pSMARTPLLexer)
+ * - void pSMARTPLLexer->INCLUDES(pSMARTPLLexer)
+ * - void pSMARTPLLexer->IS(pSMARTPLLexer)
+ * - void pSMARTPLLexer->INTBOOL(pSMARTPLLexer)
+ * - void pSMARTPLLexer->GREATER(pSMARTPLLexer)
+ * - void pSMARTPLLexer->GREATEREQUAL(pSMARTPLLexer)
+ * - void pSMARTPLLexer->LESS(pSMARTPLLexer)
+ * - void pSMARTPLLexer->LESSEQUAL(pSMARTPLLexer)
+ * - void pSMARTPLLexer->EQUAL(pSMARTPLLexer)
+ * - void pSMARTPLLexer->AFTER(pSMARTPLLexer)
+ * - void pSMARTPLLexer->BEFORE(pSMARTPLLexer)
+ * - void pSMARTPLLexer->AGO(pSMARTPLLexer)
+ * - void pSMARTPLLexer->AND(pSMARTPLLexer)
+ * - void pSMARTPLLexer->OR(pSMARTPLLexer)
+ * - void pSMARTPLLexer->NOT(pSMARTPLLexer)
+ * - void pSMARTPLLexer->LPAR(pSMARTPLLexer)
+ * - void pSMARTPLLexer->RPAR(pSMARTPLLexer)
+ * - void pSMARTPLLexer->DATE(pSMARTPLLexer)
+ * - void pSMARTPLLexer->DATINTERVAL(pSMARTPLLexer)
+ * - void pSMARTPLLexer->ENUMVAL(pSMARTPLLexer)
+ * - void pSMARTPLLexer->STR(pSMARTPLLexer)
+ * - void pSMARTPLLexer->INT(pSMARTPLLexer)
+ * - void pSMARTPLLexer->WHITESPACE(pSMARTPLLexer)
+ * - void pSMARTPLLexer->Tokens(pSMARTPLLexer)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _SMARTPLLexer_H
+#define _SMARTPLLexer_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct SMARTPLLexer_Ctx_struct SMARTPLLexer, * pSMARTPLLexer;
+
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+
+/** Context tracking structure for SMARTPLLexer
+ */
+struct SMARTPLLexer_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_LEXER pLexer;
+
+
+ void (*mT__30) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mT__31) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mSTRTAG) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mINTTAG) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mDATETAG) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mENUMTAG) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mINCLUDES) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mIS) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mINTBOOL) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mGREATER) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mGREATEREQUAL) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mLESS) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mLESSEQUAL) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mEQUAL) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mAFTER) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mBEFORE) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mAGO) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mAND) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mOR) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mNOT) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mLPAR) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mRPAR) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mDATE) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mDATINTERVAL) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mENUMVAL) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mSTR) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mINT) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mWHITESPACE) (struct SMARTPLLexer_Ctx_struct * ctx);
+ void (*mTokens) (struct SMARTPLLexer_Ctx_struct * ctx); const char * (*getGrammarFileName)();
+ void (*free) (struct SMARTPLLexer_Ctx_struct * ctx);
+
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pSMARTPLLexer SMARTPLLexerNew (pANTLR3_INPUT_STREAM instream);
+ANTLR3_API pSMARTPLLexer SMARTPLLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the lexer will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define INTBOOL 14
+#define STRTAG 10
+#define AGO 22
+#define WHITESPACE 29
+#define GREATEREQUAL 25
+#define BEFORE 18
+#define DATETAG 16
+#define INT 15
+#define NOT 7
+#define AFTER 17
+#define AND 6
+#define EOF -1
+#define INCLUDES 11
+#define STR 4
+#define T__30 30
+#define T__31 31
+#define GREATER 24
+#define LPAR 8
+#define ENUMTAG 19
+#define IS 12
+#define ENUMVAL 20
+#define EQUAL 28
+#define OR 5
+#define LESS 26
+#define RPAR 9
+#define DATE 21
+#define LESSEQUAL 27
+#define INTTAG 13
+#define DATINTERVAL 23
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for SMARTPLLexer
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
diff --git a/src/pregen/SMARTPLParser.c b/src/pregen/SMARTPLParser.c
new file mode 100644
index 0000000..f39e5ae
--- /dev/null
+++ b/src/pregen/SMARTPLParser.c
@@ -0,0 +1,1812 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : SMARTPL.g
+ * - On : 2016-01-01 12:23:40
+ * - for the parser : SMARTPLParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+*/
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* -----------------------------------------
+ * Include the ANTLR3 generated header file.
+ */
+#include "SMARTPLParser.h"
+/* ----------------------------------------- */
+
+
+
+
+
+/* MACROS that hide the C interface implementations from the
+ * generated code, which makes it a little more understandable to the human eye.
+ * I am very much against using C pre-processor macros for function calls and bits
+ * of code as you cannot see what is happening when single stepping in debuggers
+ * and so on. The exception (in my book at least) is for generated code, where you are
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
+ * hides some indirect calls, but is always referring to the input stream. This is
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
+ * the runtime interfaces without changing the generated code too often, without
+ * confusing the reader of the generated output, who may not wish to know the gory
+ * details of the interface inheritance.
+ */
+
+#define CTX ctx
+
+/* Aids in accessing scopes for grammar programmers
+ */
+#undef SCOPE_TYPE
+#undef SCOPE_STACK
+#undef SCOPE_TOP
+#define SCOPE_TYPE(scope) pSMARTPLParser_##scope##_SCOPE
+#define SCOPE_STACK(scope) pSMARTPLParser_##scope##Stack
+#define SCOPE_TOP(scope) ctx->pSMARTPLParser_##scope##Top
+#define SCOPE_SIZE(scope) ctx->pSMARTPLParser_##scope##Stack_limit
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
+
+/* Macros for accessing things in the parser
+ */
+
+#undef PARSER
+#undef RECOGNIZER
+#undef HAVEPARSEDRULE
+#undef MEMOIZE
+#undef INPUT
+#undef STRSTREAM
+#undef HASEXCEPTION
+#undef EXCEPTION
+#undef MATCHT
+#undef MATCHANYT
+#undef FOLLOWSTACK
+#undef FOLLOWPUSH
+#undef FOLLOWPOP
+#undef PRECOVER
+#undef PREPORTERROR
+#undef LA
+#undef LT
+#undef CONSTRUCTEX
+#undef CONSUME
+#undef MARK
+#undef REWIND
+#undef REWINDLAST
+#undef PERRORRECOVERY
+#undef HASFAILED
+#undef FAILEDFLAG
+#undef RECOVERFROMMISMATCHEDSET
+#undef RECOVERFROMMISMATCHEDELEMENT
+#undef INDEX
+#undef ADAPTOR
+#undef SEEK
+#undef RULEMEMO
+#undef DBG
+
+#define PARSER ctx->pParser
+#define RECOGNIZER PARSER->rec
+#define PSRSTATE RECOGNIZER->state
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
+#define INPUT PARSER->tstream
+#define STRSTREAM INPUT
+#define ISTREAM INPUT->istream
+#define INDEX() ISTREAM->index(INPUT->istream)
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
+#define EXCEPTION PSRSTATE->exception
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
+#define FOLLOWSTACK PSRSTATE->following
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
+#define LA(n) INPUT->istream->_LA(ISTREAM, n)
+#define LT(n) INPUT->_LT(INPUT, n)
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
+#define CONSUME() ISTREAM->consume(ISTREAM)
+#define MARK() ISTREAM->mark(ISTREAM)
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)
+#define PERRORRECOVERY PSRSTATE->errorRecovery
+#define FAILEDFLAG PSRSTATE->failed
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
+#define BACKTRACKING PSRSTATE->backtracking
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
+#define ADAPTOR ctx->adaptor
+#define RULEMEMO PSRSTATE->ruleMemo
+#define DBG RECOGNIZER->debugger
+
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
+
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so
+ * then for the present you must use different names for your defines as these are hard coded
+ * in the code generator. It would be better not to use such names internally, and maybe
+ * we can change this in a forthcoming release. I deliberately do not #undef these
+ * here as this will at least give you a redefined error somewhere if they clash.
+ */
+#define UP ANTLR3_TOKEN_UP
+#define DOWN ANTLR3_TOKEN_DOWN
+#define EOR ANTLR3_TOKEN_EOR
+#define INVALID ANTLR3_TOKEN_INVALID
+
+
+/* =============================================================================
+ * Functions to create and destroy scopes. First come the rule scopes, followed
+ * by the global declared scopes.
+ */
+
+
+
+/* ============================================================================= */
+
+/* =============================================================================
+ * Start of recognizer
+ */
+
+
+
+/** \brief Table of all token names in symbolic order, mainly used for
+ * error reporting.
+ */
+pANTLR3_UINT8 SMARTPLParserTokenNames[28+4]
+ = {
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
+ (pANTLR3_UINT8) "<EOR>",
+ (pANTLR3_UINT8) "<DOWN>",
+ (pANTLR3_UINT8) "<UP>",
+ (pANTLR3_UINT8) "STR",
+ (pANTLR3_UINT8) "OR",
+ (pANTLR3_UINT8) "AND",
+ (pANTLR3_UINT8) "NOT",
+ (pANTLR3_UINT8) "LPAR",
+ (pANTLR3_UINT8) "RPAR",
+ (pANTLR3_UINT8) "STRTAG",
+ (pANTLR3_UINT8) "INCLUDES",
+ (pANTLR3_UINT8) "IS",
+ (pANTLR3_UINT8) "INTTAG",
+ (pANTLR3_UINT8) "INTBOOL",
+ (pANTLR3_UINT8) "INT",
+ (pANTLR3_UINT8) "DATETAG",
+ (pANTLR3_UINT8) "AFTER",
+ (pANTLR3_UINT8) "BEFORE",
+ (pANTLR3_UINT8) "ENUMTAG",
+ (pANTLR3_UINT8) "ENUMVAL",
+ (pANTLR3_UINT8) "DATE",
+ (pANTLR3_UINT8) "AGO",
+ (pANTLR3_UINT8) "DATINTERVAL",
+ (pANTLR3_UINT8) "GREATER",
+ (pANTLR3_UINT8) "GREATEREQUAL",
+ (pANTLR3_UINT8) "LESS",
+ (pANTLR3_UINT8) "LESSEQUAL",
+ (pANTLR3_UINT8) "EQUAL",
+ (pANTLR3_UINT8) "WHITESPACE",
+ (pANTLR3_UINT8) "'{'",
+ (pANTLR3_UINT8) "'}'"
+ };
+
+
+
+// Forward declare the locally static matching functions we have generated.
+//
+static SMARTPLParser_playlist_return playlist (pSMARTPLParser ctx);
+static SMARTPLParser_expression_return expression (pSMARTPLParser ctx);
+static SMARTPLParser_aexpr_return aexpr (pSMARTPLParser ctx);
+static SMARTPLParser_nexpr_return nexpr (pSMARTPLParser ctx);
+static SMARTPLParser_crit_return crit (pSMARTPLParser ctx);
+static SMARTPLParser_dateval_return dateval (pSMARTPLParser ctx);
+static SMARTPLParser_interval_return interval (pSMARTPLParser ctx);
+static void SMARTPLParserFree(pSMARTPLParser ctx);
+/* For use in tree output where we are accumulating rule labels via label += ruleRef
+ * we need a function that knows how to free a return scope when the list is destroyed.
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
+ */
+static void ANTLR3_CDECL freeScope(void * scope)
+{
+ ANTLR3_FREE(scope);
+}
+
+/** \brief Name of the grammar file that generated this code
+ */
+static const char fileName[] = "SMARTPL.g";
+
+/** \brief Return the name of the grammar file that generated this code.
+ */
+static const char * getGrammarFileName()
+{
+ return fileName;
+}
+/** \brief Create a new SMARTPLParser parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pSMARTPLParser
+SMARTPLParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
+{
+ // See if we can create a new parser with the standard constructor
+ //
+ return SMARTPLParserNewSSD(instream, NULL);
+}
+
+/** \brief Create a new SMARTPLParser parser and return a context for it.
+ *
+ * \param[in] instream Pointer to an input stream interface.
+ *
+ * \return Pointer to new parser context upon success.
+ */
+ANTLR3_API pSMARTPLParser
+SMARTPLParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
+{
+ pSMARTPLParser ctx; /* Context structure we will build and return */
+
+ ctx = (pSMARTPLParser) ANTLR3_CALLOC(1, sizeof(SMARTPLParser));
+
+ if (ctx == NULL)
+ {
+ // Failed to allocate memory for parser context
+ //
+ return NULL;
+ }
+
+ /* -------------------------------------------------------------------
+ * Memory for basic structure is allocated, now to fill in
+ * the base ANTLR3 structures. We initialize the function pointers
+ * for the standard ANTLR3 parser function set, but upon return
+ * from here, the programmer may set the pointers to provide custom
+ * implementations of each function.
+ *
+ * We don't use the macros defined in SMARTPLParser.h here, in order that you can get a sense
+ * of what goes where.
+ */
+
+ /* Create a base parser/recognizer, using the supplied token stream
+ */
+ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
+ /* Install the implementation of our SMARTPLParser interface
+ */
+ ctx->playlist = playlist;
+ ctx->expression = expression;
+ ctx->aexpr = aexpr;
+ ctx->nexpr = nexpr;
+ ctx->crit = crit;
+ ctx->dateval = dateval;
+ ctx->interval = interval;
+ ctx->free = SMARTPLParserFree;
+ ctx->getGrammarFileName = getGrammarFileName;
+
+ /* Install the scope pushing methods.
+ */
+ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
+ ctx->vectors = antlr3VectorFactoryNew(0);
+
+
+
+ /* Install the token table
+ */
+ PSRSTATE->tokenNames = SMARTPLParserTokenNames;
+
+
+ /* Return the newly built parser to the caller
+ */
+ return ctx;
+}
+
+/** Free the parser resources
+ */
+ static void
+ SMARTPLParserFree(pSMARTPLParser ctx)
+ {
+ /* Free any scope memory
+ */
+
+ ctx->vectors->close(ctx->vectors);
+ /* We created the adaptor so we must free it
+ */
+ ADAPTOR->free(ADAPTOR);
+ // Free this parser
+ //
+ ctx->pParser->free(ctx->pParser);
+ ANTLR3_FREE(ctx);
+
+ /* Everything is released, so we can return
+ */
+ return;
+ }
+
+/** Return token names used by this parser
+ *
+ * The returned pointer is used as an index into the token names table (using the token
+ * number as the index).
+ *
+ * \return Pointer to first char * in the table.
+ */
+static pANTLR3_UINT8 *getTokenNames()
+{
+ return SMARTPLParserTokenNames;
+}
+
+
+/* Declare the bitsets
+ */
+
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_playlist42 */
+static ANTLR3_BITWORD FOLLOW_STR_in_playlist42_bits[] = { ANTLR3_UINT64_LIT(0x0000000040000000) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_playlist42 = { FOLLOW_STR_in_playlist42_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_30_in_playlist44 */
+static ANTLR3_BITWORD FOLLOW_30_in_playlist44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
+static ANTLR3_BITSET_LIST FOLLOW_30_in_playlist44 = { FOLLOW_30_in_playlist44_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_playlist46 */
+static ANTLR3_BITWORD FOLLOW_expression_in_playlist46_bits[] = { ANTLR3_UINT64_LIT(0x0000000080000000) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_playlist46 = { FOLLOW_expression_in_playlist46_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_31_in_playlist48 */
+static ANTLR3_BITWORD FOLLOW_31_in_playlist48_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) };
+static ANTLR3_BITSET_LIST FOLLOW_31_in_playlist48 = { FOLLOW_31_in_playlist48_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_playlist50 */
+static ANTLR3_BITWORD FOLLOW_EOF_in_playlist50_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_EOF_in_playlist50 = { FOLLOW_EOF_in_playlist50_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expression62 */
+static ANTLR3_BITWORD FOLLOW_aexpr_in_expression62_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
+static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expression62 = { FOLLOW_aexpr_in_expression62_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expression65 */
+static ANTLR3_BITWORD FOLLOW_OR_in_expression65_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
+static ANTLR3_BITSET_LIST FOLLOW_OR_in_expression65 = { FOLLOW_OR_in_expression65_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expression68 */
+static ANTLR3_BITWORD FOLLOW_aexpr_in_expression68_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
+static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expression68 = { FOLLOW_aexpr_in_expression68_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_nexpr_in_aexpr83 */
+static ANTLR3_BITWORD FOLLOW_nexpr_in_aexpr83_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
+static ANTLR3_BITSET_LIST FOLLOW_nexpr_in_aexpr83 = { FOLLOW_nexpr_in_aexpr83_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_aexpr86 */
+static ANTLR3_BITWORD FOLLOW_AND_in_aexpr86_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
+static ANTLR3_BITSET_LIST FOLLOW_AND_in_aexpr86 = { FOLLOW_AND_in_aexpr86_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_nexpr_in_aexpr89 */
+static ANTLR3_BITWORD FOLLOW_nexpr_in_aexpr89_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
+static ANTLR3_BITSET_LIST FOLLOW_nexpr_in_aexpr89 = { FOLLOW_nexpr_in_aexpr89_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_nexpr104 */
+static ANTLR3_BITWORD FOLLOW_NOT_in_nexpr104_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
+static ANTLR3_BITSET_LIST FOLLOW_NOT_in_nexpr104 = { FOLLOW_NOT_in_nexpr104_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_nexpr107 */
+static ANTLR3_BITWORD FOLLOW_crit_in_nexpr107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_crit_in_nexpr107 = { FOLLOW_crit_in_nexpr107_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_nexpr114 */
+static ANTLR3_BITWORD FOLLOW_crit_in_nexpr114_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_crit_in_nexpr114 = { FOLLOW_crit_in_nexpr114_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit127 */
+static ANTLR3_BITWORD FOLLOW_LPAR_in_crit127_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
+static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit127 = { FOLLOW_LPAR_in_crit127_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_crit129 */
+static ANTLR3_BITWORD FOLLOW_expression_in_crit129_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000200) };
+static ANTLR3_BITSET_LIST FOLLOW_expression_in_crit129 = { FOLLOW_expression_in_crit129_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit131 */
+static ANTLR3_BITWORD FOLLOW_RPAR_in_crit131_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit131 = { FOLLOW_RPAR_in_crit131_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRTAG_in_crit142 */
+static ANTLR3_BITWORD FOLLOW_STRTAG_in_crit142_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001800) };
+static ANTLR3_BITSET_LIST FOLLOW_STRTAG_in_crit142 = { FOLLOW_STRTAG_in_crit142_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_crit144 */
+static ANTLR3_BITWORD FOLLOW_set_in_crit144_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
+static ANTLR3_BITSET_LIST FOLLOW_set_in_crit144 = { FOLLOW_set_in_crit144_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_crit150 */
+static ANTLR3_BITWORD FOLLOW_STR_in_crit150_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_STR_in_crit150 = { FOLLOW_STR_in_crit150_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTTAG_in_crit157 */
+static ANTLR3_BITWORD FOLLOW_INTTAG_in_crit157_bits[] = { ANTLR3_UINT64_LIT(0x0000000000004000) };
+static ANTLR3_BITSET_LIST FOLLOW_INTTAG_in_crit157 = { FOLLOW_INTTAG_in_crit157_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTBOOL_in_crit159 */
+static ANTLR3_BITWORD FOLLOW_INTBOOL_in_crit159_bits[] = { ANTLR3_UINT64_LIT(0x0000000000008000) };
+static ANTLR3_BITSET_LIST FOLLOW_INTBOOL_in_crit159 = { FOLLOW_INTBOOL_in_crit159_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_crit161 */
+static ANTLR3_BITWORD FOLLOW_INT_in_crit161_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_crit161 = { FOLLOW_INT_in_crit161_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATETAG_in_crit168 */
+static ANTLR3_BITWORD FOLLOW_DATETAG_in_crit168_bits[] = { ANTLR3_UINT64_LIT(0x0000000000060000) };
+static ANTLR3_BITSET_LIST FOLLOW_DATETAG_in_crit168 = { FOLLOW_DATETAG_in_crit168_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_crit170 */
+static ANTLR3_BITWORD FOLLOW_set_in_crit170_bits[] = { ANTLR3_UINT64_LIT(0x0000000000208000) };
+static ANTLR3_BITSET_LIST FOLLOW_set_in_crit170 = { FOLLOW_set_in_crit170_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateval_in_crit176 */
+static ANTLR3_BITWORD FOLLOW_dateval_in_crit176_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_dateval_in_crit176 = { FOLLOW_dateval_in_crit176_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMTAG_in_crit183 */
+static ANTLR3_BITWORD FOLLOW_ENUMTAG_in_crit183_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001000) };
+static ANTLR3_BITSET_LIST FOLLOW_ENUMTAG_in_crit183 = { FOLLOW_ENUMTAG_in_crit183_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_IS_in_crit185 */
+static ANTLR3_BITWORD FOLLOW_IS_in_crit185_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) };
+static ANTLR3_BITSET_LIST FOLLOW_IS_in_crit185 = { FOLLOW_IS_in_crit185_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMVAL_in_crit187 */
+static ANTLR3_BITWORD FOLLOW_ENUMVAL_in_crit187_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_ENUMVAL_in_crit187 = { FOLLOW_ENUMVAL_in_crit187_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval200 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateval200_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval200 = { FOLLOW_DATE_in_dateval200_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval207 */
+static ANTLR3_BITWORD FOLLOW_interval_in_dateval207_bits[] = { ANTLR3_UINT64_LIT(0x0000000000040000) };
+static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval207 = { FOLLOW_interval_in_dateval207_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateval209 */
+static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateval209_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
+static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateval209 = { FOLLOW_BEFORE_in_dateval209_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval211 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateval211_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval211 = { FOLLOW_DATE_in_dateval211_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval218 */
+static ANTLR3_BITWORD FOLLOW_interval_in_dateval218_bits[] = { ANTLR3_UINT64_LIT(0x0000000000020000) };
+static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval218 = { FOLLOW_interval_in_dateval218_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateval220 */
+static ANTLR3_BITWORD FOLLOW_AFTER_in_dateval220_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
+static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateval220 = { FOLLOW_AFTER_in_dateval220_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval222 */
+static ANTLR3_BITWORD FOLLOW_DATE_in_dateval222_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval222 = { FOLLOW_DATE_in_dateval222_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval229 */
+static ANTLR3_BITWORD FOLLOW_interval_in_dateval229_bits[] = { ANTLR3_UINT64_LIT(0x0000000000400000) };
+static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval229 = { FOLLOW_interval_in_dateval229_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_AGO_in_dateval231 */
+static ANTLR3_BITWORD FOLLOW_AGO_in_dateval231_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_AGO_in_dateval231 = { FOLLOW_AGO_in_dateval231_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_interval243 */
+static ANTLR3_BITWORD FOLLOW_INT_in_interval243_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
+static ANTLR3_BITSET_LIST FOLLOW_INT_in_interval243 = { FOLLOW_INT_in_interval243_bits, 1 };
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATINTERVAL_in_interval245 */
+static ANTLR3_BITWORD FOLLOW_DATINTERVAL_in_interval245_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static ANTLR3_BITSET_LIST FOLLOW_DATINTERVAL_in_interval245 = { FOLLOW_DATINTERVAL_in_interval245_bits, 1 };
+
+
+
+
+/* ==============================================
+ * Parsing rules
+ */
+/**
+ * $ANTLR start playlist
+ * SMARTPL.g:27:1: playlist : STR '{' expression '}' EOF ;
+ */
+static SMARTPLParser_playlist_return
+playlist(pSMARTPLParser ctx)
+{
+ SMARTPLParser_playlist_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN STR1;
+ pANTLR3_COMMON_TOKEN char_literal2;
+ pANTLR3_COMMON_TOKEN char_literal4;
+ pANTLR3_COMMON_TOKEN EOF5;
+ SMARTPLParser_expression_return expression3;
+ #undef RETURN_TYPE_expression3
+ #define RETURN_TYPE_expression3 SMARTPLParser_expression_return
+
+ pANTLR3_BASE_TREE STR1_tree;
+ pANTLR3_BASE_TREE char_literal2_tree;
+ pANTLR3_BASE_TREE char_literal4_tree;
+ pANTLR3_BASE_TREE EOF5_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ STR1 = NULL;
+ char_literal2 = NULL;
+ char_literal4 = NULL;
+ EOF5 = NULL;
+ expression3.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ STR1_tree = NULL;
+ char_literal2_tree = NULL;
+ char_literal4_tree = NULL;
+ EOF5_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // SMARTPL.g:27:10: ( STR '{' expression '}' EOF )
+ // SMARTPL.g:27:12: STR '{' expression '}' EOF
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ STR1 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_playlist42);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ STR1_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STR1));
+ ADAPTOR->addChild(ADAPTOR, root_0, STR1_tree);
+
+ char_literal2 = (pANTLR3_COMMON_TOKEN) MATCHT(30, &FOLLOW_30_in_playlist44);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ char_literal2_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal2));
+ ADAPTOR->addChild(ADAPTOR, root_0, char_literal2_tree);
+
+ FOLLOWPUSH(FOLLOW_expression_in_playlist46);
+ expression3=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, expression3.tree);
+ char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(31, &FOLLOW_31_in_playlist48);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ char_literal4_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal4));
+ ADAPTOR->addChild(ADAPTOR, root_0, char_literal4_tree);
+
+ EOF5 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_playlist50);
+ if (HASEXCEPTION())
+ {
+ goto ruleplaylistEx;
+ }
+
+ EOF5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EOF5));
+ ADAPTOR->addChild(ADAPTOR, root_0, EOF5_tree);
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleplaylistEx; /* Prevent compiler warnings */
+ ruleplaylistEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end playlist */
+
+/**
+ * $ANTLR start expression
+ * SMARTPL.g:30:1: expression : aexpr ( OR aexpr )* ;
+ */
+static SMARTPLParser_expression_return
+expression(pSMARTPLParser ctx)
+{
+ SMARTPLParser_expression_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN OR7;
+ SMARTPLParser_aexpr_return aexpr6;
+ #undef RETURN_TYPE_aexpr6
+ #define RETURN_TYPE_aexpr6 SMARTPLParser_aexpr_return
+
+ SMARTPLParser_aexpr_return aexpr8;
+ #undef RETURN_TYPE_aexpr8
+ #define RETURN_TYPE_aexpr8 SMARTPLParser_aexpr_return
+
+ pANTLR3_BASE_TREE OR7_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ OR7 = NULL;
+ aexpr6.tree = NULL;
+
+ aexpr8.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ OR7_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // SMARTPL.g:30:12: ( aexpr ( OR aexpr )* )
+ // SMARTPL.g:30:14: aexpr ( OR aexpr )*
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_aexpr_in_expression62);
+ aexpr6=aexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree);
+
+ // SMARTPL.g:30:20: ( OR aexpr )*
+
+ for (;;)
+ {
+ int alt1=2;
+ switch ( LA(1) )
+ {
+ case OR:
+ {
+ alt1=1;
+ }
+ break;
+
+ }
+
+ switch (alt1)
+ {
+ case 1:
+ // SMARTPL.g:30:21: OR aexpr
+ {
+ OR7 = (pANTLR3_COMMON_TOKEN) MATCHT(OR, &FOLLOW_OR_in_expression65);
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ OR7_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OR7));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OR7_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_aexpr_in_expression68);
+ aexpr8=aexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleexpressionEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, aexpr8.tree);
+
+ }
+ break;
+
+ default:
+ goto loop1; /* break out of the loop */
+ break;
+ }
+ }
+ loop1: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleexpressionEx; /* Prevent compiler warnings */
+ ruleexpressionEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end expression */
+
+/**
+ * $ANTLR start aexpr
+ * SMARTPL.g:33:1: aexpr : nexpr ( AND nexpr )* ;
+ */
+static SMARTPLParser_aexpr_return
+aexpr(pSMARTPLParser ctx)
+{
+ SMARTPLParser_aexpr_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN AND10;
+ SMARTPLParser_nexpr_return nexpr9;
+ #undef RETURN_TYPE_nexpr9
+ #define RETURN_TYPE_nexpr9 SMARTPLParser_nexpr_return
+
+ SMARTPLParser_nexpr_return nexpr11;
+ #undef RETURN_TYPE_nexpr11
+ #define RETURN_TYPE_nexpr11 SMARTPLParser_nexpr_return
+
+ pANTLR3_BASE_TREE AND10_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ AND10 = NULL;
+ nexpr9.tree = NULL;
+
+ nexpr11.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ AND10_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // SMARTPL.g:33:8: ( nexpr ( AND nexpr )* )
+ // SMARTPL.g:33:10: nexpr ( AND nexpr )*
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_nexpr_in_aexpr83);
+ nexpr9=nexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, nexpr9.tree);
+
+ // SMARTPL.g:33:16: ( AND nexpr )*
+
+ for (;;)
+ {
+ int alt2=2;
+ switch ( LA(1) )
+ {
+ case AND:
+ {
+ alt2=1;
+ }
+ break;
+
+ }
+
+ switch (alt2)
+ {
+ case 1:
+ // SMARTPL.g:33:17: AND nexpr
+ {
+ AND10 = (pANTLR3_COMMON_TOKEN) MATCHT(AND, &FOLLOW_AND_in_aexpr86);
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ AND10_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AND10));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, AND10_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_nexpr_in_aexpr89);
+ nexpr11=nexpr(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruleaexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, nexpr11.tree);
+
+ }
+ break;
+
+ default:
+ goto loop2; /* break out of the loop */
+ break;
+ }
+ }
+ loop2: ; /* Jump out to here if this rule does not match */
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleaexprEx; /* Prevent compiler warnings */
+ ruleaexprEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end aexpr */
+
+/**
+ * $ANTLR start nexpr
+ * SMARTPL.g:36:1: nexpr : ( NOT crit | crit );
+ */
+static SMARTPLParser_nexpr_return
+nexpr(pSMARTPLParser ctx)
+{
+ SMARTPLParser_nexpr_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN NOT12;
+ SMARTPLParser_crit_return crit13;
+ #undef RETURN_TYPE_crit13
+ #define RETURN_TYPE_crit13 SMARTPLParser_crit_return
+
+ SMARTPLParser_crit_return crit14;
+ #undef RETURN_TYPE_crit14
+ #define RETURN_TYPE_crit14 SMARTPLParser_crit_return
+
+ pANTLR3_BASE_TREE NOT12_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ NOT12 = NULL;
+ crit13.tree = NULL;
+
+ crit14.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ NOT12_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // SMARTPL.g:36:8: ( NOT crit | crit )
+
+ ANTLR3_UINT32 alt3;
+
+ alt3=2;
+
+ switch ( LA(1) )
+ {
+ case NOT:
+ {
+ alt3=1;
+ }
+ break;
+ case LPAR:
+ case STRTAG:
+ case INTTAG:
+ case DATETAG:
+ case ENUMTAG:
+ {
+ alt3=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 3;
+ EXCEPTION->state = 0;
+
+
+ goto rulenexprEx;
+ }
+
+ switch (alt3)
+ {
+ case 1:
+ // SMARTPL.g:36:10: NOT crit
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ NOT12 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_nexpr104);
+ if (HASEXCEPTION())
+ {
+ goto rulenexprEx;
+ }
+
+ NOT12_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NOT12));
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, NOT12_tree, root_0));
+
+ FOLLOWPUSH(FOLLOW_crit_in_nexpr107);
+ crit13=crit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulenexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, crit13.tree);
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:37:6: crit
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_crit_in_nexpr114);
+ crit14=crit(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulenexprEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, crit14.tree);
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulenexprEx; /* Prevent compiler warnings */
+ rulenexprEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end nexpr */
+
+/**
+ * $ANTLR start crit
+ * SMARTPL.g:40:1: crit : ( LPAR expression RPAR -> expression | STRTAG ( INCLUDES | IS ) STR | INTTAG INTBOOL INT | DATETAG ( AFTER | BEFORE ) dateval | ENUMTAG IS ENUMVAL );
+ */
+static SMARTPLParser_crit_return
+crit(pSMARTPLParser ctx)
+{
+ SMARTPLParser_crit_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN LPAR15;
+ pANTLR3_COMMON_TOKEN RPAR17;
+ pANTLR3_COMMON_TOKEN STRTAG18;
+ pANTLR3_COMMON_TOKEN set19;
+ pANTLR3_COMMON_TOKEN STR20;
+ pANTLR3_COMMON_TOKEN INTTAG21;
+ pANTLR3_COMMON_TOKEN INTBOOL22;
+ pANTLR3_COMMON_TOKEN INT23;
+ pANTLR3_COMMON_TOKEN DATETAG24;
+ pANTLR3_COMMON_TOKEN set25;
+ pANTLR3_COMMON_TOKEN ENUMTAG27;
+ pANTLR3_COMMON_TOKEN IS28;
+ pANTLR3_COMMON_TOKEN ENUMVAL29;
+ SMARTPLParser_expression_return expression16;
+ #undef RETURN_TYPE_expression16
+ #define RETURN_TYPE_expression16 SMARTPLParser_expression_return
+
+ SMARTPLParser_dateval_return dateval26;
+ #undef RETURN_TYPE_dateval26
+ #define RETURN_TYPE_dateval26 SMARTPLParser_dateval_return
+
+ pANTLR3_BASE_TREE LPAR15_tree;
+ pANTLR3_BASE_TREE RPAR17_tree;
+ pANTLR3_BASE_TREE STRTAG18_tree;
+ pANTLR3_BASE_TREE set19_tree;
+ pANTLR3_BASE_TREE STR20_tree;
+ pANTLR3_BASE_TREE INTTAG21_tree;
+ pANTLR3_BASE_TREE INTBOOL22_tree;
+ pANTLR3_BASE_TREE INT23_tree;
+ pANTLR3_BASE_TREE DATETAG24_tree;
+ pANTLR3_BASE_TREE set25_tree;
+ pANTLR3_BASE_TREE ENUMTAG27_tree;
+ pANTLR3_BASE_TREE IS28_tree;
+ pANTLR3_BASE_TREE ENUMVAL29_tree;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR;
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR;
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expression;
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ LPAR15 = NULL;
+ RPAR17 = NULL;
+ STRTAG18 = NULL;
+ set19 = NULL;
+ STR20 = NULL;
+ INTTAG21 = NULL;
+ INTBOOL22 = NULL;
+ INT23 = NULL;
+ DATETAG24 = NULL;
+ set25 = NULL;
+ ENUMTAG27 = NULL;
+ IS28 = NULL;
+ ENUMVAL29 = NULL;
+ expression16.tree = NULL;
+
+ dateval26.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ LPAR15_tree = NULL;
+ RPAR17_tree = NULL;
+ STRTAG18_tree = NULL;
+ set19_tree = NULL;
+ STR20_tree = NULL;
+ INTTAG21_tree = NULL;
+ INTBOOL22_tree = NULL;
+ INT23_tree = NULL;
+ DATETAG24_tree = NULL;
+ set25_tree = NULL;
+ ENUMTAG27_tree = NULL;
+ IS28_tree = NULL;
+ ENUMVAL29_tree = NULL;
+
+ stream_RPAR = NULL;
+ #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); }
+ stream_LPAR = NULL;
+ #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); }
+ stream_expression = NULL;
+ #define CREATE_stream_expression if (stream_expression == NULL) {stream_expression = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expression"); }
+
+ retval.tree = NULL;
+ {
+ {
+ // SMARTPL.g:40:7: ( LPAR expression RPAR -> expression | STRTAG ( INCLUDES | IS ) STR | INTTAG INTBOOL INT | DATETAG ( AFTER | BEFORE ) dateval | ENUMTAG IS ENUMVAL )
+
+ ANTLR3_UINT32 alt4;
+
+ alt4=5;
+
+ switch ( LA(1) )
+ {
+ case LPAR:
+ {
+ alt4=1;
+ }
+ break;
+ case STRTAG:
+ {
+ alt4=2;
+ }
+ break;
+ case INTTAG:
+ {
+ alt4=3;
+ }
+ break;
+ case DATETAG:
+ {
+ alt4=4;
+ }
+ break;
+ case ENUMTAG:
+ {
+ alt4=5;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 4;
+ EXCEPTION->state = 0;
+
+
+ goto rulecritEx;
+ }
+
+ switch (alt4)
+ {
+ case 1:
+ // SMARTPL.g:40:9: LPAR expression RPAR
+ {
+ LPAR15 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit127);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR15, NULL);
+
+ FOLLOWPUSH(FOLLOW_expression_in_crit129);
+ expression16=expression(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_expression; stream_expression->add(stream_expression, expression16.tree, NULL);
+ RPAR17 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit131);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR17, NULL);
+
+
+
+ /* AST REWRITE
+ * elements : expression
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ * rule list labels :
+ */
+ {
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
+
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
+
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+ retval.tree = root_0;
+ // 40:30: -> expression
+ {
+ ADAPTOR->addChild(ADAPTOR, root_0, stream_expression == NULL ? NULL : stream_expression->nextTree(stream_expression));
+
+ }
+
+ retval.tree = root_0; // set result root
+ if (stream_retval != NULL) stream_retval->free(stream_retval);
+
+
+ }
+ }
+ break;
+ case 2:
+ // SMARTPL.g:41:6: STRTAG ( INCLUDES | IS ) STR
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ STRTAG18 = (pANTLR3_COMMON_TOKEN) MATCHT(STRTAG, &FOLLOW_STRTAG_in_crit142);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ STRTAG18_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STRTAG18));
+ ADAPTOR->addChild(ADAPTOR, root_0, STRTAG18_tree);
+
+ set19=(pANTLR3_COMMON_TOKEN)LT(1);
+ if ( ((LA(1) >= INCLUDES) && (LA(1) <= IS)) )
+ {
+ CONSUME();
+ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set19)));
+ PERRORRECOVERY=ANTLR3_FALSE;
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+ EXCEPTION->expectingSet = &FOLLOW_set_in_crit144;
+ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_crit144); goto rulecritEx;
+ }
+
+ STR20 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_crit150);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ STR20_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STR20));
+ ADAPTOR->addChild(ADAPTOR, root_0, STR20_tree);
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:42:6: INTTAG INTBOOL INT
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ INTTAG21 = (pANTLR3_COMMON_TOKEN) MATCHT(INTTAG, &FOLLOW_INTTAG_in_crit157);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ INTTAG21_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INTTAG21));
+ ADAPTOR->addChild(ADAPTOR, root_0, INTTAG21_tree);
+
+ INTBOOL22 = (pANTLR3_COMMON_TOKEN) MATCHT(INTBOOL, &FOLLOW_INTBOOL_in_crit159);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ INTBOOL22_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INTBOOL22));
+ ADAPTOR->addChild(ADAPTOR, root_0, INTBOOL22_tree);
+
+ INT23 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_crit161);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ INT23_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT23));
+ ADAPTOR->addChild(ADAPTOR, root_0, INT23_tree);
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:43:6: DATETAG ( AFTER | BEFORE ) dateval
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ DATETAG24 = (pANTLR3_COMMON_TOKEN) MATCHT(DATETAG, &FOLLOW_DATETAG_in_crit168);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ DATETAG24_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATETAG24));
+ ADAPTOR->addChild(ADAPTOR, root_0, DATETAG24_tree);
+
+ set25=(pANTLR3_COMMON_TOKEN)LT(1);
+ if ( ((LA(1) >= AFTER) && (LA(1) <= BEFORE)) )
+ {
+ CONSUME();
+ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set25)));
+ PERRORRECOVERY=ANTLR3_FALSE;
+ }
+ else
+ {
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
+ EXCEPTION->expectingSet = &FOLLOW_set_in_crit170;
+ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_crit170); goto rulecritEx;
+ }
+
+ FOLLOWPUSH(FOLLOW_dateval_in_crit176);
+ dateval26=dateval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, dateval26.tree);
+
+ }
+ break;
+ case 5:
+ // SMARTPL.g:44:6: ENUMTAG IS ENUMVAL
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ ENUMTAG27 = (pANTLR3_COMMON_TOKEN) MATCHT(ENUMTAG, &FOLLOW_ENUMTAG_in_crit183);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ ENUMTAG27_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, ENUMTAG27));
+ ADAPTOR->addChild(ADAPTOR, root_0, ENUMTAG27_tree);
+
+ IS28 = (pANTLR3_COMMON_TOKEN) MATCHT(IS, &FOLLOW_IS_in_crit185);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ IS28_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, IS28));
+ ADAPTOR->addChild(ADAPTOR, root_0, IS28_tree);
+
+ ENUMVAL29 = (pANTLR3_COMMON_TOKEN) MATCHT(ENUMVAL, &FOLLOW_ENUMVAL_in_crit187);
+ if (HASEXCEPTION())
+ {
+ goto rulecritEx;
+ }
+
+ ENUMVAL29_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, ENUMVAL29));
+ ADAPTOR->addChild(ADAPTOR, root_0, ENUMVAL29_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto rulecritEx; /* Prevent compiler warnings */
+ rulecritEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+ if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR);
+ if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR);
+ if (stream_expression != NULL) stream_expression->free(stream_expression);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end crit */
+
+/**
+ * $ANTLR start dateval
+ * SMARTPL.g:47:1: dateval : ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO );
+ */
+static SMARTPLParser_dateval_return
+dateval(pSMARTPLParser ctx)
+{
+ SMARTPLParser_dateval_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN DATE30;
+ pANTLR3_COMMON_TOKEN BEFORE32;
+ pANTLR3_COMMON_TOKEN DATE33;
+ pANTLR3_COMMON_TOKEN AFTER35;
+ pANTLR3_COMMON_TOKEN DATE36;
+ pANTLR3_COMMON_TOKEN AGO38;
+ SMARTPLParser_interval_return interval31;
+ #undef RETURN_TYPE_interval31
+ #define RETURN_TYPE_interval31 SMARTPLParser_interval_return
+
+ SMARTPLParser_interval_return interval34;
+ #undef RETURN_TYPE_interval34
+ #define RETURN_TYPE_interval34 SMARTPLParser_interval_return
+
+ SMARTPLParser_interval_return interval37;
+ #undef RETURN_TYPE_interval37
+ #define RETURN_TYPE_interval37 SMARTPLParser_interval_return
+
+ pANTLR3_BASE_TREE DATE30_tree;
+ pANTLR3_BASE_TREE BEFORE32_tree;
+ pANTLR3_BASE_TREE DATE33_tree;
+ pANTLR3_BASE_TREE AFTER35_tree;
+ pANTLR3_BASE_TREE DATE36_tree;
+ pANTLR3_BASE_TREE AGO38_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ DATE30 = NULL;
+ BEFORE32 = NULL;
+ DATE33 = NULL;
+ AFTER35 = NULL;
+ DATE36 = NULL;
+ AGO38 = NULL;
+ interval31.tree = NULL;
+
+ interval34.tree = NULL;
+
+ interval37.tree = NULL;
+
+ retval.start = LT(1); retval.stop = retval.start;
+
+ DATE30_tree = NULL;
+ BEFORE32_tree = NULL;
+ DATE33_tree = NULL;
+ AFTER35_tree = NULL;
+ DATE36_tree = NULL;
+ AGO38_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ {
+ // SMARTPL.g:47:10: ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO )
+
+ ANTLR3_UINT32 alt5;
+
+ alt5=4;
+
+ switch ( LA(1) )
+ {
+ case DATE:
+ {
+ alt5=1;
+ }
+ break;
+ case INT:
+ {
+ switch ( LA(2) )
+ {
+ case DATINTERVAL:
+ {
+ switch ( LA(3) )
+ {
+ case AGO:
+ {
+ alt5=4;
+ }
+ break;
+ case AFTER:
+ {
+ alt5=3;
+ }
+ break;
+ case BEFORE:
+ {
+ alt5=2;
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 3;
+
+
+ goto ruledatevalEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 2;
+
+
+ goto ruledatevalEx;
+ }
+
+ }
+ break;
+
+ default:
+ CONSTRUCTEX();
+ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+ EXCEPTION->message = (void *)"";
+ EXCEPTION->decisionNum = 5;
+ EXCEPTION->state = 0;
+
+
+ goto ruledatevalEx;
+ }
+
+ switch (alt5)
+ {
+ case 1:
+ // SMARTPL.g:47:12: DATE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ DATE30 = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateval200);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ DATE30_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATE30));
+ ADAPTOR->addChild(ADAPTOR, root_0, DATE30_tree);
+
+
+ }
+ break;
+ case 2:
+ // SMARTPL.g:48:6: interval BEFORE DATE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_interval_in_dateval207);
+ interval31=interval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, interval31.tree);
+ BEFORE32 = (pANTLR3_COMMON_TOKEN) MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateval209);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ BEFORE32_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, BEFORE32));
+ ADAPTOR->addChild(ADAPTOR, root_0, BEFORE32_tree);
+
+ DATE33 = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateval211);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ DATE33_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATE33));
+ ADAPTOR->addChild(ADAPTOR, root_0, DATE33_tree);
+
+
+ }
+ break;
+ case 3:
+ // SMARTPL.g:49:6: interval AFTER DATE
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_interval_in_dateval218);
+ interval34=interval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, interval34.tree);
+ AFTER35 = (pANTLR3_COMMON_TOKEN) MATCHT(AFTER, &FOLLOW_AFTER_in_dateval220);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ AFTER35_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AFTER35));
+ ADAPTOR->addChild(ADAPTOR, root_0, AFTER35_tree);
+
+ DATE36 = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateval222);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ DATE36_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATE36));
+ ADAPTOR->addChild(ADAPTOR, root_0, DATE36_tree);
+
+
+ }
+ break;
+ case 4:
+ // SMARTPL.g:50:6: interval AGO
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ FOLLOWPUSH(FOLLOW_interval_in_dateval229);
+ interval37=interval(ctx);
+
+ FOLLOWPOP();
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ ADAPTOR->addChild(ADAPTOR, root_0, interval37.tree);
+ AGO38 = (pANTLR3_COMMON_TOKEN) MATCHT(AGO, &FOLLOW_AGO_in_dateval231);
+ if (HASEXCEPTION())
+ {
+ goto ruledatevalEx;
+ }
+
+ AGO38_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AGO38));
+ ADAPTOR->addChild(ADAPTOR, root_0, AGO38_tree);
+
+
+ }
+ break;
+
+ }
+ }
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruledatevalEx; /* Prevent compiler warnings */
+ ruledatevalEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end dateval */
+
+/**
+ * $ANTLR start interval
+ * SMARTPL.g:53:1: interval : INT DATINTERVAL ;
+ */
+static SMARTPLParser_interval_return
+interval(pSMARTPLParser ctx)
+{
+ SMARTPLParser_interval_return retval;
+
+ pANTLR3_BASE_TREE root_0;
+
+ pANTLR3_COMMON_TOKEN INT39;
+ pANTLR3_COMMON_TOKEN DATINTERVAL40;
+
+ pANTLR3_BASE_TREE INT39_tree;
+ pANTLR3_BASE_TREE DATINTERVAL40_tree;
+
+ /* Initialize rule variables
+ */
+
+
+ root_0 = NULL;
+
+ INT39 = NULL;
+ DATINTERVAL40 = NULL;
+ retval.start = LT(1); retval.stop = retval.start;
+
+ INT39_tree = NULL;
+ DATINTERVAL40_tree = NULL;
+
+
+ retval.tree = NULL;
+ {
+ // SMARTPL.g:53:10: ( INT DATINTERVAL )
+ // SMARTPL.g:53:12: INT DATINTERVAL
+ {
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+ INT39 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_interval243);
+ if (HASEXCEPTION())
+ {
+ goto ruleintervalEx;
+ }
+
+ INT39_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT39));
+ ADAPTOR->addChild(ADAPTOR, root_0, INT39_tree);
+
+ DATINTERVAL40 = (pANTLR3_COMMON_TOKEN) MATCHT(DATINTERVAL, &FOLLOW_DATINTERVAL_in_interval245);
+ if (HASEXCEPTION())
+ {
+ goto ruleintervalEx;
+ }
+
+ DATINTERVAL40_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATINTERVAL40));
+ ADAPTOR->addChild(ADAPTOR, root_0, DATINTERVAL40_tree);
+
+
+ }
+
+ }
+
+
+ // This is where rules clean up and exit
+ //
+ goto ruleintervalEx; /* Prevent compiler warnings */
+ ruleintervalEx: ;
+ retval.stop = LT(-1);
+
+ retval.stop = LT(-1);
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
+
+ if (HASEXCEPTION())
+ {
+ PREPORTERROR();
+ PRECOVER();
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
+ }
+
+
+ return retval;
+}
+/* $ANTLR end interval */
+/* End of parsing rules
+ * ==============================================
+ */
+
+/* ==============================================
+ * Syntactic predicates
+ */
+/* End of syntactic predicates
+ * ==============================================
+ */
+
+
+
+
+
+
+/* End of code
+ * =============================================================================
+ */
diff --git a/src/pregen/SMARTPLParser.h b/src/pregen/SMARTPLParser.h
new file mode 100644
index 0000000..38ef500
--- /dev/null
+++ b/src/pregen/SMARTPLParser.h
@@ -0,0 +1,285 @@
+/** \file
+ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : SMARTPL.g
+ * - On : 2016-01-01 12:23:40
+ * - for the parser : SMARTPLParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
+ *
+ *
+ * The parser SMARTPLParser has the callable functions (rules) shown below,
+ * which will invoke the code for the associated rule in the source grammar
+ * assuming that the input stream is pointing to a token/text stream that could begin
+ * this rule.
+ *
+ * For instance if you call the first (topmost) rule in a parser grammar, you will
+ * get the results of a full parse, but calling a rule half way through the grammar will
+ * allow you to pass part of a full token stream to the parser, such as for syntax checking
+ * in editors and so on.
+ *
+ * The parser entry points are called indirectly (by function pointer to function) via
+ * a parser context typedef pSMARTPLParser, which is returned from a call to SMARTPLParserNew().
+ *
+ * The methods in pSMARTPLParser are as follows:
+ *
+ * - SMARTPLParser_playlist_return pSMARTPLParser->playlist(pSMARTPLParser)
+ * - SMARTPLParser_expression_return pSMARTPLParser->expression(pSMARTPLParser)
+ * - SMARTPLParser_aexpr_return pSMARTPLParser->aexpr(pSMARTPLParser)
+ * - SMARTPLParser_nexpr_return pSMARTPLParser->nexpr(pSMARTPLParser)
+ * - SMARTPLParser_crit_return pSMARTPLParser->crit(pSMARTPLParser)
+ * - SMARTPLParser_dateval_return pSMARTPLParser->dateval(pSMARTPLParser)
+ * - SMARTPLParser_interval_return pSMARTPLParser->interval(pSMARTPLParser)
+ *
+ * The return type for any particular rule is of course determined by the source
+ * grammar file.
+ */
+// [The "BSD licence"]
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
+// http://www.temporal-wave.com
+// http://www.linkedin.com/in/jimidle
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _SMARTPLParser_H
+#define _SMARTPLParser_H
+/* =============================================================================
+ * Standard antlr3 C runtime definitions
+ */
+#include <antlr3.h>
+
+/* End of standard antlr 3 runtime definitions
+ * =============================================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare the context typedef so that we can use it before it is
+// properly defined. Delegators and delegates (from import statements) are
+// interdependent and their context structures contain pointers to each other
+// C only allows such things to be declared if you pre-declare the typedef.
+//
+typedef struct SMARTPLParser_Ctx_struct SMARTPLParser, * pSMARTPLParser;
+
+
+
+#ifdef ANTLR3_WINDOWS
+// Disable: Unreferenced parameter, - Rules with parameters that are not used
+// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
+// initialized but unused variable - tree rewrite variables declared but not needed
+// Unreferenced local variable - lexer rule declares but does not always use _type
+// potentially unitialized variable used - retval always returned from a rule
+// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
+//
+// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
+// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
+// usually generated when a parser rule is given a parameter that it does not use. Mostly though
+// this is a matter of orthogonality hence I disable that one.
+//
+#pragma warning( disable : 4100 )
+#pragma warning( disable : 4101 )
+#pragma warning( disable : 4127 )
+#pragma warning( disable : 4189 )
+#pragma warning( disable : 4505 )
+#pragma warning( disable : 4701 )
+#endif
+typedef struct SMARTPLParser_playlist_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_playlist_return;
+
+typedef struct SMARTPLParser_expression_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_expression_return;
+
+typedef struct SMARTPLParser_aexpr_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_aexpr_return;
+
+typedef struct SMARTPLParser_nexpr_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_nexpr_return;
+
+typedef struct SMARTPLParser_crit_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_crit_return;
+
+typedef struct SMARTPLParser_dateval_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_dateval_return;
+
+typedef struct SMARTPLParser_interval_return_struct
+{
+ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
+ */
+ pANTLR3_COMMON_TOKEN start;
+ pANTLR3_COMMON_TOKEN stop;
+ pANTLR3_BASE_TREE tree;
+
+}
+ SMARTPLParser_interval_return;
+
+
+
+/** Context tracking structure for SMARTPLParser
+ */
+struct SMARTPLParser_Ctx_struct
+{
+ /** Built in ANTLR3 context tracker contains all the generic elements
+ * required for context tracking.
+ */
+ pANTLR3_PARSER pParser;
+
+
+ SMARTPLParser_playlist_return (*playlist) (struct SMARTPLParser_Ctx_struct * ctx);
+ SMARTPLParser_expression_return (*expression) (struct SMARTPLParser_Ctx_struct * ctx);
+ SMARTPLParser_aexpr_return (*aexpr) (struct SMARTPLParser_Ctx_struct * ctx);
+ SMARTPLParser_nexpr_return (*nexpr) (struct SMARTPLParser_Ctx_struct * ctx);
+ SMARTPLParser_crit_return (*crit) (struct SMARTPLParser_Ctx_struct * ctx);
+ SMARTPLParser_dateval_return (*dateval) (struct SMARTPLParser_Ctx_struct * ctx);
+ SMARTPLParser_interval_return (*interval) (struct SMARTPLParser_Ctx_struct * ctx);
+ // Delegated rules
+ const char * (*getGrammarFileName)();
+ void (*free) (struct SMARTPLParser_Ctx_struct * ctx);
+ /* @headerFile.members() */
+ pANTLR3_BASE_TREE_ADAPTOR adaptor;
+ pANTLR3_VECTOR_FACTORY vectors;
+ /* End @headerFile.members() */
+};
+
+// Function protoypes for the constructor functions that external translation units
+// such as delegators and delegates may wish to call.
+//
+ANTLR3_API pSMARTPLParser SMARTPLParserNew (pANTLR3_COMMON_TOKEN_STREAM instream);
+ANTLR3_API pSMARTPLParser SMARTPLParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
+
+/** Symbolic definitions of all the tokens that the parser will work with.
+ * \{
+ *
+ * Antlr will define EOF, but we can't use that as it it is too common in
+ * in C header files and that would be confusing. There is no way to filter this out at the moment
+ * so we just undef it here for now. That isn't the value we get back from C recognizers
+ * anyway. We are looking for ANTLR3_TOKEN_EOF.
+ */
+#ifdef EOF
+#undef EOF
+#endif
+#ifdef Tokens
+#undef Tokens
+#endif
+#define INTBOOL 14
+#define STRTAG 10
+#define AGO 22
+#define WHITESPACE 29
+#define GREATEREQUAL 25
+#define BEFORE 18
+#define DATETAG 16
+#define INT 15
+#define NOT 7
+#define AFTER 17
+#define AND 6
+#define EOF -1
+#define INCLUDES 11
+#define STR 4
+#define T__30 30
+#define T__31 31
+#define GREATER 24
+#define LPAR 8
+#define ENUMTAG 19
+#define IS 12
+#define ENUMVAL 20
+#define EQUAL 28
+#define OR 5
+#define LESS 26
+#define RPAR 9
+#define DATE 21
+#define LESSEQUAL 27
+#define DATINTERVAL 23
+#define INTTAG 13
+#ifdef EOF
+#undef EOF
+#define EOF ANTLR3_TOKEN_EOF
+#endif
+
+#ifndef TOKENSOURCE
+#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
+#endif
+
+/* End of token definitions for SMARTPLParser
+ * =============================================================================
+ */
+/** \} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */