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