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..3f94589
--- /dev/null
+++ b/src/pregen/DAAP2SQL.c
@@ -0,0 +1,929 @@
+/** \file
+ *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ *     -  From the grammar source file : DAAP2SQL.g
+ *     -                            On : 2014-09-30 21:42: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.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:
+        	    // DAAP2SQL.g:86: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.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:
+        	    // DAAP2SQL.g:102: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 */
+        	            				}
+
+        	            				/* Need to check against NULL too */
+        	            				if (op == ':')
+        	            					retval.result->append8(retval.result, "(");
+        	            			}
+
+        	            			retval.result->append8(retval.result, dqfm->db_col);
+
+        	            			/* 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 */
+        	            			}
+        	            			/* 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[strlen((char *)val) - 1] == '*')
+        	            				{
+        	            					op = '%';
+        	            					val[strlen((char *)val) - 1] = '%';
+        	            				}
+        	            			}
+
+        	            			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..e170f6c
--- /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 : 2014-09-30 21:42: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..12e7ef3
--- /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 : 2014-09-30 21:42:40
+ *     -                 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..ba8f58b
--- /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 : 2014-09-30 21:42:40
+ *     -                 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..6d0239d
--- /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 : 2014-09-30 21:42:39
+ *     -                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..dcc664f
--- /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 : 2014-09-30 21:42:39
+ *     -                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..b5c9550
--- /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 : 2014-09-30 21:42:42
+ *     -           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..2789fc7
--- /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 : 2014-09-30 21:42:42
+ *     -           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..ee23c08
--- /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 : 2014-09-30 21:42:41
+ *     -                 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..4f4d06b
--- /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 : 2014-09-30 21:42:41
+ *     -                 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..c538e49
--- /dev/null
+++ b/src/pregen/RSPParser.c
@@ -0,0 +1,2684 @@
+/** \file
+ *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ *     -  From the grammar source file : RSP.g
+ *     -                            On : 2014-09-30 21:42:40
+ *     -                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_set_in_strop0  */
+static	ANTLR3_BITWORD FOLLOW_set_in_strop0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_set_in_strop0	= { FOLLOW_set_in_strop0_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit211  */
+static	ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit211_bits[]	= { ANTLR3_UINT64_LIT(0x00000000001E1000) };
+static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit211	= { FOLLOW_FIELD_in_intcrit211_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit213  */
+static	ANTLR3_BITWORD FOLLOW_intop_in_intcrit213_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000010000) };
+static  ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit213	= { FOLLOW_intop_in_intcrit213_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit215  */
+static	ANTLR3_BITWORD FOLLOW_INT_in_intcrit215_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit215	= { FOLLOW_INT_in_intcrit215_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit232  */
+static	ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit232_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000800) };
+static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit232	= { FOLLOW_FIELD_in_intcrit232_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_intcrit234  */
+static	ANTLR3_BITWORD FOLLOW_NOT_in_intcrit234_bits[]	= { ANTLR3_UINT64_LIT(0x00000000001E1000) };
+static  ANTLR3_BITSET_LIST FOLLOW_NOT_in_intcrit234	= { FOLLOW_NOT_in_intcrit234_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit236  */
+static	ANTLR3_BITWORD FOLLOW_intop_in_intcrit236_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000010000) };
+static  ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit236	= { FOLLOW_intop_in_intcrit236_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit238  */
+static	ANTLR3_BITWORD FOLLOW_INT_in_intcrit238_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit238	= { FOLLOW_INT_in_intcrit238_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_intop0  */
+static	ANTLR3_BITWORD FOLLOW_set_in_intop0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_set_in_intop0	= { FOLLOW_set_in_intop0_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit292  */
+static	ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit292_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000600000) };
+static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit292	= { FOLLOW_FIELD_in_datecrit292_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit294  */
+static	ANTLR3_BITWORD FOLLOW_dateop_in_datecrit294_bits[]	= { ANTLR3_UINT64_LIT(0x0000000001810000) };
+static  ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit294	= { FOLLOW_dateop_in_datecrit294_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit296  */
+static	ANTLR3_BITWORD FOLLOW_datespec_in_datecrit296_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit296	= { FOLLOW_datespec_in_datecrit296_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateop0  */
+static	ANTLR3_BITWORD FOLLOW_set_in_dateop0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_set_in_dateop0	= { FOLLOW_set_in_dateop0_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec331  */
+static	ANTLR3_BITWORD FOLLOW_dateref_in_datespec331_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec331	= { FOLLOW_dateref_in_datespec331_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec336  */
+static	ANTLR3_BITWORD FOLLOW_INT_in_datespec336_bits[]	= { ANTLR3_UINT64_LIT(0x000000001E000000) };
+static  ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec336	= { FOLLOW_INT_in_datespec336_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec338  */
+static	ANTLR3_BITWORD FOLLOW_dateintval_in_datespec338_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000600000) };
+static  ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec338	= { FOLLOW_dateintval_in_datespec338_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec340  */
+static	ANTLR3_BITWORD FOLLOW_dateop_in_datespec340_bits[]	= { ANTLR3_UINT64_LIT(0x0000000001800000) };
+static  ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec340	= { FOLLOW_dateop_in_datespec340_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec342  */
+static	ANTLR3_BITWORD FOLLOW_dateref_in_datespec342_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec342	= { FOLLOW_dateref_in_datespec342_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateref0  */
+static	ANTLR3_BITWORD FOLLOW_set_in_dateref0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_set_in_dateref0	= { FOLLOW_set_in_dateref0_bits, 1	};
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateintval0  */
+static	ANTLR3_BITWORD FOLLOW_set_in_dateintval0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
+static  ANTLR3_BITSET_LIST FOLLOW_set_in_dateintval0	= { FOLLOW_set_in_dateintval0_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 INCLUDES:
+            				case STARTSW:
+            				case ENDSW:
+            					{
+            						alt4=2;
+            					}
+            				    break;
+            				case LESS:
+            				case GREATER:
+            				case LTE:
+            				case GTE:
+            					{
+            						alt4=3;
+            					}
+            				    break;
+
+            				default:
+            				    CONSTRUCTEX();
+            				    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+            				    EXCEPTION->message      = (void *)"";
+            				    EXCEPTION->decisionNum  = 4;
+            				    EXCEPTION->state        = 3;
+
+
+            				    goto rulecritEx;
+            				}
+
+            			}
+            		    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        = 4;
+
+
+            				    goto rulecritEx;
+            				}
+
+            			}
+            		    break;
+            		case BEFORE:
+            		case AFTER:
+            			{
+            				alt4=4;
+            			}
+            		    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          : strop, STR, 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;
+        	        	// 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          : NOT, FIELD, strop, STR
+        	         * 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 | INCLUDES | STARTSW | ENDSW );
+ */
+static RSPParser_strop_return
+strop(pRSPParser ctx)
+{   
+    RSPParser_strop_return retval;
+
+    pANTLR3_BASE_TREE root_0;
+
+    pANTLR3_COMMON_TOKEN    set23;
+
+    pANTLR3_BASE_TREE set23_tree;
+
+    /* Initialize rule variables
+     */
+
+
+    root_0 = NULL;
+
+    set23       = NULL;
+    retval.start = LT(1); retval.stop = retval.start;
+
+    set23_tree   = NULL;
+
+
+    retval.tree  = NULL;
+    {
+        // RSP.g:46:7: ( EQUAL | INCLUDES | STARTSW | ENDSW )
+        // RSP.g:
+        {
+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+            set23=(pANTLR3_COMMON_TOKEN)LT(1);
+            if ( ((LA(1) >= EQUAL) && (LA(1) <= ENDSW)) )
+            {
+                CONSUME();
+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set23)));
+                PERRORRECOVERY=ANTLR3_FALSE;
+            }
+            else 
+            {
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
+                EXCEPTION->expectingSet = &FOLLOW_set_in_strop0;
+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_strop0);    goto rulestropEx;
+            }
+
+
+        }
+
+    }
+    
+
+    // 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    FIELD24;
+    pANTLR3_COMMON_TOKEN    INT26;
+    pANTLR3_COMMON_TOKEN    FIELD27;
+    pANTLR3_COMMON_TOKEN    NOT28;
+    pANTLR3_COMMON_TOKEN    INT30;
+    RSPParser_intop_return intop25;
+    #undef	RETURN_TYPE_intop25
+    #define	RETURN_TYPE_intop25 RSPParser_intop_return
+
+    RSPParser_intop_return intop29;
+    #undef	RETURN_TYPE_intop29
+    #define	RETURN_TYPE_intop29 RSPParser_intop_return
+
+    pANTLR3_BASE_TREE FIELD24_tree;
+    pANTLR3_BASE_TREE INT26_tree;
+    pANTLR3_BASE_TREE FIELD27_tree;
+    pANTLR3_BASE_TREE NOT28_tree;
+    pANTLR3_BASE_TREE INT30_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;
+
+    FIELD24       = NULL;
+    INT26       = NULL;
+    FIELD27       = NULL;
+    NOT28       = NULL;
+    INT30       = NULL;
+    intop25.tree = NULL;
+
+    intop29.tree = NULL;
+
+    retval.start = LT(1); retval.stop = retval.start;
+
+    FIELD24_tree   = NULL;
+    INT26_tree   = NULL;
+    FIELD27_tree   = NULL;
+    NOT28_tree   = NULL;
+    INT30_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 alt6;
+
+            alt6=2;
+
+            switch ( LA(1) ) 
+            {
+            case FIELD:
+            	{
+            		switch ( LA(2) ) 
+            		{
+            		case NOT:
+            			{
+            				alt6=2;
+            			}
+            		    break;
+            		case EQUAL:
+            		case LESS:
+            		case GREATER:
+            		case LTE:
+            		case GTE:
+            			{
+            				alt6=1;
+            			}
+            		    break;
+
+            		default:
+            		    CONSTRUCTEX();
+            		    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+            		    EXCEPTION->message      = (void *)"";
+            		    EXCEPTION->decisionNum  = 6;
+            		    EXCEPTION->state        = 1;
+
+
+            		    goto ruleintcritEx;
+            		}
+
+            	}
+                break;
+
+            default:
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+                EXCEPTION->message      = (void *)"";
+                EXCEPTION->decisionNum  = 6;
+                EXCEPTION->state        = 0;
+
+
+                goto ruleintcritEx;
+            }
+
+            switch (alt6) 
+            {
+        	case 1:
+        	    // RSP.g:52:11: FIELD intop INT
+        	    {
+        	        FIELD24 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit211); 
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+        	         
+        	        CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD24, NULL);
+
+        	        FOLLOWPUSH(FOLLOW_intop_in_intcrit213);
+        	        intop25=intop(ctx);
+
+        	        FOLLOWPOP();
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+
+        	        CREATE_stream_intop; stream_intop->add(stream_intop, intop25.tree, NULL);
+        	        INT26 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit215); 
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+        	         
+        	        CREATE_stream_INT; stream_INT->add(stream_INT, INT26, NULL);
+
+
+        	         
+        	        /* AST REWRITE
+        	         * elements          : FIELD, intop, INT
+        	         * 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
+        	    {
+        	        FIELD27 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit232); 
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+        	         
+        	        CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD27, NULL);
+
+        	        NOT28 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_intcrit234); 
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+        	         
+        	        CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT28, NULL);
+
+        	        FOLLOWPUSH(FOLLOW_intop_in_intcrit236);
+        	        intop29=intop(ctx);
+
+        	        FOLLOWPOP();
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+
+        	        CREATE_stream_intop; stream_intop->add(stream_intop, intop29.tree, NULL);
+        	        INT30 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit238); 
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruleintcritEx;
+        	        }
+        	         
+        	        CREATE_stream_INT; stream_INT->add(stream_INT, INT30, NULL);
+
+
+        	         
+        	        /* AST REWRITE
+        	         * elements          : NOT, INT, FIELD, 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;
+        	        	// 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 | LESS | GREATER | LTE | GTE );
+ */
+static RSPParser_intop_return
+intop(pRSPParser ctx)
+{   
+    RSPParser_intop_return retval;
+
+    pANTLR3_BASE_TREE root_0;
+
+    pANTLR3_COMMON_TOKEN    set31;
+
+    pANTLR3_BASE_TREE set31_tree;
+
+    /* Initialize rule variables
+     */
+
+
+    root_0 = NULL;
+
+    set31       = NULL;
+    retval.start = LT(1); retval.stop = retval.start;
+
+    set31_tree   = NULL;
+
+
+    retval.tree  = NULL;
+    {
+        // RSP.g:56:7: ( EQUAL | LESS | GREATER | LTE | GTE )
+        // RSP.g:
+        {
+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+            set31=(pANTLR3_COMMON_TOKEN)LT(1);
+            if ( LA(1) == EQUAL || ((LA(1) >= LESS) && (LA(1) <= GTE)) )
+            {
+                CONSUME();
+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set31)));
+                PERRORRECOVERY=ANTLR3_FALSE;
+            }
+            else 
+            {
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
+                EXCEPTION->expectingSet = &FOLLOW_set_in_intop0;
+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_intop0);    goto ruleintopEx;
+            }
+
+
+        }
+
+    }
+    
+
+    // 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    FIELD32;
+    RSPParser_dateop_return dateop33;
+    #undef	RETURN_TYPE_dateop33
+    #define	RETURN_TYPE_dateop33 RSPParser_dateop_return
+
+    RSPParser_datespec_return datespec34;
+    #undef	RETURN_TYPE_datespec34
+    #define	RETURN_TYPE_datespec34 RSPParser_datespec_return
+
+    pANTLR3_BASE_TREE FIELD32_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;
+
+    FIELD32       = NULL;
+    dateop33.tree = NULL;
+
+    datespec34.tree = NULL;
+
+    retval.start = LT(1); retval.stop = retval.start;
+
+    FIELD32_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
+        {
+            FIELD32 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit292); 
+            if  (HASEXCEPTION())
+            {
+                goto ruledatecritEx;
+            }
+             
+            CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD32, NULL);
+
+            FOLLOWPUSH(FOLLOW_dateop_in_datecrit294);
+            dateop33=dateop(ctx);
+
+            FOLLOWPOP();
+            if  (HASEXCEPTION())
+            {
+                goto ruledatecritEx;
+            }
+
+            CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop33.tree, NULL);
+            FOLLOWPUSH(FOLLOW_datespec_in_datecrit296);
+            datespec34=datespec(ctx);
+
+            FOLLOWPOP();
+            if  (HASEXCEPTION())
+            {
+                goto ruledatecritEx;
+            }
+
+            CREATE_stream_datespec; stream_datespec->add(stream_datespec, datespec34.tree, NULL);
+
+             
+            /* AST REWRITE
+             * elements          : FIELD, datespec, dateop
+             * 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 | AFTER );
+ */
+static RSPParser_dateop_return
+dateop(pRSPParser ctx)
+{   
+    RSPParser_dateop_return retval;
+
+    pANTLR3_BASE_TREE root_0;
+
+    pANTLR3_COMMON_TOKEN    set35;
+
+    pANTLR3_BASE_TREE set35_tree;
+
+    /* Initialize rule variables
+     */
+
+
+    root_0 = NULL;
+
+    set35       = NULL;
+    retval.start = LT(1); retval.stop = retval.start;
+
+    set35_tree   = NULL;
+
+
+    retval.tree  = NULL;
+    {
+        // RSP.g:66:8: ( BEFORE | AFTER )
+        // RSP.g:
+        {
+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+            set35=(pANTLR3_COMMON_TOKEN)LT(1);
+            if ( ((LA(1) >= BEFORE) && (LA(1) <= AFTER)) )
+            {
+                CONSUME();
+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set35)));
+                PERRORRECOVERY=ANTLR3_FALSE;
+            }
+            else 
+            {
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
+                EXCEPTION->expectingSet = &FOLLOW_set_in_dateop0;
+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateop0);    goto ruledateopEx;
+            }
+
+
+        }
+
+    }
+    
+
+    // 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    INT37;
+    RSPParser_dateref_return dateref36;
+    #undef	RETURN_TYPE_dateref36
+    #define	RETURN_TYPE_dateref36 RSPParser_dateref_return
+
+    RSPParser_dateintval_return dateintval38;
+    #undef	RETURN_TYPE_dateintval38
+    #define	RETURN_TYPE_dateintval38 RSPParser_dateintval_return
+
+    RSPParser_dateop_return dateop39;
+    #undef	RETURN_TYPE_dateop39
+    #define	RETURN_TYPE_dateop39 RSPParser_dateop_return
+
+    RSPParser_dateref_return dateref40;
+    #undef	RETURN_TYPE_dateref40
+    #define	RETURN_TYPE_dateref40 RSPParser_dateref_return
+
+    pANTLR3_BASE_TREE INT37_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;
+
+    INT37       = NULL;
+    dateref36.tree = NULL;
+
+    dateintval38.tree = NULL;
+
+    dateop39.tree = NULL;
+
+    dateref40.tree = NULL;
+
+    retval.start = LT(1); retval.stop = retval.start;
+
+    INT37_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 alt7;
+
+            alt7=2;
+
+            switch ( LA(1) ) 
+            {
+            case DATE:
+            case TODAY:
+            	{
+            		alt7=1;
+            	}
+                break;
+            case INT:
+            	{
+            		alt7=2;
+            	}
+                break;
+
+            default:
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
+                EXCEPTION->message      = (void *)"";
+                EXCEPTION->decisionNum  = 7;
+                EXCEPTION->state        = 0;
+
+
+                goto ruledatespecEx;
+            }
+
+            switch (alt7) 
+            {
+        	case 1:
+        	    // RSP.g:70:11: dateref
+        	    {
+        	        root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+        	        FOLLOWPUSH(FOLLOW_dateref_in_datespec331);
+        	        dateref36=dateref(ctx);
+
+        	        FOLLOWPOP();
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruledatespecEx;
+        	        }
+
+        	        ADAPTOR->addChild(ADAPTOR, root_0, dateref36.tree);
+
+        	    }
+        	    break;
+        	case 2:
+        	    // RSP.g:71:4: INT dateintval dateop dateref
+        	    {
+        	        INT37 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_datespec336); 
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruledatespecEx;
+        	        }
+        	         
+        	        CREATE_stream_INT; stream_INT->add(stream_INT, INT37, NULL);
+
+        	        FOLLOWPUSH(FOLLOW_dateintval_in_datespec338);
+        	        dateintval38=dateintval(ctx);
+
+        	        FOLLOWPOP();
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruledatespecEx;
+        	        }
+
+        	        CREATE_stream_dateintval; stream_dateintval->add(stream_dateintval, dateintval38.tree, NULL);
+        	        FOLLOWPUSH(FOLLOW_dateop_in_datespec340);
+        	        dateop39=dateop(ctx);
+
+        	        FOLLOWPOP();
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruledatespecEx;
+        	        }
+
+        	        CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop39.tree, NULL);
+        	        FOLLOWPUSH(FOLLOW_dateref_in_datespec342);
+        	        dateref40=dateref(ctx);
+
+        	        FOLLOWPOP();
+        	        if  (HASEXCEPTION())
+        	        {
+        	            goto ruledatespecEx;
+        	        }
+
+        	        CREATE_stream_dateref; stream_dateref->add(stream_dateref, dateref40.tree, NULL);
+
+        	         
+        	        /* AST REWRITE
+        	         * elements          : dateintval, INT, dateref, dateop
+        	         * 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 | TODAY );
+ */
+static RSPParser_dateref_return
+dateref(pRSPParser ctx)
+{   
+    RSPParser_dateref_return retval;
+
+    pANTLR3_BASE_TREE root_0;
+
+    pANTLR3_COMMON_TOKEN    set41;
+
+    pANTLR3_BASE_TREE set41_tree;
+
+    /* Initialize rule variables
+     */
+
+
+    root_0 = NULL;
+
+    set41       = NULL;
+    retval.start = LT(1); retval.stop = retval.start;
+
+    set41_tree   = NULL;
+
+
+    retval.tree  = NULL;
+    {
+        // RSP.g:74:9: ( DATE | TODAY )
+        // RSP.g:
+        {
+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+            set41=(pANTLR3_COMMON_TOKEN)LT(1);
+            if ( ((LA(1) >= DATE) && (LA(1) <= TODAY)) )
+            {
+                CONSUME();
+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set41)));
+                PERRORRECOVERY=ANTLR3_FALSE;
+            }
+            else 
+            {
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
+                EXCEPTION->expectingSet = &FOLLOW_set_in_dateref0;
+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateref0);    goto ruledaterefEx;
+            }
+
+
+        }
+
+    }
+    
+
+    // 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 | WEEK | MONTH | YEAR );
+ */
+static RSPParser_dateintval_return
+dateintval(pRSPParser ctx)
+{   
+    RSPParser_dateintval_return retval;
+
+    pANTLR3_BASE_TREE root_0;
+
+    pANTLR3_COMMON_TOKEN    set42;
+
+    pANTLR3_BASE_TREE set42_tree;
+
+    /* Initialize rule variables
+     */
+
+
+    root_0 = NULL;
+
+    set42       = NULL;
+    retval.start = LT(1); retval.stop = retval.start;
+
+    set42_tree   = NULL;
+
+
+    retval.tree  = NULL;
+    {
+        // RSP.g:79:2: ( DAY | WEEK | MONTH | YEAR )
+        // RSP.g:
+        {
+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
+
+            set42=(pANTLR3_COMMON_TOKEN)LT(1);
+            if ( ((LA(1) >= DAY) && (LA(1) <= YEAR)) )
+            {
+                CONSUME();
+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set42)));
+                PERRORRECOVERY=ANTLR3_FALSE;
+            }
+            else 
+            {
+                CONSTRUCTEX();
+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
+                EXCEPTION->expectingSet = &FOLLOW_set_in_dateintval0;
+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateintval0);    goto ruledateintvalEx;
+            }
+
+
+        }
+
+    }
+    
+
+    // 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..d0744a2
--- /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 : 2014-09-30 21:42:40
+ *     -                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 */