First Commit

[librecmc/package-feed.git] / sound / forked-daapd / patches / 010-include_pregen.patch

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 */