\ 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
+index 0000000..f13209c
--- /dev/null
+++ b/src/pregen/DAAP2SQL.c
-@@ -0,0 +1,929 @@
+@@ -0,0 +1,975 @@
+/** \file
+ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
+ *
+ * - From the grammar source file : DAAP2SQL.g
-+ * - On : 2014-09-30 21:42:43
++ * - On : 2015-06-27 19:05:20
+ * - for the tree parser : DAAP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+
+ {
+
-+ if (!a.valid || !b.valid)
-+ {
-+ retval.valid= 0;
-+ }
-+ else
++ if (a.valid && b.valid)
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->append8(retval.result, "(");
+ retval.result->appendS(retval.result, b.result);
+ retval.result->append8(retval.result, ")");
+ }
++ else if (a.valid)
++ {
++ retval.result= a.result->factory->newRaw(a.result->factory);
++ retval.result->appendS(retval.result, a.result);
++ }
++ else if (b.valid)
++ {
++ retval.result= b.result->factory->newRaw(b.result->factory);
++ retval.result->appendS(retval.result, b.result);
++ }
++ else
++ {
++ retval.valid= 0;
++ }
+
+ }
+
+ }
+ break;
+ case 2:
-+ // DAAP2SQL.g:86:4: ^( OPOR a= expr b= expr )
++ // DAAP2SQL.g:96:4: ^( OPOR a= expr b= expr )
+ {
+ MATCHT(OPOR, &FOLLOW_OPOR_in_expr118);
+ if (HASEXCEPTION())
+
+ {
+
-+ if (!a.valid || !b.valid)
-+ {
-+ retval.valid= 0;
-+ }
-+ else
++ if (a.valid && b.valid)
+ {
+ retval.result= a.result->factory->newRaw(a.result->factory);
+ retval.result->append8(retval.result, "(");
+ retval.result->appendS(retval.result, b.result);
+ retval.result->append8(retval.result, ")");
+ }
++ else if (a.valid)
++ {
++ retval.result= a.result->factory->newRaw(a.result->factory);
++ retval.result->appendS(retval.result, a.result);
++ }
++ else if (b.valid)
++ {
++ retval.result= b.result->factory->newRaw(b.result->factory);
++ retval.result->appendS(retval.result, b.result);
++ }
++ else
++ {
++ retval.valid= 0;
++ }
+
+ }
+
+ }
+ break;
+ case 3:
-+ // DAAP2SQL.g:102:4: STR
++ // DAAP2SQL.g:122:4: STR
+ {
+ STR1 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expr140);
+ if (HASEXCEPTION())
+ goto STR_result_valid_0; /* ABORT */
+ }
+
++ /* No need to exclude empty artist and album, as forked-daapd makes sure there always exists an artist/album. */
++ if (neg_op && op == ':'
++ && (strcmp((char *)field, "daap.songalbumartist") == 0
++ || strcmp((char *)field, "daap.songartist") == 0
++ || strcmp((char *)field, "daap.songalbum") == 0))
++ {
++ DPRINTF(E_DBG, L_DAAP, "Ignoring clause '%s%s%c'\n", field, (neg_op) ? "!" : "", op);
++ retval.valid= 0;
++ goto STR_result_valid_0;
++ }
++
+ /* Need to check against NULL too */
+ if (op == ':')
+ retval.result->append8(retval.result, "(");
+ }
+
-+ retval.result->append8(retval.result, dqfm->db_col);
-+
+ /* Int field: check integer conversion */
+ if (dqfm->as_int)
+ {
+ }
+
+ *end = '\0'; /* Cut out potential garbage - we're being kind */
++
++ /* forked-daapd only has media_kind = 1 for music - so remove media_kind = 32 to imporve select query performance. */
++ if (llval == 32
++ && (strcmp((char *)field, "com.apple.itunes.mediakind") == 0
++ || strcmp((char *)field, "com.apple.itunes.extended-media-kind") == 0))
++ {
++ DPRINTF(E_DBG, L_DAAP, "Ignoring clause '%s%s%c%s'\n", field, (neg_op) ? "!" : "", op, val);
++
++ if (neg_op)
++ retval.result->append8(retval.result, "1 = 1");
++ else
++ retval.result->append8(retval.result, "1 = 0");
++
++ goto STR_out;
++ }
+ }
+ /* String field: escape string, check for '*' */
+ else
+ val[0] = '%';
+ }
+
-+ if (val[strlen((char *)val) - 1] == '*')
++ if (val[0] && val[1] && val[strlen((char *)val) - 1] == '*')
+ {
+ op = '%';
+ val[strlen((char *)val) - 1] = '%';
+ }
+ }
++
++ retval.result->append8(retval.result, dqfm->db_col);
+
+ switch(op)
+ {
+ */
diff --git a/src/pregen/DAAP2SQL.h b/src/pregen/DAAP2SQL.h
new file mode 100644
-index 0000000..e170f6c
+index 0000000..2b1e806
--- /dev/null
+++ b/src/pregen/DAAP2SQL.h
@@ -0,0 +1,195 @@
+ * 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
++ * - On : 2015-06-27 19:05:20
+ * - for the tree parser : DAAP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
\ 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
+index 0000000..b72f28a
--- /dev/null
+++ b/src/pregen/DAAPLexer.c
@@ -0,0 +1,1101 @@
+ * 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
++ * - On : 2015-06-27 19:05:17
+ * - for the lexer : DAAPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ */
diff --git a/src/pregen/DAAPLexer.h b/src/pregen/DAAPLexer.h
new file mode 100644
-index 0000000..ba8f58b
+index 0000000..401b214
--- /dev/null
+++ b/src/pregen/DAAPLexer.h
@@ -0,0 +1,188 @@
+ * 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
++ * - On : 2015-06-27 19:05:17
+ * - for the lexer : DAAPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+/* 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
+index 0000000..7a9aae9
--- /dev/null
+++ b/src/pregen/DAAPParser.c
@@ -0,0 +1,1014 @@
+ * 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
++ * - On : 2015-06-27 19:05:16
+ * - for the parser : DAAPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+ */
diff --git a/src/pregen/DAAPParser.h b/src/pregen/DAAPParser.h
new file mode 100644
-index 0000000..dcc664f
+index 0000000..82ce85e
--- /dev/null
+++ b/src/pregen/DAAPParser.h
@@ -0,0 +1,226 @@
+ * 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
++ * - On : 2015-06-27 19:05:16
+ * - for the parser : DAAPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
\ 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
+index 0000000..05b54d3
--- /dev/null
+++ b/src/pregen/RSP2SQL.c
@@ -0,0 +1,2546 @@
+ * 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
++ * - On : 2015-06-27 19:05:19
+ * - for the tree parser : RSP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
+ */
diff --git a/src/pregen/RSP2SQL.h b/src/pregen/RSP2SQL.h
new file mode 100644
-index 0000000..2789fc7
+index 0000000..a94e317
--- /dev/null
+++ b/src/pregen/RSP2SQL.h
@@ -0,0 +1,291 @@
+ * 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
++ * - On : 2015-06-27 19:05:19
+ * - for the tree parser : RSP2SQLTreeParser *
+ * Editing it, at least manually, is not wise.
+ *
\ 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
+index 0000000..bc4245a
--- /dev/null
+++ b/src/pregen/RSPLexer.c
@@ -0,0 +1,4867 @@
+ * 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
++ * - On : 2015-06-27 19:05:18
+ * - for the lexer : RSPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+ */
diff --git a/src/pregen/RSPLexer.h b/src/pregen/RSPLexer.h
new file mode 100644
-index 0000000..4f4d06b
+index 0000000..d93f93e
--- /dev/null
+++ b/src/pregen/RSPLexer.h
@@ -0,0 +1,254 @@
+ * 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
++ * - On : 2015-06-27 19:05:18
+ * - for the lexer : RSPLexerLexer *
+ * Editing it, at least manually, is not wise.
+ *
+/* 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
+index 0000000..c0f3e2a
--- /dev/null
+++ b/src/pregen/RSPParser.c
@@ -0,0 +1,2684 @@
+ * 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
++ * - On : 2015-06-27 19:05:18
+ * - for the parser : RSPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+
+
+ /* AST REWRITE
-+ * elements : NOT, FIELD, strop, STR
++ * elements : NOT, strop, STR, FIELD
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+
+
+ /* AST REWRITE
-+ * elements : FIELD, intop, INT
++ * elements : intop, INT, FIELD
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+
+
+ /* AST REWRITE
-+ * elements : NOT, INT, FIELD, intop
++ * elements : INT, FIELD, intop, NOT
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+
+
+ /* AST REWRITE
-+ * elements : FIELD, datespec, dateop
++ * elements : datespec, FIELD, dateop
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+
+
+ /* AST REWRITE
-+ * elements : dateintval, INT, dateref, dateop
++ * elements : INT, dateintval, dateop, dateref
+ * token labels :
+ * rule labels : retval
+ * token list labels :
+ */
diff --git a/src/pregen/RSPParser.h b/src/pregen/RSPParser.h
new file mode 100644
-index 0000000..d0744a2
+index 0000000..4b3bbfe
--- /dev/null
+++ b/src/pregen/RSPParser.h
@@ -0,0 +1,365 @@
+ * 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
++ * - On : 2015-06-27 19:05:18
+ * - for the parser : RSPParserParser *
+ * Editing it, at least manually, is not wise.
+ *
+#endif
+
+/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/SMARTPL.u b/src/pregen/SMARTPL.u
+new file mode 100644
+index 0000000..2a66bf3
+--- /dev/null
++++ b/src/pregen/SMARTPL.u
+@@ -0,0 +1,6 @@
++SMARTPLParser.c : SMARTPL.g
++./SMARTPL.tokens : SMARTPL.g
++SMARTPLParser.h : SMARTPL.g
++SMARTPLLexer.c : SMARTPL.g
++SMARTPLLexer.h : SMARTPL.g
++ANTLR_PRODUCTS += SMARTPLParser.c ./SMARTPL.tokens SMARTPLParser.h SMARTPLLexer.c SMARTPLLexer.h
+\ No newline at end of file
+diff --git a/src/pregen/SMARTPL2SQL.c b/src/pregen/SMARTPL2SQL.c
+new file mode 100644
+index 0000000..c435f37
+--- /dev/null
++++ b/src/pregen/SMARTPL2SQL.c
+@@ -0,0 +1,1649 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : SMARTPL2SQL.g
++ * - On : 2015-06-27 19:05:21
++ * - for the tree parser : SMARTPL2SQLTreeParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++
++/* =============================================================================
++ * This is what the grammar programmer asked us to put at the top of every file.
++ */
++
++ #include <stdio.h>
++ #include <stdlib.h>
++ #include <string.h>
++ #include <limits.h>
++ #include <errno.h>
++ #include <time.h>
++ #include <sqlite3.h>
++
++ #include "logger.h"
++ #include "db.h"
++
++/* End of Header action.
++ * =============================================================================
++ */
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "SMARTPL2SQL.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pSMARTPL2SQL_##scope##_SCOPE
++#define SCOPE_STACK(scope) pSMARTPL2SQL_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pSMARTPL2SQL_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pSMARTPL2SQL_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++/* Macros for accessing things in the parser
++ */
++
++#undef PARSER
++#undef RECOGNIZER
++#undef HAVEPARSEDRULE
++#undef INPUT
++#undef STRSTREAM
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef MATCHT
++#undef MATCHANYT
++#undef FOLLOWSTACK
++#undef FOLLOWPUSH
++#undef FOLLOWPOP
++#undef PRECOVER
++#undef PREPORTERROR
++#undef LA
++#undef LT
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef PERRORRECOVERY
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef RECOVERFROMMISMATCHEDSET
++#undef RECOVERFROMMISMATCHEDELEMENT
++#undef BACKTRACKING
++#undef ADAPTOR
++#undef RULEMEMO
++#undef SEEK
++#undef INDEX
++#undef DBG
++
++#define PARSER ctx->pTreeParser
++#define RECOGNIZER PARSER->rec
++#define PSRSTATE RECOGNIZER->state
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define INPUT PARSER->ctnstream
++#define ISTREAM INPUT->tnstream->istream
++#define STRSTREAM INPUT->tnstream
++#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION PSRSTATE->exception
++#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
++#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
++#define FOLLOWSTACK PSRSTATE->following
++#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
++#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
++#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
++#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
++#define LA(n) ISTREAM->_LA(ISTREAM, n)
++#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define CONSUME() ISTREAM->consume(ISTREAM)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define PERRORRECOVERY PSRSTATE->errorRecovery
++#define FAILEDFLAG PSRSTATE->failed
++#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
++#define BACKTRACKING PSRSTATE->backtracking
++#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
++#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
++#define ADAPTOR INPUT->adaptor
++#define RULEMEMO PSRSTATE->ruleMemo
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define INDEX() ISTREAM->index(ISTREAM)
++#define DBG RECOGNIZER->debugger
++
++
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++
++/** \brief Table of all token names in symbolic order, mainly used for
++ * error reporting.
++ */
++pANTLR3_UINT8 SMARTPL2SQLTokenNames[28+4]
++ = {
++ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
++ (pANTLR3_UINT8) "<EOR>",
++ (pANTLR3_UINT8) "<DOWN>",
++ (pANTLR3_UINT8) "<UP>",
++ (pANTLR3_UINT8) "STR",
++ (pANTLR3_UINT8) "OR",
++ (pANTLR3_UINT8) "AND",
++ (pANTLR3_UINT8) "NOT",
++ (pANTLR3_UINT8) "LPAR",
++ (pANTLR3_UINT8) "RPAR",
++ (pANTLR3_UINT8) "STRTAG",
++ (pANTLR3_UINT8) "INCLUDES",
++ (pANTLR3_UINT8) "IS",
++ (pANTLR3_UINT8) "INTTAG",
++ (pANTLR3_UINT8) "INTBOOL",
++ (pANTLR3_UINT8) "INT",
++ (pANTLR3_UINT8) "DATETAG",
++ (pANTLR3_UINT8) "AFTER",
++ (pANTLR3_UINT8) "BEFORE",
++ (pANTLR3_UINT8) "ENUMTAG",
++ (pANTLR3_UINT8) "ENUMVAL",
++ (pANTLR3_UINT8) "DATE",
++ (pANTLR3_UINT8) "AGO",
++ (pANTLR3_UINT8) "DATINTERVAL",
++ (pANTLR3_UINT8) "GREATER",
++ (pANTLR3_UINT8) "GREATEREQUAL",
++ (pANTLR3_UINT8) "LESS",
++ (pANTLR3_UINT8) "LESSEQUAL",
++ (pANTLR3_UINT8) "EQUAL",
++ (pANTLR3_UINT8) "WHITESPACE",
++ (pANTLR3_UINT8) "'{'",
++ (pANTLR3_UINT8) "'}'"
++ };
++
++
++
++// Forward declare the locally static matching functions we have generated.
++//
++static SMARTPL2SQL_playlist_return playlist (pSMARTPL2SQL ctx);
++static pANTLR3_STRING expression (pSMARTPL2SQL ctx);
++static int dateval (pSMARTPL2SQL ctx);
++static int interval (pSMARTPL2SQL ctx);
++static void SMARTPL2SQLFree(pSMARTPL2SQL ctx);
++/* For use in tree output where we are accumulating rule labels via label += ruleRef
++ * we need a function that knows how to free a return scope when the list is destroyed.
++ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
++ */
++static void ANTLR3_CDECL freeScope(void * scope)
++{
++ ANTLR3_FREE(scope);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "SMARTPL2SQL.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++/** \brief Create a new SMARTPL2SQL parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pSMARTPL2SQL
++SMARTPL2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
++{
++ // See if we can create a new parser with the standard constructor
++ //
++ return SMARTPL2SQLNewSSD(instream, NULL);
++}
++
++/** \brief Create a new SMARTPL2SQL parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pSMARTPL2SQL
++SMARTPL2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pSMARTPL2SQL ctx; /* Context structure we will build and return */
++
++ ctx = (pSMARTPL2SQL) ANTLR3_CALLOC(1, sizeof(SMARTPL2SQL));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for parser context
++ //
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * the base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 parser function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in SMARTPL2SQL.h here, in order that you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base Tree parser/recognizer, using the supplied tree node stream
++ */
++ ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
++ /* Install the implementation of our SMARTPL2SQL interface
++ */
++ ctx->playlist = playlist;
++ ctx->expression = expression;
++ ctx->dateval = dateval;
++ ctx->interval = interval;
++ ctx->free = SMARTPL2SQLFree;
++ ctx->getGrammarFileName = getGrammarFileName;
++
++ /* Install the scope pushing methods.
++ */
++
++
++
++
++
++ /* Install the token table
++ */
++ PSRSTATE->tokenNames = SMARTPL2SQLTokenNames;
++
++
++ /* Return the newly built parser to the caller
++ */
++ return ctx;
++}
++
++/** Free the parser resources
++ */
++ static void
++ SMARTPL2SQLFree(pSMARTPL2SQL ctx)
++ {
++ /* Free any scope memory
++ */
++
++
++ // Free this parser
++ //
++ ctx->pTreeParser->free(ctx->pTreeParser);
++ ANTLR3_FREE(ctx);
++
++ /* Everything is released, so we can return
++ */
++ return;
++ }
++
++/** Return token names used by this tree parser
++ *
++ * The returned pointer is used as an index into the token names table (using the token
++ * number as the index).
++ *
++ * \return Pointer to first char * in the table.
++ */
++static pANTLR3_UINT8 *getTokenNames()
++{
++ return SMARTPL2SQLTokenNames;
++}
++
++
++
++
++/* Declare the bitsets
++ */
++
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_playlist66 */
++static ANTLR3_BITWORD FOLLOW_STR_in_playlist66_bits[] = { ANTLR3_UINT64_LIT(0x0000000040000000) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_playlist66 = { FOLLOW_STR_in_playlist66_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_30_in_playlist68 */
++static ANTLR3_BITWORD FOLLOW_30_in_playlist68_bits[] = { ANTLR3_UINT64_LIT(0x00000000000924E0) };
++static ANTLR3_BITSET_LIST FOLLOW_30_in_playlist68 = { FOLLOW_30_in_playlist68_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_playlist74 */
++static ANTLR3_BITWORD FOLLOW_expression_in_playlist74_bits[] = { ANTLR3_UINT64_LIT(0x0000000080000000) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_playlist74 = { FOLLOW_expression_in_playlist74_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_31_in_playlist76 */
++static ANTLR3_BITWORD FOLLOW_31_in_playlist76_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_31_in_playlist76 = { FOLLOW_31_in_playlist76_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_expression101 */
++static ANTLR3_BITWORD FOLLOW_NOT_in_expression101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_NOT_in_expression101 = { FOLLOW_NOT_in_expression101_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression107 */
++static ANTLR3_BITWORD FOLLOW_expression_in_expression107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression107 = { FOLLOW_expression_in_expression107_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_expression118 */
++static ANTLR3_BITWORD FOLLOW_AND_in_expression118_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_AND_in_expression118 = { FOLLOW_AND_in_expression118_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression124 */
++static ANTLR3_BITWORD FOLLOW_expression_in_expression124_bits[] = { ANTLR3_UINT64_LIT(0x00000000000924E0) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression124 = { FOLLOW_expression_in_expression124_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression130 */
++static ANTLR3_BITWORD FOLLOW_expression_in_expression130_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression130 = { FOLLOW_expression_in_expression130_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expression141 */
++static ANTLR3_BITWORD FOLLOW_OR_in_expression141_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_OR_in_expression141 = { FOLLOW_OR_in_expression141_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression147 */
++static ANTLR3_BITWORD FOLLOW_expression_in_expression147_bits[] = { ANTLR3_UINT64_LIT(0x00000000000924E0) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression147 = { FOLLOW_expression_in_expression147_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_expression153 */
++static ANTLR3_BITWORD FOLLOW_expression_in_expression153_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_expression153 = { FOLLOW_expression_in_expression153_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRTAG_in_expression163 */
++static ANTLR3_BITWORD FOLLOW_STRTAG_in_expression163_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) };
++static ANTLR3_BITSET_LIST FOLLOW_STRTAG_in_expression163 = { FOLLOW_STRTAG_in_expression163_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INCLUDES_in_expression165 */
++static ANTLR3_BITWORD FOLLOW_INCLUDES_in_expression165_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
++static ANTLR3_BITSET_LIST FOLLOW_INCLUDES_in_expression165 = { FOLLOW_INCLUDES_in_expression165_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_expression167 */
++static ANTLR3_BITWORD FOLLOW_STR_in_expression167_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_expression167 = { FOLLOW_STR_in_expression167_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRTAG_in_expression176 */
++static ANTLR3_BITWORD FOLLOW_STRTAG_in_expression176_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001000) };
++static ANTLR3_BITSET_LIST FOLLOW_STRTAG_in_expression176 = { FOLLOW_STRTAG_in_expression176_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_IS_in_expression178 */
++static ANTLR3_BITWORD FOLLOW_IS_in_expression178_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
++static ANTLR3_BITSET_LIST FOLLOW_IS_in_expression178 = { FOLLOW_IS_in_expression178_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_expression180 */
++static ANTLR3_BITWORD FOLLOW_STR_in_expression180_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_expression180 = { FOLLOW_STR_in_expression180_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTTAG_in_expression189 */
++static ANTLR3_BITWORD FOLLOW_INTTAG_in_expression189_bits[] = { ANTLR3_UINT64_LIT(0x0000000000004000) };
++static ANTLR3_BITSET_LIST FOLLOW_INTTAG_in_expression189 = { FOLLOW_INTTAG_in_expression189_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTBOOL_in_expression191 */
++static ANTLR3_BITWORD FOLLOW_INTBOOL_in_expression191_bits[] = { ANTLR3_UINT64_LIT(0x0000000000008000) };
++static ANTLR3_BITSET_LIST FOLLOW_INTBOOL_in_expression191 = { FOLLOW_INTBOOL_in_expression191_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_expression193 */
++static ANTLR3_BITWORD FOLLOW_INT_in_expression193_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_expression193 = { FOLLOW_INT_in_expression193_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATETAG_in_expression202 */
++static ANTLR3_BITWORD FOLLOW_DATETAG_in_expression202_bits[] = { ANTLR3_UINT64_LIT(0x0000000000020000) };
++static ANTLR3_BITSET_LIST FOLLOW_DATETAG_in_expression202 = { FOLLOW_DATETAG_in_expression202_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_expression204 */
++static ANTLR3_BITWORD FOLLOW_AFTER_in_expression204_bits[] = { ANTLR3_UINT64_LIT(0x0000000000208000) };
++static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_expression204 = { FOLLOW_AFTER_in_expression204_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateval_in_expression206 */
++static ANTLR3_BITWORD FOLLOW_dateval_in_expression206_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_dateval_in_expression206 = { FOLLOW_dateval_in_expression206_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATETAG_in_expression215 */
++static ANTLR3_BITWORD FOLLOW_DATETAG_in_expression215_bits[] = { ANTLR3_UINT64_LIT(0x0000000000040000) };
++static ANTLR3_BITSET_LIST FOLLOW_DATETAG_in_expression215 = { FOLLOW_DATETAG_in_expression215_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_expression217 */
++static ANTLR3_BITWORD FOLLOW_BEFORE_in_expression217_bits[] = { ANTLR3_UINT64_LIT(0x0000000000208000) };
++static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_expression217 = { FOLLOW_BEFORE_in_expression217_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateval_in_expression219 */
++static ANTLR3_BITWORD FOLLOW_dateval_in_expression219_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_dateval_in_expression219 = { FOLLOW_dateval_in_expression219_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMTAG_in_expression228 */
++static ANTLR3_BITWORD FOLLOW_ENUMTAG_in_expression228_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001000) };
++static ANTLR3_BITSET_LIST FOLLOW_ENUMTAG_in_expression228 = { FOLLOW_ENUMTAG_in_expression228_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_IS_in_expression230 */
++static ANTLR3_BITWORD FOLLOW_IS_in_expression230_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) };
++static ANTLR3_BITSET_LIST FOLLOW_IS_in_expression230 = { FOLLOW_IS_in_expression230_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMVAL_in_expression232 */
++static ANTLR3_BITWORD FOLLOW_ENUMVAL_in_expression232_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_ENUMVAL_in_expression232 = { FOLLOW_ENUMVAL_in_expression232_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval257 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateval257_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval257 = { FOLLOW_DATE_in_dateval257_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval266 */
++static ANTLR3_BITWORD FOLLOW_interval_in_dateval266_bits[] = { ANTLR3_UINT64_LIT(0x0000000000040000) };
++static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval266 = { FOLLOW_interval_in_dateval266_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateval268 */
++static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateval268_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
++static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateval268 = { FOLLOW_BEFORE_in_dateval268_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval270 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateval270_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval270 = { FOLLOW_DATE_in_dateval270_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval279 */
++static ANTLR3_BITWORD FOLLOW_interval_in_dateval279_bits[] = { ANTLR3_UINT64_LIT(0x0000000000020000) };
++static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval279 = { FOLLOW_interval_in_dateval279_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateval281 */
++static ANTLR3_BITWORD FOLLOW_AFTER_in_dateval281_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
++static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateval281 = { FOLLOW_AFTER_in_dateval281_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval283 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateval283_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval283 = { FOLLOW_DATE_in_dateval283_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval292 */
++static ANTLR3_BITWORD FOLLOW_interval_in_dateval292_bits[] = { ANTLR3_UINT64_LIT(0x0000000000400000) };
++static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval292 = { FOLLOW_interval_in_dateval292_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AGO_in_dateval294 */
++static ANTLR3_BITWORD FOLLOW_AGO_in_dateval294_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_AGO_in_dateval294 = { FOLLOW_AGO_in_dateval294_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_interval318 */
++static ANTLR3_BITWORD FOLLOW_INT_in_interval318_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_interval318 = { FOLLOW_INT_in_interval318_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATINTERVAL_in_interval320 */
++static ANTLR3_BITWORD FOLLOW_DATINTERVAL_in_interval320_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATINTERVAL_in_interval320 = { FOLLOW_DATINTERVAL_in_interval320_bits, 1 };
++
++
++
++
++/* ==============================================
++ * Parsing rules
++ */
++/**
++ * $ANTLR start playlist
++ * SMARTPL2SQL.g:43:1: playlist returns [ pANTLR3_STRING title, pANTLR3_STRING query ] : STR '{' e= expression '}' ;
++ */
++static SMARTPL2SQL_playlist_return
++playlist(pSMARTPL2SQL ctx)
++{
++ SMARTPL2SQL_playlist_return retval;
++
++ pANTLR3_BASE_TREE STR1;
++ pANTLR3_STRING e;
++ #undef RETURN_TYPE_e
++ #define RETURN_TYPE_e pANTLR3_STRING
++
++ /* Initialize rule variables
++ */
++
++
++ retval.title= NULL; retval.query= NULL;
++ STR1 = NULL;
++ e = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ // SMARTPL2SQL.g:45:2: ( STR '{' e= expression '}' )
++ // SMARTPL2SQL.g:45:4: STR '{' e= expression '}'
++ {
++ STR1 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_playlist66);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ MATCHT(30, &FOLLOW_30_in_playlist68);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expression_in_playlist74);
++ e=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ MATCHT(31, &FOLLOW_31_in_playlist76);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 val;
++ val = (STR1->getText(STR1))->toUTF8((STR1->getText(STR1)))->chars;
++ val++;
++ val[strlen((const char *)val) - 1] = '\0';
++
++ retval.title= (STR1->getText(STR1))->factory->newRaw((STR1->getText(STR1))->factory);
++ retval.title->append8(retval.title, (const char *)val);
++
++ retval.query= e->factory->newRaw(e->factory);
++ retval.query->append8(retval.query, "(");
++ retval.query->appendS(retval.query, e);
++ retval.query->append8(retval.query, ")");
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleplaylistEx; /* Prevent compiler warnings */
++ ruleplaylistEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end playlist */
++
++/**
++ * $ANTLR start expression
++ * SMARTPL2SQL.g:62:1: expression returns [ pANTLR3_STRING result ] : ( ^( NOT a= expression ) | ^( AND a= expression b= expression ) | ^( OR a= expression b= expression ) | STRTAG INCLUDES STR | STRTAG IS STR | INTTAG INTBOOL INT | DATETAG AFTER dateval | DATETAG BEFORE dateval | ENUMTAG IS ENUMVAL );
++ */
++static pANTLR3_STRING
++expression(pSMARTPL2SQL ctx)
++{
++ pANTLR3_STRING result = NULL;
++
++ pANTLR3_BASE_TREE STR2;
++ pANTLR3_BASE_TREE STRTAG3;
++ pANTLR3_BASE_TREE STR4;
++ pANTLR3_BASE_TREE STRTAG5;
++ pANTLR3_BASE_TREE INTTAG6;
++ pANTLR3_BASE_TREE INTBOOL7;
++ pANTLR3_BASE_TREE INT8;
++ pANTLR3_BASE_TREE DATETAG10;
++ pANTLR3_BASE_TREE DATETAG12;
++ pANTLR3_BASE_TREE ENUMTAG13;
++ pANTLR3_BASE_TREE ENUMVAL14;
++ pANTLR3_STRING a;
++ #undef RETURN_TYPE_a
++ #define RETURN_TYPE_a pANTLR3_STRING
++
++ pANTLR3_STRING b;
++ #undef RETURN_TYPE_b
++ #define RETURN_TYPE_b pANTLR3_STRING
++
++ int dateval9;
++ #undef RETURN_TYPE_dateval9
++ #define RETURN_TYPE_dateval9 int
++
++ int dateval11;
++ #undef RETURN_TYPE_dateval11
++ #define RETURN_TYPE_dateval11 int
++
++ /* Initialize rule variables
++ */
++
++
++ result= NULL;
++ STR2 = NULL;
++ STRTAG3 = NULL;
++ STR4 = NULL;
++ STRTAG5 = NULL;
++ INTTAG6 = NULL;
++ INTBOOL7 = NULL;
++ INT8 = NULL;
++ DATETAG10 = NULL;
++ DATETAG12 = NULL;
++ ENUMTAG13 = NULL;
++ ENUMVAL14 = NULL;
++ a = NULL;
++ b = NULL;
++ dateval9 = 0;
++ dateval11 = 0;
++
++ {
++ {
++ // SMARTPL2SQL.g:64:2: ( ^( NOT a= expression ) | ^( AND a= expression b= expression ) | ^( OR a= expression b= expression ) | STRTAG INCLUDES STR | STRTAG IS STR | INTTAG INTBOOL INT | DATETAG AFTER dateval | DATETAG BEFORE dateval | ENUMTAG IS ENUMVAL )
++
++ ANTLR3_UINT32 alt1;
++
++ alt1=9;
++
++ switch ( LA(1) )
++ {
++ case NOT:
++ {
++ alt1=1;
++ }
++ break;
++ case AND:
++ {
++ alt1=2;
++ }
++ break;
++ case OR:
++ {
++ alt1=3;
++ }
++ break;
++ case STRTAG:
++ {
++ switch ( LA(2) )
++ {
++ case INCLUDES:
++ {
++ alt1=4;
++ }
++ break;
++ case IS:
++ {
++ alt1=5;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 4;
++
++
++ goto ruleexpressionEx;
++ }
++
++ }
++ break;
++ case INTTAG:
++ {
++ alt1=6;
++ }
++ break;
++ case DATETAG:
++ {
++ switch ( LA(2) )
++ {
++ case AFTER:
++ {
++ alt1=7;
++ }
++ break;
++ case BEFORE:
++ {
++ alt1=8;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 6;
++
++
++ goto ruleexpressionEx;
++ }
++
++ }
++ break;
++ case ENUMTAG:
++ {
++ alt1=9;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 0;
++
++
++ goto ruleexpressionEx;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // SMARTPL2SQL.g:64:4: ^( NOT a= expression )
++ {
++ MATCHT(NOT, &FOLLOW_NOT_in_expression101);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expression_in_expression107);
++ a=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ result= a->factory->newRaw(a->factory);
++ result->append8(result, "NOT(");
++ result->appendS(result, a);
++ result->append8(result, ")");
++
++ }
++
++ }
++ break;
++ case 2:
++ // SMARTPL2SQL.g:71:4: ^( AND a= expression b= expression )
++ {
++ MATCHT(AND, &FOLLOW_AND_in_expression118);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expression_in_expression124);
++ a=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expression_in_expression130);
++ b=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ result= a->factory->newRaw(a->factory);
++ result->append8(result, "(");
++ result->appendS(result, a);
++ result->append8(result, " AND ");
++ result->appendS(result, b);
++ result->append8(result, ")");
++
++ }
++
++ }
++ break;
++ case 3:
++ // SMARTPL2SQL.g:80:4: ^( OR a= expression b= expression )
++ {
++ MATCHT(OR, &FOLLOW_OR_in_expression141);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expression_in_expression147);
++ a=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expression_in_expression153);
++ b=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ result= a->factory->newRaw(a->factory);
++ result->append8(result, "(");
++ result->appendS(result, a);
++ result->append8(result, " OR ");
++ result->appendS(result, b);
++ result->append8(result, ")");
++
++ }
++
++ }
++ break;
++ case 4:
++ // SMARTPL2SQL.g:89:4: STRTAG INCLUDES STR
++ {
++ STRTAG3 = (pANTLR3_BASE_TREE) MATCHT(STRTAG, &FOLLOW_STRTAG_in_expression163);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ MATCHT(INCLUDES, &FOLLOW_INCLUDES_in_expression165);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ STR2 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expression167);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 val;
++ val = (STR2->getText(STR2))->toUTF8((STR2->getText(STR2)))->chars;
++ val++;
++ val[strlen((const char *)val) - 1] = '\0';
++
++ result= (STR2->getText(STR2))->factory->newRaw((STR2->getText(STR2))->factory);
++ result->append8(result, "f.");
++ result->appendS(result, (STRTAG3->getText(STRTAG3))->toUTF8((STRTAG3->getText(STRTAG3))));
++ result->append8(result, " LIKE '%");
++ result->append8(result, sqlite3_mprintf("%q", (const char *)val));
++ result->append8(result, "%'");
++
++ }
++
++ }
++ break;
++ case 5:
++ // SMARTPL2SQL.g:103:4: STRTAG IS STR
++ {
++ STRTAG5 = (pANTLR3_BASE_TREE) MATCHT(STRTAG, &FOLLOW_STRTAG_in_expression176);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ MATCHT(IS, &FOLLOW_IS_in_expression178);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ STR4 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expression180);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 val;
++ val = (STR4->getText(STR4))->toUTF8((STR4->getText(STR4)))->chars;
++ val++;
++ val[strlen((const char *)val) - 1] = '\0';
++
++ result= (STR4->getText(STR4))->factory->newRaw((STR4->getText(STR4))->factory);
++ result->append8(result, "f.");
++ result->appendS(result, (STRTAG5->getText(STRTAG5))->toUTF8((STRTAG5->getText(STRTAG5))));
++ result->append8(result, " LIKE '");
++ result->append8(result, sqlite3_mprintf("%q", (const char *)val));
++ result->append8(result, "'");
++
++ }
++
++ }
++ break;
++ case 6:
++ // SMARTPL2SQL.g:117:4: INTTAG INTBOOL INT
++ {
++ INTTAG6 = (pANTLR3_BASE_TREE) MATCHT(INTTAG, &FOLLOW_INTTAG_in_expression189);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ INTBOOL7 = (pANTLR3_BASE_TREE) MATCHT(INTBOOL, &FOLLOW_INTBOOL_in_expression191);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ INT8 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_expression193);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ result= (INTTAG6->getText(INTTAG6))->factory->newRaw((INTTAG6->getText(INTTAG6))->factory);
++ result->append8(result, "f.");
++ result->appendS(result, (INTTAG6->getText(INTTAG6))->toUTF8((INTTAG6->getText(INTTAG6))));
++ result->append8(result, " ");
++ result->appendS(result, (INTBOOL7->getText(INTBOOL7))->toUTF8((INTBOOL7->getText(INTBOOL7))));
++ result->append8(result, " ");
++ result->appendS(result, (INT8->getText(INT8))->toUTF8((INT8->getText(INT8))));
++
++ }
++
++ }
++ break;
++ case 7:
++ // SMARTPL2SQL.g:127:4: DATETAG AFTER dateval
++ {
++ DATETAG10 = (pANTLR3_BASE_TREE) MATCHT(DATETAG, &FOLLOW_DATETAG_in_expression202);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ MATCHT(AFTER, &FOLLOW_AFTER_in_expression204);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_dateval_in_expression206);
++ dateval9=dateval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ char str[15];
++ sprintf(str, "%d", dateval9);
++
++ result= (DATETAG10->getText(DATETAG10))->factory->newRaw((DATETAG10->getText(DATETAG10))->factory);
++ result->append8(result, "f.");
++ result->appendS(result, (DATETAG10->getText(DATETAG10))->toUTF8((DATETAG10->getText(DATETAG10))));
++ result->append8(result, " > ");
++ result->append8(result, str);
++
++ }
++
++ }
++ break;
++ case 8:
++ // SMARTPL2SQL.g:138:4: DATETAG BEFORE dateval
++ {
++ DATETAG12 = (pANTLR3_BASE_TREE) MATCHT(DATETAG, &FOLLOW_DATETAG_in_expression215);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ MATCHT(BEFORE, &FOLLOW_BEFORE_in_expression217);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_dateval_in_expression219);
++ dateval11=dateval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ char str[15];
++ sprintf(str, "%d", dateval11);
++
++ result= (DATETAG12->getText(DATETAG12))->factory->newRaw((DATETAG12->getText(DATETAG12))->factory);
++ result->append8(result, "f.");
++ result->appendS(result, (DATETAG12->getText(DATETAG12))->toUTF8((DATETAG12->getText(DATETAG12))));
++ result->append8(result, " > ");
++ result->append8(result, str);
++
++ }
++
++ }
++ break;
++ case 9:
++ // SMARTPL2SQL.g:149:4: ENUMTAG IS ENUMVAL
++ {
++ ENUMTAG13 = (pANTLR3_BASE_TREE) MATCHT(ENUMTAG, &FOLLOW_ENUMTAG_in_expression228);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ MATCHT(IS, &FOLLOW_IS_in_expression230);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ ENUMVAL14 = (pANTLR3_BASE_TREE) MATCHT(ENUMVAL, &FOLLOW_ENUMVAL_in_expression232);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 tag;
++ pANTLR3_UINT8 val;
++ char str[20];
++
++ sprintf(str, "1=1");
++
++ tag = (ENUMTAG13->getText(ENUMTAG13))->chars;
++ val = (ENUMVAL14->getText(ENUMVAL14))->chars;
++ if (strcmp((char *)tag, "media_kind") == 0)
++ {
++ if (strcmp((char *)val, "music") == 0)
++ {
++ sprintf(str, "f.media_kind = %d", MEDIA_KIND_MUSIC);
++ }
++ else if (strcmp((char *)val, "movie") == 0)
++ {
++ sprintf(str, "f.media_kind = %d", MEDIA_KIND_MOVIE);
++ }
++ else if (strcmp((char *)val, "podcast") == 0)
++ {
++ sprintf(str, "f.media_kind = %d", MEDIA_KIND_PODCAST);
++ }
++ else if (strcmp((char *)val, "audiobook") == 0)
++ {
++ sprintf(str, "f.media_kind = %d", MEDIA_KIND_AUDIOBOOK);
++ }
++ else if (strcmp((char *)val, "tvshow") == 0)
++ {
++ sprintf(str, "f.media_kind = %d", MEDIA_KIND_TVSHOW);
++ }
++ }
++ else if (strcmp((char *)tag, "data_kind") == 0)
++ {
++ if (strcmp((char *)val, "file") == 0)
++ {
++ sprintf(str, "f.data_kind = %d", DATA_KIND_FILE);
++ }
++ else if (strcmp((char *)val, "url") == 0)
++ {
++ sprintf(str, "f.data_kind = %d", DATA_KIND_URL);
++ }
++ else if (strcmp((char *)val, "spotify") == 0)
++ {
++ sprintf(str, "f.data_kind = %d", DATA_KIND_SPOTIFY);
++ }
++ else if (strcmp((char *)val, "pipe") == 0)
++ {
++ sprintf(str, "f.data_kind = %d", DATA_KIND_PIPE);
++ }
++ }
++
++ result= (ENUMTAG13->getText(ENUMTAG13))->factory->newRaw((ENUMTAG13->getText(ENUMTAG13))->factory);
++ result->append8(result, str);
++
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleexpressionEx; /* Prevent compiler warnings */
++ ruleexpressionEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return result;
++}
++/* $ANTLR end expression */
++
++/**
++ * $ANTLR start dateval
++ * SMARTPL2SQL.g:207:1: dateval returns [ int result ] : ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO );
++ */
++static int
++dateval(pSMARTPL2SQL ctx)
++{
++ int result = 0;
++
++ pANTLR3_BASE_TREE DATE15;
++ pANTLR3_BASE_TREE DATE16;
++ pANTLR3_BASE_TREE DATE18;
++ int interval17;
++ #undef RETURN_TYPE_interval17
++ #define RETURN_TYPE_interval17 int
++
++ int interval19;
++ #undef RETURN_TYPE_interval19
++ #define RETURN_TYPE_interval19 int
++
++ int interval20;
++ #undef RETURN_TYPE_interval20
++ #define RETURN_TYPE_interval20 int
++
++ /* Initialize rule variables
++ */
++
++
++ result= 0;
++ DATE15 = NULL;
++ DATE16 = NULL;
++ DATE18 = NULL;
++ interval17 = 0;
++ interval19 = 0;
++ interval20 = 0;
++
++ {
++ {
++ // SMARTPL2SQL.g:209:2: ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO )
++
++ ANTLR3_UINT32 alt2;
++
++ alt2=4;
++
++ switch ( LA(1) )
++ {
++ case DATE:
++ {
++ alt2=1;
++ }
++ break;
++ case INT:
++ {
++ switch ( LA(2) )
++ {
++ case DATINTERVAL:
++ {
++ switch ( LA(3) )
++ {
++ case AGO:
++ {
++ alt2=4;
++ }
++ break;
++ case BEFORE:
++ {
++ alt2=2;
++ }
++ break;
++ case AFTER:
++ {
++ alt2=3;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 3;
++
++
++ goto ruledatevalEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 2;
++
++
++ goto ruledatevalEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 0;
++
++
++ goto ruledatevalEx;
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // SMARTPL2SQL.g:209:4: DATE
++ {
++ DATE15 = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateval257);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 datval;
++
++ datval = (DATE15->getText(DATE15))->chars;
++
++ if (strcmp((char *)datval, "today") == 0)
++ {
++ result= time(NULL);
++ }
++ else if (strcmp((char *)datval, "yesterday") == 0)
++ {
++ result= time(NULL) - 24 * 3600;
++ }
++ else if (strcmp((char *)datval, "last week") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 7;
++ }
++ else if (strcmp((char *)datval, "last month") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 30;
++ }
++ else if (strcmp((char *)datval, "last year") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 365;
++ }
++ else
++ {
++ struct tm tm;
++ char year[5];
++ char month[3];
++ char day[3];
++
++ memset((void*)&tm,0,sizeof(tm));
++ memset(year, 0, sizeof(year));
++ memset(month, 0, sizeof(month));
++ memset(day, 0, sizeof(day));
++
++ strncpy(year, (const char *)datval, 4);
++ strncpy(month, (const char *)datval + 5, 2);
++ strncpy(day, (const char *)datval + 8, 2);
++
++ tm.tm_year = atoi(year) - 1900;
++ tm.tm_mon = atoi(month) - 1;
++ tm.tm_mday = atoi(day);
++
++ result= mktime(&tm);
++ }
++
++ }
++
++ }
++ break;
++ case 2:
++ // SMARTPL2SQL.g:258:4: interval BEFORE DATE
++ {
++ FOLLOWPUSH(FOLLOW_interval_in_dateval266);
++ interval17=interval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateval268);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ DATE16 = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateval270);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 datval;
++
++ datval = (DATE16->getText(DATE16))->chars;
++
++ if (strcmp((char *)datval, "yesterday") == 0)
++ {
++ result= time(NULL) - 24 * 3600;
++ }
++ else if (strcmp((char *)datval, "last week") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 7;
++ }
++ else if (strcmp((char *)datval, "last month") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 30;
++ }
++ else if (strcmp((char *)datval, "last year") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 365;
++ }
++ else
++ {
++ result= time(NULL);
++ }
++
++ result= result - interval17;
++
++ }
++
++ }
++ break;
++ case 3:
++ // SMARTPL2SQL.g:287:4: interval AFTER DATE
++ {
++ FOLLOWPUSH(FOLLOW_interval_in_dateval279);
++ interval19=interval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ MATCHT(AFTER, &FOLLOW_AFTER_in_dateval281);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ DATE18 = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateval283);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 datval;
++
++ datval = (DATE18->getText(DATE18))->chars;
++
++ if (strcmp((char *)datval, "yesterday") == 0)
++ {
++ result= time(NULL) - 24 * 3600;
++ }
++ else if (strcmp((char *)datval, "last week") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 7;
++ }
++ else if (strcmp((char *)datval, "last month") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 30;
++ }
++ else if (strcmp((char *)datval, "last year") == 0)
++ {
++ result= time(NULL) - 24 * 3600 * 365;
++ }
++ else
++ {
++ result= time(NULL);
++ }
++
++ result= result + interval19;
++
++ }
++
++ }
++ break;
++ case 4:
++ // SMARTPL2SQL.g:316:4: interval AGO
++ {
++ FOLLOWPUSH(FOLLOW_interval_in_dateval292);
++ interval20=interval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ MATCHT(AGO, &FOLLOW_AGO_in_dateval294);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ {
++
++ result= time(NULL) - interval20;
++
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledatevalEx; /* Prevent compiler warnings */
++ ruledatevalEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return result;
++}
++/* $ANTLR end dateval */
++
++/**
++ * $ANTLR start interval
++ * SMARTPL2SQL.g:322:1: interval returns [ int result ] : INT DATINTERVAL ;
++ */
++static int
++interval(pSMARTPL2SQL ctx)
++{
++ int result = 0;
++
++ pANTLR3_BASE_TREE INT21;
++ pANTLR3_BASE_TREE DATINTERVAL22;
++
++ /* Initialize rule variables
++ */
++
++
++ result= 0;
++ INT21 = NULL;
++ DATINTERVAL22 = NULL;
++
++ {
++ // SMARTPL2SQL.g:324:2: ( INT DATINTERVAL )
++ // SMARTPL2SQL.g:324:4: INT DATINTERVAL
++ {
++ INT21 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_interval318);
++ if (HASEXCEPTION())
++ {
++ goto ruleintervalEx;
++ }
++
++ DATINTERVAL22 = (pANTLR3_BASE_TREE) MATCHT(DATINTERVAL, &FOLLOW_DATINTERVAL_in_interval320);
++ if (HASEXCEPTION())
++ {
++ goto ruleintervalEx;
++ }
++
++ {
++
++ pANTLR3_UINT8 interval;
++
++ result= atoi((const char *)(INT21->getText(INT21))->chars);
++ interval = (DATINTERVAL22->getText(DATINTERVAL22))->chars;
++
++ if (strcmp((char *)interval, "days") == 0)
++ {
++ result= result * 24 * 3600;
++ }
++ else if (strcmp((char *)interval, "weeks") == 0)
++ {
++ result= result * 24 * 3600 * 7;
++ }
++ else if (strcmp((char *)interval, "months") == 0)
++ {
++ result= result * 24 * 3600 * 30;
++ }
++ else if (strcmp((char *)interval, "weeks") == 0)
++ {
++ result= result * 24 * 3600 * 365;
++ }
++ else
++ {
++ result= 0;
++ }
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleintervalEx; /* Prevent compiler warnings */
++ ruleintervalEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return result;
++}
++/* $ANTLR end interval */
++/* End of parsing rules
++ * ==============================================
++ */
++
++/* ==============================================
++ * Syntactic predicates
++ */
++/* End of syntactic predicates
++ * ==============================================
++ */
++
++
++
++
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/SMARTPL2SQL.h b/src/pregen/SMARTPL2SQL.h
+new file mode 100644
+index 0000000..322e8fd
+--- /dev/null
++++ b/src/pregen/SMARTPL2SQL.h
+@@ -0,0 +1,220 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : SMARTPL2SQL.g
++ * - On : 2015-06-27 19:05:21
++ * - for the tree parser : SMARTPL2SQLTreeParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The tree parser SMARTPL2SQL has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pSMARTPL2SQL, which is returned from a call to SMARTPL2SQLNew().
++ *
++ * The methods in pSMARTPL2SQL are as follows:
++ *
++ * - SMARTPL2SQL_playlist_return pSMARTPL2SQL->playlist(pSMARTPL2SQL)
++ * - pANTLR3_STRING pSMARTPL2SQL->expression(pSMARTPL2SQL)
++ * - int pSMARTPL2SQL->dateval(pSMARTPL2SQL)
++ * - int pSMARTPL2SQL->interval(pSMARTPL2SQL)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _SMARTPL2SQL_H
++#define _SMARTPL2SQL_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct SMARTPL2SQL_Ctx_struct SMARTPL2SQL, * pSMARTPL2SQL;
++
++
++
++ #include <stdio.h>
++ #include <stdlib.h>
++ #include <string.h>
++ #include <limits.h>
++ #include <errno.h>
++ #include <time.h>
++ #include <sqlite3.h>
++
++ #include "logger.h"
++ #include "db.h"
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++typedef struct SMARTPL2SQL_playlist_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ pANTLR3_STRING title;
++ pANTLR3_STRING query;
++}
++ SMARTPL2SQL_playlist_return;
++
++
++
++/** Context tracking structure for SMARTPL2SQL
++ */
++struct SMARTPL2SQL_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_TREE_PARSER pTreeParser;
++
++
++ SMARTPL2SQL_playlist_return (*playlist) (struct SMARTPL2SQL_Ctx_struct * ctx);
++ pANTLR3_STRING (*expression) (struct SMARTPL2SQL_Ctx_struct * ctx);
++ int (*dateval) (struct SMARTPL2SQL_Ctx_struct * ctx);
++ int (*interval) (struct SMARTPL2SQL_Ctx_struct * ctx);
++ // Delegated rules
++ const char * (*getGrammarFileName)();
++ void (*free) (struct SMARTPL2SQL_Ctx_struct * ctx);
++
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pSMARTPL2SQL SMARTPL2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream);
++ANTLR3_API pSMARTPL2SQL SMARTPL2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the tree parser will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define INTBOOL 14
++#define STRTAG 10
++#define AGO 22
++#define WHITESPACE 29
++#define GREATEREQUAL 25
++#define BEFORE 18
++#define DATETAG 16
++#define INT 15
++#define NOT 7
++#define AFTER 17
++#define AND 6
++#define EOF -1
++#define INCLUDES 11
++#define STR 4
++#define T__30 30
++#define T__31 31
++#define GREATER 24
++#define LPAR 8
++#define ENUMTAG 19
++#define IS 12
++#define ENUMVAL 20
++#define EQUAL 28
++#define OR 5
++#define LESS 26
++#define RPAR 9
++#define DATE 21
++#define LESSEQUAL 27
++#define INTTAG 13
++#define DATINTERVAL 23
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for SMARTPL2SQL
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/SMARTPL2SQL.u b/src/pregen/SMARTPL2SQL.u
+new file mode 100644
+index 0000000..85567d1
+--- /dev/null
++++ b/src/pregen/SMARTPL2SQL.u
+@@ -0,0 +1,5 @@
++SMARTPL2SQL.g: SMARTPL.tokens
++SMARTPL2SQL.c : SMARTPL2SQL.g
++./SMARTPL2SQL.tokens : SMARTPL2SQL.g
++SMARTPL2SQL.h : SMARTPL2SQL.g
++ANTLR_PRODUCTS += SMARTPL2SQL.c ./SMARTPL2SQL.tokens SMARTPL2SQL.h
+\ No newline at end of file
+diff --git a/src/pregen/SMARTPLLexer.c b/src/pregen/SMARTPLLexer.c
+new file mode 100644
+index 0000000..9ea1a83
+--- /dev/null
++++ b/src/pregen/SMARTPLLexer.c
+@@ -0,0 +1,4168 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : SMARTPL.g
++ * - On : 2015-06-27 19:05:15
++ * - for the lexer : SMARTPLLexerLexer *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "SMARTPLLexer.h"
++/* ----------------------------------------- */
++
++
++/** String literals used by SMARTPLLexer that we must do things like MATCHS() with.
++ * C will normally just lay down 8 bit characters, and you can use L"xxx" to
++ * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
++ * we perform this little trick of defining the literals as arrays of UINT32
++ * and passing in the address of these.
++ */
++static ANTLR3_UCHAR lit_1[] = { 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_2[] = { 0x61, 0x6C, 0x62, 0x75, 0x6D, 0x5F, 0x61, 0x72, 0x74, 0x69, 0x73, 0x74, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_3[] = { 0x61, 0x6C, 0x62, 0x75, 0x6D, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_4[] = { 0x74, 0x69, 0x74, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_5[] = { 0x67, 0x65, 0x6E, 0x72, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_6[] = { 0x63, 0x6F, 0x6D, 0x70, 0x6F, 0x73, 0x65, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_7[] = { 0x70, 0x61, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_8[] = { 0x74, 0x79, 0x70, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_9[] = { 0x67, 0x72, 0x6F, 0x75, 0x70, 0x69, 0x6E, 0x67, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_10[] = { 0x70, 0x6C, 0x61, 0x79, 0x5F, 0x63, 0x6F, 0x75, 0x6E, 0x74, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_11[] = { 0x72, 0x61, 0x74, 0x69, 0x6E, 0x67, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_12[] = { 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_13[] = { 0x63, 0x6F, 0x6D, 0x70, 0x69, 0x6C, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_14[] = { 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x61, 0x64, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_15[] = { 0x74, 0x69, 0x6D, 0x65, 0x5F, 0x70, 0x6C, 0x61, 0x79, 0x65, 0x64, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_16[] = { 0x64, 0x61, 0x74, 0x61, 0x5F, 0x6B, 0x69, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_17[] = { 0x6D, 0x65, 0x64, 0x69, 0x61, 0x5F, 0x6B, 0x69, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_18[] = { 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_19[] = { 0x69, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_20[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_21[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_22[] = { 0x61, 0x66, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_23[] = { 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_24[] = { 0x61, 0x67, 0x6F, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_25[] = { 0x41, 0x4E, 0x44, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_26[] = { 0x61, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_27[] = { 0x4F, 0x52, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_28[] = { 0x6F, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_29[] = { 0x4E, 0x4F, 0x54, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_30[] = { 0x6E, 0x6F, 0x74, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_31[] = { 0x74, 0x6F, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_32[] = { 0x79, 0x65, 0x73, 0x74, 0x65, 0x72, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_33[] = { 0x6C, 0x61, 0x73, 0x74, 0x20, 0x77, 0x65, 0x65, 0x6B, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_34[] = { 0x6C, 0x61, 0x73, 0x74, 0x20, 0x6D, 0x6F, 0x6E, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_35[] = { 0x6C, 0x61, 0x73, 0x74, 0x20, 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_36[] = { 0x64, 0x61, 0x79, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_37[] = { 0x77, 0x65, 0x65, 0x6B, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_38[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_39[] = { 0x79, 0x65, 0x61, 0x72, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_40[] = { 0x6D, 0x75, 0x73, 0x69, 0x63, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_41[] = { 0x6D, 0x6F, 0x76, 0x69, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_42[] = { 0x70, 0x6F, 0x64, 0x63, 0x61, 0x73, 0x74, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_43[] = { 0x61, 0x75, 0x64, 0x69, 0x6F, 0x62, 0x6F, 0x6F, 0x6B, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_44[] = { 0x74, 0x76, 0x73, 0x68, 0x6F, 0x77, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_45[] = { 0x66, 0x69, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_46[] = { 0x75, 0x72, 0x6C, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_47[] = { 0x73, 0x70, 0x6F, 0x74, 0x69, 0x66, 0x79, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_48[] = { 0x70, 0x69, 0x70, 0x65, ANTLR3_STRING_TERMINATOR};
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pSMARTPLLexer_##scope##_SCOPE
++#define SCOPE_STACK(scope) pSMARTPLLexer_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pSMARTPLLexer_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pSMARTPLLexer_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++
++/* Macros for accessing things in a lexer
++ */
++#undef LEXER
++#undef RECOGNIZER
++#undef RULEMEMO
++#undef GETCHARINDEX
++#undef GETLINE
++#undef GETCHARPOSITIONINLINE
++#undef EMIT
++#undef EMITNEW
++#undef MATCHC
++#undef MATCHS
++#undef MATCHRANGE
++#undef LTOKEN
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef INPUT
++#undef STRSTREAM
++#undef LA
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef LRECOVER
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef BACKTRACKING
++#undef MATCHANY
++#undef MEMOIZE
++#undef HAVEPARSEDRULE
++#undef GETTEXT
++#undef INDEX
++#undef SEEK
++#undef PUSHSTREAM
++#undef POPSTREAM
++#undef SETTEXT
++#undef SETTEXT8
++
++#define LEXER ctx->pLexer
++#define RECOGNIZER LEXER->rec
++#define LEXSTATE RECOGNIZER->state
++#define TOKSOURCE LEXSTATE->tokSource
++#define GETCHARINDEX() LEXER->getCharIndex(LEXER)
++#define GETLINE() LEXER->getLine(LEXER)
++#define GETTEXT() LEXER->getText(LEXER)
++#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
++#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER)
++#define EMITNEW(t) LEXER->emitNew(LEXER, t)
++#define MATCHC(c) LEXER->matchc(LEXER, c)
++#define MATCHS(s) LEXER->matchs(LEXER, s)
++#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2)
++#define MATCHANY() LEXER->matchAny(LEXER)
++#define LTOKEN LEXSTATE->token
++#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE)
++#define BACKTRACKING LEXSTATE->backtracking
++#define FAILEDFLAG LEXSTATE->failed
++#define INPUT LEXER->input
++#define STRSTREAM INPUT
++#define ISTREAM INPUT->istream
++#define INDEX() ISTREAM->index(ISTREAM)
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken)
++#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION LEXSTATE->exception
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define LRECOVER() LEXER->recover(LEXER)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str)
++#define POPSTREAM() LEXER->popCharStream(LEXER)
++#define SETTEXT(str) LEXSTATE->text = str
++#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken)
++#define USER1 LEXSTATE->user1
++#define USER2 LEXSTATE->user2
++#define USER3 LEXSTATE->user3
++#define CUSTOM LEXSTATE->custom
++#define RULEMEMO LEXSTATE->ruleMemo
++#define DBG RECOGNIZER->debugger
++
++/* If we have been told we can rely on the standard 8 bit or 16 bit input
++ * stream, then we can define our macros to use the direct pointers
++ * in the input object, which is much faster than indirect calls. This
++ * is really only significant to lexers with a lot of fragment rules (which
++ * do not place LA(1) in a temporary at the moment) and even then
++ * only if there is a lot of input (order of say 1M or so).
++ */
++#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
++
++# ifdef ANTLR3_INLINE_INPUT_ASCII
++
++/* 8 bit "ASCII" (actually any 8 bit character set) */
++
++# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar))
++# define DATAP ((pANTLR3_UINT8)(INPUT->data))
++
++# else
++
++# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar))
++# define DATAP ((pANTLR3_UINT16)(INPUT->data))
++
++# endif
++
++# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
++# define CONSUME() \
++{ \
++ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \
++ { \
++ INPUT->charPositionInLine++; \
++ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \
++ { \
++ INPUT->line++; \
++ INPUT->charPositionInLine = 0; \
++ INPUT->currentLine = (void *)(NEXTCHAR + 1); \
++ } \
++ INPUT->nextChar = (void *)(NEXTCHAR + 1); \
++ } \
++}
++
++#else
++
++// Pick up the input character by calling the input stream implementation.
++//
++#define CONSUME() INPUT->istream->consume(INPUT->istream)
++#define LA(n) INPUT->istream->_LA(INPUT->istream, n)
++
++#endif
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++/* Forward declare the locally static matching functions we have generated and any predicate functions.
++ */
++static ANTLR3_INLINE void mT__30 (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mT__31 (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mSTRTAG (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mINTTAG (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mDATETAG (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mENUMTAG (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mINCLUDES (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mIS (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mINTBOOL (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mGREATER (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mGREATEREQUAL (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mLESS (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mLESSEQUAL (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mEQUAL (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mAFTER (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mBEFORE (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mAGO (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mAND (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mOR (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mNOT (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mLPAR (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mRPAR (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mDATE (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mDATINTERVAL (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mENUMVAL (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mSTR (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mINT (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mWHITESPACE (pSMARTPLLexer ctx);
++static ANTLR3_INLINE void mTokens (pSMARTPLLexer ctx);
++static void SMARTPLLexerFree(pSMARTPLLexer ctx);
++
++/* =========================================================================
++ * Lexer matching rules end.
++ * =========================================================================
++ */
++
++
++
++static void
++SMARTPLLexerFree (pSMARTPLLexer ctx)
++{
++ LEXER->free(LEXER);
++
++ ANTLR3_FREE(ctx);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "SMARTPL.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++
++/** \brief Create a new lexer called SMARTPLLexer
++ *
++ * \param[in] instream Pointer to an initialized input stream
++ * \return
++ * - Success pSMARTPLLexer initialized for the lex start
++ * - Fail NULL
++ */
++ANTLR3_API pSMARTPLLexer SMARTPLLexerNew
++(pANTLR3_INPUT_STREAM instream)
++{
++ // See if we can create a new lexer with the standard constructor
++ //
++ return SMARTPLLexerNewSSD(instream, NULL);
++}
++
++/** \brief Create a new lexer called SMARTPLLexer
++ *
++ * \param[in] instream Pointer to an initialized input stream
++ * \param[state] state Previously created shared recognizer stat
++ * \return
++ * - Success pSMARTPLLexer initialized for the lex start
++ * - Fail NULL
++ */
++ANTLR3_API pSMARTPLLexer SMARTPLLexerNewSSD
++(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pSMARTPLLexer ctx; // Context structure we will build and return
++
++ ctx = (pSMARTPLLexer) ANTLR3_CALLOC(1, sizeof(SMARTPLLexer));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for lexer context
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * in base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 lexer function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in SMARTPLLexer.h here so you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base lexer, using the supplied input stream
++ */
++ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
++
++ /* Check that we allocated the memory correctly
++ */
++ if (ctx->pLexer == NULL)
++ {
++ ANTLR3_FREE(ctx);
++ return NULL;
++ }
++ /* Install the implementation of our SMARTPLLexer interface
++ */
++ ctx->mT__30 = mT__30;
++ ctx->mT__31 = mT__31;
++ ctx->mSTRTAG = mSTRTAG;
++ ctx->mINTTAG = mINTTAG;
++ ctx->mDATETAG = mDATETAG;
++ ctx->mENUMTAG = mENUMTAG;
++ ctx->mINCLUDES = mINCLUDES;
++ ctx->mIS = mIS;
++ ctx->mINTBOOL = mINTBOOL;
++ ctx->mGREATER = mGREATER;
++ ctx->mGREATEREQUAL = mGREATEREQUAL;
++ ctx->mLESS = mLESS;
++ ctx->mLESSEQUAL = mLESSEQUAL;
++ ctx->mEQUAL = mEQUAL;
++ ctx->mAFTER = mAFTER;
++ ctx->mBEFORE = mBEFORE;
++ ctx->mAGO = mAGO;
++ ctx->mAND = mAND;
++ ctx->mOR = mOR;
++ ctx->mNOT = mNOT;
++ ctx->mLPAR = mLPAR;
++ ctx->mRPAR = mRPAR;
++ ctx->mDATE = mDATE;
++ ctx->mDATINTERVAL = mDATINTERVAL;
++ ctx->mENUMVAL = mENUMVAL;
++ ctx->mSTR = mSTR;
++ ctx->mINT = mINT;
++ ctx->mWHITESPACE = mWHITESPACE;
++ ctx->mTokens = mTokens;
++
++ /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
++ * it will call mTokens() in this generated code, and will pass it the ctx
++ * pointer of this lexer, not the context of the base lexer, so store that now.
++ */
++ ctx->pLexer->ctx = ctx;
++
++ /**Install the token matching function
++ */
++ ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
++
++ ctx->getGrammarFileName = getGrammarFileName;
++ ctx->free = SMARTPLLexerFree;
++
++
++
++
++
++ /* Return the newly built lexer to the caller
++ */
++ return ctx;
++}
++
++
++/* =========================================================================
++ * Functions to match the lexer grammar defined tokens from the input stream
++ */
++
++// Comes from: 7:7: ( '{' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start T__30
++ *
++ * Looks to match the characters the constitute the token T__30
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mT__30(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = T__30;
++
++
++ // SMARTPL.g:7:7: ( '{' )
++ // SMARTPL.g:7:9: '{'
++ {
++ MATCHC('{');
++ if (HASEXCEPTION())
++ {
++ goto ruleT__30Ex;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleT__30Ex; /* Prevent compiler warnings */
++ ruleT__30Ex: ;
++
++}
++// $ANTLR end T__30
++
++// Comes from: 8:7: ( '}' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start T__31
++ *
++ * Looks to match the characters the constitute the token T__31
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mT__31(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = T__31;
++
++
++ // SMARTPL.g:8:7: ( '}' )
++ // SMARTPL.g:8:9: '}'
++ {
++ MATCHC('}');
++ if (HASEXCEPTION())
++ {
++ goto ruleT__31Ex;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleT__31Ex; /* Prevent compiler warnings */
++ ruleT__31Ex: ;
++
++}
++// $ANTLR end T__31
++
++// Comes from: 56:9: ( 'artist' | 'album_artist' | 'album' | 'title' | 'genre' | 'composer' | 'path' | 'type' | 'grouping' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start STRTAG
++ *
++ * Looks to match the characters the constitute the token STRTAG
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mSTRTAG(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = STRTAG;
++
++
++ {
++ // SMARTPL.g:56:9: ( 'artist' | 'album_artist' | 'album' | 'title' | 'genre' | 'composer' | 'path' | 'type' | 'grouping' )
++
++ ANTLR3_UINT32 alt1;
++
++ alt1=9;
++
++ switch ( LA(1) )
++ {
++ case 'a':
++ {
++ switch ( LA(2) )
++ {
++ case 'r':
++ {
++ alt1=1;
++ }
++ break;
++ case 'l':
++ {
++ switch ( LA(3) )
++ {
++ case 'b':
++ {
++ switch ( LA(4) )
++ {
++ case 'u':
++ {
++ switch ( LA(5) )
++ {
++ case 'm':
++ {
++ switch ( LA(6) )
++ {
++ case '_':
++ {
++ alt1=2;
++ }
++ break;
++
++ default:
++ alt1=3;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 13;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 12;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 7;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 1;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ }
++ break;
++ case 't':
++ {
++ switch ( LA(2) )
++ {
++ case 'i':
++ {
++ alt1=4;
++ }
++ break;
++ case 'y':
++ {
++ alt1=8;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 2;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ }
++ break;
++ case 'g':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ alt1=5;
++ }
++ break;
++ case 'r':
++ {
++ alt1=9;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 3;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ }
++ break;
++ case 'c':
++ {
++ alt1=6;
++ }
++ break;
++ case 'p':
++ {
++ alt1=7;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 0;
++
++
++ goto ruleSTRTAGEx;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // SMARTPL.g:56:11: 'artist'
++ {
++ MATCHS(lit_1);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:57:6: 'album_artist'
++ {
++ MATCHS(lit_2);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:58:6: 'album'
++ {
++ MATCHS(lit_3);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:59:6: 'title'
++ {
++ MATCHS(lit_4);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 5:
++ // SMARTPL.g:60:6: 'genre'
++ {
++ MATCHS(lit_5);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 6:
++ // SMARTPL.g:61:6: 'composer'
++ {
++ MATCHS(lit_6);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 7:
++ // SMARTPL.g:62:6: 'path'
++ {
++ MATCHS(lit_7);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 8:
++ // SMARTPL.g:63:6: 'type'
++ {
++ MATCHS(lit_8);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 9:
++ // SMARTPL.g:64:6: 'grouping'
++ {
++ MATCHS(lit_9);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTRTAGEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleSTRTAGEx; /* Prevent compiler warnings */
++ ruleSTRTAGEx: ;
++
++}
++// $ANTLR end STRTAG
++
++// Comes from: 67:9: ( 'play_count' | 'rating' | 'year' | 'compilation' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start INTTAG
++ *
++ * Looks to match the characters the constitute the token INTTAG
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mINTTAG(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = INTTAG;
++
++
++ {
++ // SMARTPL.g:67:9: ( 'play_count' | 'rating' | 'year' | 'compilation' )
++
++ ANTLR3_UINT32 alt2;
++
++ alt2=4;
++
++ switch ( LA(1) )
++ {
++ case 'p':
++ {
++ alt2=1;
++ }
++ break;
++ case 'r':
++ {
++ alt2=2;
++ }
++ break;
++ case 'y':
++ {
++ alt2=3;
++ }
++ break;
++ case 'c':
++ {
++ alt2=4;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 0;
++
++
++ goto ruleINTTAGEx;
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // SMARTPL.g:67:11: 'play_count'
++ {
++ MATCHS(lit_10);
++ if (HASEXCEPTION())
++ {
++ goto ruleINTTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:68:6: 'rating'
++ {
++ MATCHS(lit_11);
++ if (HASEXCEPTION())
++ {
++ goto ruleINTTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:69:6: 'year'
++ {
++ MATCHS(lit_12);
++ if (HASEXCEPTION())
++ {
++ goto ruleINTTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:70:6: 'compilation'
++ {
++ MATCHS(lit_13);
++ if (HASEXCEPTION())
++ {
++ goto ruleINTTAGEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleINTTAGEx; /* Prevent compiler warnings */
++ ruleINTTAGEx: ;
++
++}
++// $ANTLR end INTTAG
++
++// Comes from: 73:10: ( 'time_added' | 'time_played' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DATETAG
++ *
++ * Looks to match the characters the constitute the token DATETAG
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDATETAG(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = DATETAG;
++
++
++ {
++ // SMARTPL.g:73:10: ( 'time_added' | 'time_played' )
++
++ ANTLR3_UINT32 alt3;
++
++ alt3=2;
++
++ switch ( LA(1) )
++ {
++ case 't':
++ {
++ switch ( LA(2) )
++ {
++ case 'i':
++ {
++ switch ( LA(3) )
++ {
++ case 'm':
++ {
++ switch ( LA(4) )
++ {
++ case 'e':
++ {
++ switch ( LA(5) )
++ {
++ case '_':
++ {
++ switch ( LA(6) )
++ {
++ case 'a':
++ {
++ alt3=1;
++ }
++ break;
++ case 'p':
++ {
++ alt3=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 5;
++
++
++ goto ruleDATETAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 4;
++
++
++ goto ruleDATETAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 3;
++
++
++ goto ruleDATETAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 2;
++
++
++ goto ruleDATETAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 1;
++
++
++ goto ruleDATETAGEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 0;
++
++
++ goto ruleDATETAGEx;
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // SMARTPL.g:73:12: 'time_added'
++ {
++ MATCHS(lit_14);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATETAGEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:74:6: 'time_played'
++ {
++ MATCHS(lit_15);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATETAGEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDATETAGEx; /* Prevent compiler warnings */
++ ruleDATETAGEx: ;
++
++}
++// $ANTLR end DATETAG
++
++// Comes from: 77:10: ( 'data_kind' | 'media_kind' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start ENUMTAG
++ *
++ * Looks to match the characters the constitute the token ENUMTAG
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mENUMTAG(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = ENUMTAG;
++
++
++ {
++ // SMARTPL.g:77:10: ( 'data_kind' | 'media_kind' )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=2;
++
++ switch ( LA(1) )
++ {
++ case 'd':
++ {
++ alt4=1;
++ }
++ break;
++ case 'm':
++ {
++ alt4=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto ruleENUMTAGEx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // SMARTPL.g:77:12: 'data_kind'
++ {
++ MATCHS(lit_16);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMTAGEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:78:6: 'media_kind'
++ {
++ MATCHS(lit_17);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMTAGEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleENUMTAGEx; /* Prevent compiler warnings */
++ ruleENUMTAGEx: ;
++
++}
++// $ANTLR end ENUMTAG
++
++// Comes from: 81:10: ( 'includes' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start INCLUDES
++ *
++ * Looks to match the characters the constitute the token INCLUDES
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mINCLUDES(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = INCLUDES;
++
++
++ // SMARTPL.g:81:10: ( 'includes' )
++ // SMARTPL.g:81:12: 'includes'
++ {
++ MATCHS(lit_18);
++ if (HASEXCEPTION())
++ {
++ goto ruleINCLUDESEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleINCLUDESEx; /* Prevent compiler warnings */
++ ruleINCLUDESEx: ;
++
++}
++// $ANTLR end INCLUDES
++
++// Comes from: 84:6: ( 'is' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start IS
++ *
++ * Looks to match the characters the constitute the token IS
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mIS(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = IS;
++
++
++ // SMARTPL.g:84:6: ( 'is' )
++ // SMARTPL.g:84:8: 'is'
++ {
++ MATCHS(lit_19);
++ if (HASEXCEPTION())
++ {
++ goto ruleISEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleISEx; /* Prevent compiler warnings */
++ ruleISEx: ;
++
++}
++// $ANTLR end IS
++
++// Comes from: 87:10: ( ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL ) )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start INTBOOL
++ *
++ * Looks to match the characters the constitute the token INTBOOL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mINTBOOL(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = INTBOOL;
++
++
++ // SMARTPL.g:87:10: ( ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL ) )
++ // SMARTPL.g:87:12: ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL )
++ {
++
++ // SMARTPL.g:87:12: ( GREATER | GREATEREQUAL | LESS | LESSEQUAL | EQUAL )
++ {
++ int alt5=5;
++ switch ( LA(1) )
++ {
++ case '>':
++ {
++ switch ( LA(2) )
++ {
++ case '=':
++ {
++ alt5=2;
++ }
++ break;
++
++ default:
++ alt5=1;}
++
++ }
++ break;
++ case '<':
++ {
++ switch ( LA(2) )
++ {
++ case '=':
++ {
++ alt5=4;
++ }
++ break;
++
++ default:
++ alt5=3;}
++
++ }
++ break;
++ case '=':
++ {
++ alt5=5;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 0;
++
++
++ goto ruleINTBOOLEx;
++ }
++
++ switch (alt5)
++ {
++ case 1:
++ // SMARTPL.g:87:13: GREATER
++ {
++ /* 87:13: GREATER */
++ mGREATER(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTBOOLEx;
++ }
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:87:21: GREATEREQUAL
++ {
++ /* 87:21: GREATEREQUAL */
++ mGREATEREQUAL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTBOOLEx;
++ }
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:87:34: LESS
++ {
++ /* 87:34: LESS */
++ mLESS(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTBOOLEx;
++ }
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:87:39: LESSEQUAL
++ {
++ /* 87:39: LESSEQUAL */
++ mLESSEQUAL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTBOOLEx;
++ }
++
++
++ }
++ break;
++ case 5:
++ // SMARTPL.g:87:49: EQUAL
++ {
++ /* 87:49: EQUAL */
++ mEQUAL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTBOOLEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleINTBOOLEx; /* Prevent compiler warnings */
++ ruleINTBOOLEx: ;
++
++}
++// $ANTLR end INTBOOL
++
++// Comes from: 91:10: ( '>' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start GREATER
++ *
++ * Looks to match the characters the constitute the token GREATER
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mGREATER(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // SMARTPL.g:91:10: ( '>' )
++ // SMARTPL.g:91:12: '>'
++ {
++ MATCHC('>');
++ if (HASEXCEPTION())
++ {
++ goto ruleGREATEREx;
++ }
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleGREATEREx; /* Prevent compiler warnings */
++ ruleGREATEREx: ;
++
++}
++// $ANTLR end GREATER
++
++// Comes from: 95:13: ( '>=' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start GREATEREQUAL
++ *
++ * Looks to match the characters the constitute the token GREATEREQUAL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mGREATEREQUAL(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // SMARTPL.g:95:13: ( '>=' )
++ // SMARTPL.g:95:15: '>='
++ {
++ MATCHS(lit_20);
++ if (HASEXCEPTION())
++ {
++ goto ruleGREATEREQUALEx;
++ }
++
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleGREATEREQUALEx; /* Prevent compiler warnings */
++ ruleGREATEREQUALEx: ;
++
++}
++// $ANTLR end GREATEREQUAL
++
++// Comes from: 99:7: ( '<' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LESS
++ *
++ * Looks to match the characters the constitute the token LESS
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLESS(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // SMARTPL.g:99:7: ( '<' )
++ // SMARTPL.g:99:9: '<'
++ {
++ MATCHC('<');
++ if (HASEXCEPTION())
++ {
++ goto ruleLESSEx;
++ }
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLESSEx; /* Prevent compiler warnings */
++ ruleLESSEx: ;
++
++}
++// $ANTLR end LESS
++
++// Comes from: 103:11: ( '<=' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LESSEQUAL
++ *
++ * Looks to match the characters the constitute the token LESSEQUAL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLESSEQUAL(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // SMARTPL.g:103:11: ( '<=' )
++ // SMARTPL.g:103:13: '<='
++ {
++ MATCHS(lit_21);
++ if (HASEXCEPTION())
++ {
++ goto ruleLESSEQUALEx;
++ }
++
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLESSEQUALEx; /* Prevent compiler warnings */
++ ruleLESSEQUALEx: ;
++
++}
++// $ANTLR end LESSEQUAL
++
++// Comes from: 107:8: ( '=' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start EQUAL
++ *
++ * Looks to match the characters the constitute the token EQUAL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mEQUAL(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // SMARTPL.g:107:8: ( '=' )
++ // SMARTPL.g:107:10: '='
++ {
++ MATCHC('=');
++ if (HASEXCEPTION())
++ {
++ goto ruleEQUALEx;
++ }
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleEQUALEx; /* Prevent compiler warnings */
++ ruleEQUALEx: ;
++
++}
++// $ANTLR end EQUAL
++
++// Comes from: 110:8: ( 'after' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start AFTER
++ *
++ * Looks to match the characters the constitute the token AFTER
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mAFTER(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = AFTER;
++
++
++ // SMARTPL.g:110:8: ( 'after' )
++ // SMARTPL.g:110:10: 'after'
++ {
++ MATCHS(lit_22);
++ if (HASEXCEPTION())
++ {
++ goto ruleAFTEREx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleAFTEREx; /* Prevent compiler warnings */
++ ruleAFTEREx: ;
++
++}
++// $ANTLR end AFTER
++
++// Comes from: 113:9: ( 'before' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start BEFORE
++ *
++ * Looks to match the characters the constitute the token BEFORE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mBEFORE(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = BEFORE;
++
++
++ // SMARTPL.g:113:9: ( 'before' )
++ // SMARTPL.g:113:11: 'before'
++ {
++ MATCHS(lit_23);
++ if (HASEXCEPTION())
++ {
++ goto ruleBEFOREEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleBEFOREEx; /* Prevent compiler warnings */
++ ruleBEFOREEx: ;
++
++}
++// $ANTLR end BEFORE
++
++// Comes from: 116:7: ( 'ago' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start AGO
++ *
++ * Looks to match the characters the constitute the token AGO
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mAGO(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = AGO;
++
++
++ // SMARTPL.g:116:7: ( 'ago' )
++ // SMARTPL.g:116:9: 'ago'
++ {
++ MATCHS(lit_24);
++ if (HASEXCEPTION())
++ {
++ goto ruleAGOEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleAGOEx; /* Prevent compiler warnings */
++ ruleAGOEx: ;
++
++}
++// $ANTLR end AGO
++
++// Comes from: 119:7: ( 'AND' | 'and' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start AND
++ *
++ * Looks to match the characters the constitute the token AND
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mAND(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = AND;
++
++
++ {
++ // SMARTPL.g:119:7: ( 'AND' | 'and' )
++
++ ANTLR3_UINT32 alt6;
++
++ alt6=2;
++
++ switch ( LA(1) )
++ {
++ case 'A':
++ {
++ alt6=1;
++ }
++ break;
++ case 'a':
++ {
++ alt6=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 6;
++ EXCEPTION->state = 0;
++
++
++ goto ruleANDEx;
++ }
++
++ switch (alt6)
++ {
++ case 1:
++ // SMARTPL.g:119:9: 'AND'
++ {
++ MATCHS(lit_25);
++ if (HASEXCEPTION())
++ {
++ goto ruleANDEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:120:6: 'and'
++ {
++ MATCHS(lit_26);
++ if (HASEXCEPTION())
++ {
++ goto ruleANDEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleANDEx; /* Prevent compiler warnings */
++ ruleANDEx: ;
++
++}
++// $ANTLR end AND
++
++// Comes from: 123:6: ( 'OR' | 'or' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start OR
++ *
++ * Looks to match the characters the constitute the token OR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mOR(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = OR;
++
++
++ {
++ // SMARTPL.g:123:6: ( 'OR' | 'or' )
++
++ ANTLR3_UINT32 alt7;
++
++ alt7=2;
++
++ switch ( LA(1) )
++ {
++ case 'O':
++ {
++ alt7=1;
++ }
++ break;
++ case 'o':
++ {
++ alt7=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 7;
++ EXCEPTION->state = 0;
++
++
++ goto ruleOREx;
++ }
++
++ switch (alt7)
++ {
++ case 1:
++ // SMARTPL.g:123:8: 'OR'
++ {
++ MATCHS(lit_27);
++ if (HASEXCEPTION())
++ {
++ goto ruleOREx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:124:6: 'or'
++ {
++ MATCHS(lit_28);
++ if (HASEXCEPTION())
++ {
++ goto ruleOREx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleOREx; /* Prevent compiler warnings */
++ ruleOREx: ;
++
++}
++// $ANTLR end OR
++
++// Comes from: 127:7: ( 'NOT' | 'not' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start NOT
++ *
++ * Looks to match the characters the constitute the token NOT
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mNOT(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = NOT;
++
++
++ {
++ // SMARTPL.g:127:7: ( 'NOT' | 'not' )
++
++ ANTLR3_UINT32 alt8;
++
++ alt8=2;
++
++ switch ( LA(1) )
++ {
++ case 'N':
++ {
++ alt8=1;
++ }
++ break;
++ case 'n':
++ {
++ alt8=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 8;
++ EXCEPTION->state = 0;
++
++
++ goto ruleNOTEx;
++ }
++
++ switch (alt8)
++ {
++ case 1:
++ // SMARTPL.g:127:9: 'NOT'
++ {
++ MATCHS(lit_29);
++ if (HASEXCEPTION())
++ {
++ goto ruleNOTEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:128:6: 'not'
++ {
++ MATCHS(lit_30);
++ if (HASEXCEPTION())
++ {
++ goto ruleNOTEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleNOTEx; /* Prevent compiler warnings */
++ ruleNOTEx: ;
++
++}
++// $ANTLR end NOT
++
++// Comes from: 131:7: ( '(' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LPAR
++ *
++ * Looks to match the characters the constitute the token LPAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLPAR(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = LPAR;
++
++
++ // SMARTPL.g:131:7: ( '(' )
++ // SMARTPL.g:131:9: '('
++ {
++ MATCHC('(');
++ if (HASEXCEPTION())
++ {
++ goto ruleLPAREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLPAREx; /* Prevent compiler warnings */
++ ruleLPAREx: ;
++
++}
++// $ANTLR end LPAR
++
++// Comes from: 134:7: ( ')' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start RPAR
++ *
++ * Looks to match the characters the constitute the token RPAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mRPAR(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = RPAR;
++
++
++ // SMARTPL.g:134:7: ( ')' )
++ // SMARTPL.g:134:9: ')'
++ {
++ MATCHC(')');
++ if (HASEXCEPTION())
++ {
++ goto ruleRPAREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleRPAREx; /* Prevent compiler warnings */
++ ruleRPAREx: ;
++
++}
++// $ANTLR end RPAR
++
++// Comes from: 137:7: ( ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) '-' ( '0' .. '1' ) ( '0' .. '9' ) '-' ( '0' .. '3' ) ( '0' .. '9' ) | 'today' | 'yesterday' | 'last week' | 'last month' | 'last year' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DATE
++ *
++ * Looks to match the characters the constitute the token DATE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDATE(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = DATE;
++
++
++ {
++ // SMARTPL.g:137:7: ( ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) '-' ( '0' .. '1' ) ( '0' .. '9' ) '-' ( '0' .. '3' ) ( '0' .. '9' ) | 'today' | 'yesterday' | 'last week' | 'last month' | 'last year' )
++
++ ANTLR3_UINT32 alt9;
++
++ alt9=6;
++
++ switch ( LA(1) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ alt9=1;
++ }
++ break;
++ case 't':
++ {
++ alt9=2;
++ }
++ break;
++ case 'y':
++ {
++ alt9=3;
++ }
++ break;
++ case 'l':
++ {
++ switch ( LA(2) )
++ {
++ case 'a':
++ {
++ switch ( LA(3) )
++ {
++ case 's':
++ {
++ switch ( LA(4) )
++ {
++ case 't':
++ {
++ switch ( LA(5) )
++ {
++ case ' ':
++ {
++ switch ( LA(6) )
++ {
++ case 'w':
++ {
++ alt9=4;
++ }
++ break;
++ case 'm':
++ {
++ alt9=5;
++ }
++ break;
++ case 'y':
++ {
++ alt9=6;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 8;
++
++
++ goto ruleDATEEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 7;
++
++
++ goto ruleDATEEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 6;
++
++
++ goto ruleDATEEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 5;
++
++
++ goto ruleDATEEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 4;
++
++
++ goto ruleDATEEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 0;
++
++
++ goto ruleDATEEx;
++ }
++
++ switch (alt9)
++ {
++ case 1:
++ // SMARTPL.g:137:9: ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) ( '0' .. '9' ) '-' ( '0' .. '1' ) ( '0' .. '9' ) '-' ( '0' .. '3' ) ( '0' .. '9' )
++ {
++ // SMARTPL.g:137:9: ( '0' .. '9' )
++ // SMARTPL.g:137:10: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ // SMARTPL.g:137:19: ( '0' .. '9' )
++ // SMARTPL.g:137:20: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ // SMARTPL.g:137:29: ( '0' .. '9' )
++ // SMARTPL.g:137:30: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ // SMARTPL.g:137:39: ( '0' .. '9' )
++ // SMARTPL.g:137:40: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ MATCHC('-');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ // SMARTPL.g:137:52: ( '0' .. '1' )
++ // SMARTPL.g:137:53: '0' .. '1'
++ {
++ MATCHRANGE('0', '1');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ // SMARTPL.g:137:62: ( '0' .. '9' )
++ // SMARTPL.g:137:63: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ MATCHC('-');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ // SMARTPL.g:137:75: ( '0' .. '3' )
++ // SMARTPL.g:137:76: '0' .. '3'
++ {
++ MATCHRANGE('0', '3');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++ // SMARTPL.g:137:85: ( '0' .. '9' )
++ // SMARTPL.g:137:86: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:138:6: 'today'
++ {
++ MATCHS(lit_31);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:139:6: 'yesterday'
++ {
++ MATCHS(lit_32);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:140:6: 'last week'
++ {
++ MATCHS(lit_33);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++
++ }
++ break;
++ case 5:
++ // SMARTPL.g:141:6: 'last month'
++ {
++ MATCHS(lit_34);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++
++ }
++ break;
++ case 6:
++ // SMARTPL.g:142:6: 'last year'
++ {
++ MATCHS(lit_35);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDATEEx; /* Prevent compiler warnings */
++ ruleDATEEx: ;
++
++}
++// $ANTLR end DATE
++
++// Comes from: 145:13: ( 'days' | 'weeks' | 'months' | 'years' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DATINTERVAL
++ *
++ * Looks to match the characters the constitute the token DATINTERVAL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDATINTERVAL(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = DATINTERVAL;
++
++
++ {
++ // SMARTPL.g:145:13: ( 'days' | 'weeks' | 'months' | 'years' )
++
++ ANTLR3_UINT32 alt10;
++
++ alt10=4;
++
++ switch ( LA(1) )
++ {
++ case 'd':
++ {
++ alt10=1;
++ }
++ break;
++ case 'w':
++ {
++ alt10=2;
++ }
++ break;
++ case 'm':
++ {
++ alt10=3;
++ }
++ break;
++ case 'y':
++ {
++ alt10=4;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 10;
++ EXCEPTION->state = 0;
++
++
++ goto ruleDATINTERVALEx;
++ }
++
++ switch (alt10)
++ {
++ case 1:
++ // SMARTPL.g:145:15: 'days'
++ {
++ MATCHS(lit_36);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATINTERVALEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:146:6: 'weeks'
++ {
++ MATCHS(lit_37);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATINTERVALEx;
++ }
++
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:147:6: 'months'
++ {
++ MATCHS(lit_38);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATINTERVALEx;
++ }
++
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:148:6: 'years'
++ {
++ MATCHS(lit_39);
++ if (HASEXCEPTION())
++ {
++ goto ruleDATINTERVALEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDATINTERVALEx; /* Prevent compiler warnings */
++ ruleDATINTERVALEx: ;
++
++}
++// $ANTLR end DATINTERVAL
++
++// Comes from: 151:10: ( 'music' | 'movie' | 'podcast' | 'audiobook' | 'tvshow' | 'file' | 'url' | 'spotify' | 'pipe' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start ENUMVAL
++ *
++ * Looks to match the characters the constitute the token ENUMVAL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mENUMVAL(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = ENUMVAL;
++
++
++ {
++ // SMARTPL.g:151:10: ( 'music' | 'movie' | 'podcast' | 'audiobook' | 'tvshow' | 'file' | 'url' | 'spotify' | 'pipe' )
++
++ ANTLR3_UINT32 alt11;
++
++ alt11=9;
++
++ switch ( LA(1) )
++ {
++ case 'm':
++ {
++ switch ( LA(2) )
++ {
++ case 'u':
++ {
++ alt11=1;
++ }
++ break;
++ case 'o':
++ {
++ alt11=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 11;
++ EXCEPTION->state = 1;
++
++
++ goto ruleENUMVALEx;
++ }
++
++ }
++ break;
++ case 'p':
++ {
++ switch ( LA(2) )
++ {
++ case 'o':
++ {
++ alt11=3;
++ }
++ break;
++ case 'i':
++ {
++ alt11=9;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 11;
++ EXCEPTION->state = 2;
++
++
++ goto ruleENUMVALEx;
++ }
++
++ }
++ break;
++ case 'a':
++ {
++ alt11=4;
++ }
++ break;
++ case 't':
++ {
++ alt11=5;
++ }
++ break;
++ case 'f':
++ {
++ alt11=6;
++ }
++ break;
++ case 'u':
++ {
++ alt11=7;
++ }
++ break;
++ case 's':
++ {
++ alt11=8;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 11;
++ EXCEPTION->state = 0;
++
++
++ goto ruleENUMVALEx;
++ }
++
++ switch (alt11)
++ {
++ case 1:
++ // SMARTPL.g:151:12: 'music'
++ {
++ MATCHS(lit_40);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:152:6: 'movie'
++ {
++ MATCHS(lit_41);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:153:6: 'podcast'
++ {
++ MATCHS(lit_42);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:154:6: 'audiobook'
++ {
++ MATCHS(lit_43);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 5:
++ // SMARTPL.g:155:6: 'tvshow'
++ {
++ MATCHS(lit_44);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 6:
++ // SMARTPL.g:156:6: 'file'
++ {
++ MATCHS(lit_45);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 7:
++ // SMARTPL.g:157:6: 'url'
++ {
++ MATCHS(lit_46);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 8:
++ // SMARTPL.g:158:6: 'spotify'
++ {
++ MATCHS(lit_47);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++ case 9:
++ // SMARTPL.g:159:6: 'pipe'
++ {
++ MATCHS(lit_48);
++ if (HASEXCEPTION())
++ {
++ goto ruleENUMVALEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleENUMVALEx; /* Prevent compiler warnings */
++ ruleENUMVALEx: ;
++
++}
++// $ANTLR end ENUMVAL
++
++// Comes from: 162:7: ( '\"' (~ ( '\"' ) )+ '\"' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start STR
++ *
++ * Looks to match the characters the constitute the token STR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mSTR(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = STR;
++
++
++ // SMARTPL.g:162:7: ( '\"' (~ ( '\"' ) )+ '\"' )
++ // SMARTPL.g:162:9: '\"' (~ ( '\"' ) )+ '\"'
++ {
++ MATCHC('"');
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ // SMARTPL.g:162:13: (~ ( '\"' ) )+
++ {
++ int cnt12=0;
++
++ for (;;)
++ {
++ int alt12=2;
++ {
++ /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
++ */
++ int LA12_0 = LA(1);
++ if ( (((LA12_0 >= 0x0000) && (LA12_0 <= '!')) || ((LA12_0 >= '#') && (LA12_0 <= 0xFFFF))) )
++ {
++ alt12=1;
++ }
++
++ }
++ switch (alt12)
++ {
++ case 1:
++ // SMARTPL.g:162:13: ~ ( '\"' )
++ {
++ if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleSTREx;
++ }
++
++
++ }
++ break;
++
++ default:
++
++ if ( cnt12 >= 1 )
++ {
++ goto loop12;
++ }
++ /* mismatchedSetEx()
++ */
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
++
++
++ goto ruleSTREx;
++ }
++ cnt12++;
++ }
++ loop12: ; /* Jump to here if this rule does not match */
++ }
++ MATCHC('"');
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleSTREx; /* Prevent compiler warnings */
++ ruleSTREx: ;
++
++}
++// $ANTLR end STR
++
++// Comes from: 165:7: ( ( '0' .. '9' )+ )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start INT
++ *
++ * Looks to match the characters the constitute the token INT
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mINT(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = INT;
++
++
++ // SMARTPL.g:165:7: ( ( '0' .. '9' )+ )
++ // SMARTPL.g:165:9: ( '0' .. '9' )+
++ {
++ // SMARTPL.g:165:9: ( '0' .. '9' )+
++ {
++ int cnt13=0;
++
++ for (;;)
++ {
++ int alt13=2;
++ switch ( LA(1) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ alt13=1;
++ }
++ break;
++
++ }
++
++ switch (alt13)
++ {
++ case 1:
++ // SMARTPL.g:165:10: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleINTEx;
++ }
++
++
++ }
++ break;
++
++ default:
++
++ if ( cnt13 >= 1 )
++ {
++ goto loop13;
++ }
++ /* mismatchedSetEx()
++ */
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
++
++
++ goto ruleINTEx;
++ }
++ cnt13++;
++ }
++ loop13: ; /* Jump to here if this rule does not match */
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleINTEx; /* Prevent compiler warnings */
++ ruleINTEx: ;
++
++}
++// $ANTLR end INT
++
++// Comes from: 168:12: ( ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' ) )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start WHITESPACE
++ *
++ * Looks to match the characters the constitute the token WHITESPACE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mWHITESPACE(pSMARTPLLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = WHITESPACE;
++
++
++ // SMARTPL.g:168:12: ( ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' ) )
++ // SMARTPL.g:168:14: ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )
++ {
++ if ( ((LA(1) >= '\t') && (LA(1) <= '\n')) || ((LA(1) >= '\f') && (LA(1) <= '\r')) || LA(1) == ' ' )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleWHITESPACEEx;
++ }
++
++ {
++ LEXSTATE->channel = HIDDEN;
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleWHITESPACEEx; /* Prevent compiler warnings */
++ ruleWHITESPACEEx: ;
++
++}
++// $ANTLR end WHITESPACE
++
++/** This is the entry point in to the lexer from an object that
++ * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
++ */
++static void
++mTokens(pSMARTPLLexer ctx)
++{
++ {
++ // SMARTPL.g:1:8: ( T__30 | T__31 | STRTAG | INTTAG | DATETAG | ENUMTAG | INCLUDES | IS | INTBOOL | AFTER | BEFORE | AGO | AND | OR | NOT | LPAR | RPAR | DATE | DATINTERVAL | ENUMVAL | STR | INT | WHITESPACE )
++
++ ANTLR3_UINT32 alt14;
++
++ alt14=23;
++
++ switch ( LA(1) )
++ {
++ case '{':
++ {
++ alt14=1;
++ }
++ break;
++ case '}':
++ {
++ alt14=2;
++ }
++ break;
++ case 'a':
++ {
++ switch ( LA(2) )
++ {
++ case 'l':
++ case 'r':
++ {
++ alt14=3;
++ }
++ break;
++ case 'f':
++ {
++ alt14=10;
++ }
++ break;
++ case 'g':
++ {
++ alt14=12;
++ }
++ break;
++ case 'n':
++ {
++ alt14=13;
++ }
++ break;
++ case 'u':
++ {
++ alt14=20;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 3;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 't':
++ {
++ switch ( LA(2) )
++ {
++ case 'i':
++ {
++ switch ( LA(3) )
++ {
++ case 't':
++ {
++ alt14=3;
++ }
++ break;
++ case 'm':
++ {
++ alt14=5;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 28;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'y':
++ {
++ alt14=3;
++ }
++ break;
++ case 'o':
++ {
++ alt14=18;
++ }
++ break;
++ case 'v':
++ {
++ alt14=20;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 4;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'g':
++ {
++ alt14=3;
++ }
++ break;
++ case 'c':
++ {
++ switch ( LA(2) )
++ {
++ case 'o':
++ {
++ switch ( LA(3) )
++ {
++ case 'm':
++ {
++ switch ( LA(4) )
++ {
++ case 'p':
++ {
++ switch ( LA(5) )
++ {
++ case 'o':
++ {
++ alt14=3;
++ }
++ break;
++ case 'i':
++ {
++ alt14=4;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 42;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 39;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 29;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 6;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'p':
++ {
++ switch ( LA(2) )
++ {
++ case 'a':
++ {
++ alt14=3;
++ }
++ break;
++ case 'l':
++ {
++ alt14=4;
++ }
++ break;
++ case 'i':
++ case 'o':
++ {
++ alt14=20;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 7;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'r':
++ {
++ alt14=4;
++ }
++ break;
++ case 'y':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ switch ( LA(3) )
++ {
++ case 'a':
++ {
++ switch ( LA(4) )
++ {
++ case 'r':
++ {
++ switch ( LA(5) )
++ {
++ case 's':
++ {
++ alt14=19;
++ }
++ break;
++
++ default:
++ alt14=4;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 40;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 's':
++ {
++ alt14=18;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 30;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 9;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'd':
++ {
++ switch ( LA(2) )
++ {
++ case 'a':
++ {
++ switch ( LA(3) )
++ {
++ case 't':
++ {
++ alt14=6;
++ }
++ break;
++ case 'y':
++ {
++ alt14=19;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 31;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 10;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'm':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ alt14=6;
++ }
++ break;
++ case 'o':
++ {
++ switch ( LA(3) )
++ {
++ case 'n':
++ {
++ alt14=19;
++ }
++ break;
++ case 'v':
++ {
++ alt14=20;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 33;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'u':
++ {
++ alt14=20;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 11;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'i':
++ {
++ switch ( LA(2) )
++ {
++ case 'n':
++ {
++ alt14=7;
++ }
++ break;
++ case 's':
++ {
++ alt14=8;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 12;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case '<':
++ case '=':
++ case '>':
++ {
++ alt14=9;
++ }
++ break;
++ case 'b':
++ {
++ alt14=11;
++ }
++ break;
++ case 'A':
++ {
++ alt14=13;
++ }
++ break;
++ case 'O':
++ case 'o':
++ {
++ alt14=14;
++ }
++ break;
++ case 'N':
++ case 'n':
++ {
++ alt14=15;
++ }
++ break;
++ case '(':
++ {
++ alt14=16;
++ }
++ break;
++ case ')':
++ {
++ alt14=17;
++ }
++ break;
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(2) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(3) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(4) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(5) )
++ {
++ case '-':
++ {
++ alt14=18;
++ }
++ break;
++
++ default:
++ alt14=22;}
++
++ }
++ break;
++
++ default:
++ alt14=22;}
++
++ }
++ break;
++
++ default:
++ alt14=22;}
++
++ }
++ break;
++
++ default:
++ alt14=22;}
++
++ }
++ break;
++ case 'l':
++ {
++ alt14=18;
++ }
++ break;
++ case 'w':
++ {
++ alt14=19;
++ }
++ break;
++ case 'f':
++ case 's':
++ case 'u':
++ {
++ alt14=20;
++ }
++ break;
++ case '"':
++ {
++ alt14=21;
++ }
++ break;
++ case '\t':
++ case '\n':
++ case '\f':
++ case '\r':
++ case ' ':
++ {
++ alt14=23;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 14;
++ EXCEPTION->state = 0;
++
++
++ goto ruleTokensEx;
++ }
++
++ switch (alt14)
++ {
++ case 1:
++ // SMARTPL.g:1:10: T__30
++ {
++ /* 1:10: T__30 */
++ mT__30(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:1:16: T__31
++ {
++ /* 1:16: T__31 */
++ mT__31(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:1:22: STRTAG
++ {
++ /* 1:22: STRTAG */
++ mSTRTAG(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:1:29: INTTAG
++ {
++ /* 1:29: INTTAG */
++ mINTTAG(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 5:
++ // SMARTPL.g:1:36: DATETAG
++ {
++ /* 1:36: DATETAG */
++ mDATETAG(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 6:
++ // SMARTPL.g:1:44: ENUMTAG
++ {
++ /* 1:44: ENUMTAG */
++ mENUMTAG(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 7:
++ // SMARTPL.g:1:52: INCLUDES
++ {
++ /* 1:52: INCLUDES */
++ mINCLUDES(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 8:
++ // SMARTPL.g:1:61: IS
++ {
++ /* 1:61: IS */
++ mIS(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 9:
++ // SMARTPL.g:1:64: INTBOOL
++ {
++ /* 1:64: INTBOOL */
++ mINTBOOL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 10:
++ // SMARTPL.g:1:72: AFTER
++ {
++ /* 1:72: AFTER */
++ mAFTER(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 11:
++ // SMARTPL.g:1:78: BEFORE
++ {
++ /* 1:78: BEFORE */
++ mBEFORE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 12:
++ // SMARTPL.g:1:85: AGO
++ {
++ /* 1:85: AGO */
++ mAGO(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 13:
++ // SMARTPL.g:1:89: AND
++ {
++ /* 1:89: AND */
++ mAND(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 14:
++ // SMARTPL.g:1:93: OR
++ {
++ /* 1:93: OR */
++ mOR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 15:
++ // SMARTPL.g:1:96: NOT
++ {
++ /* 1:96: NOT */
++ mNOT(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 16:
++ // SMARTPL.g:1:100: LPAR
++ {
++ /* 1:100: LPAR */
++ mLPAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 17:
++ // SMARTPL.g:1:105: RPAR
++ {
++ /* 1:105: RPAR */
++ mRPAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 18:
++ // SMARTPL.g:1:110: DATE
++ {
++ /* 1:110: DATE */
++ mDATE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 19:
++ // SMARTPL.g:1:115: DATINTERVAL
++ {
++ /* 1:115: DATINTERVAL */
++ mDATINTERVAL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 20:
++ // SMARTPL.g:1:127: ENUMVAL
++ {
++ /* 1:127: ENUMVAL */
++ mENUMVAL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 21:
++ // SMARTPL.g:1:135: STR
++ {
++ /* 1:135: STR */
++ mSTR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 22:
++ // SMARTPL.g:1:139: INT
++ {
++ /* 1:139: INT */
++ mINT(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 23:
++ // SMARTPL.g:1:143: WHITESPACE
++ {
++ /* 1:143: WHITESPACE */
++ mWHITESPACE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++
++
++ goto ruleTokensEx; /* Prevent compiler warnings */
++ruleTokensEx: ;
++}
++
++/* =========================================================================
++ * Lexer matching rules end.
++ * =========================================================================
++ */
++/* End of Lexer code
++ * ================================================
++ * ================================================
++ */
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/SMARTPLLexer.h b/src/pregen/SMARTPLLexer.h
+new file mode 100644
+index 0000000..9d73721
+--- /dev/null
++++ b/src/pregen/SMARTPLLexer.h
+@@ -0,0 +1,248 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : SMARTPL.g
++ * - On : 2015-06-27 19:05:15
++ * - for the lexer : SMARTPLLexerLexer *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The lexer SMARTPLLexer has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pSMARTPLLexer, which is returned from a call to SMARTPLLexerNew().
++ *
++ * As this is a generated lexer, it is unlikely you will call it 'manually'. However
++ * the methods are provided anyway.
++ * * The methods in pSMARTPLLexer are as follows:
++ *
++ * - void pSMARTPLLexer->T__30(pSMARTPLLexer)
++ * - void pSMARTPLLexer->T__31(pSMARTPLLexer)
++ * - void pSMARTPLLexer->STRTAG(pSMARTPLLexer)
++ * - void pSMARTPLLexer->INTTAG(pSMARTPLLexer)
++ * - void pSMARTPLLexer->DATETAG(pSMARTPLLexer)
++ * - void pSMARTPLLexer->ENUMTAG(pSMARTPLLexer)
++ * - void pSMARTPLLexer->INCLUDES(pSMARTPLLexer)
++ * - void pSMARTPLLexer->IS(pSMARTPLLexer)
++ * - void pSMARTPLLexer->INTBOOL(pSMARTPLLexer)
++ * - void pSMARTPLLexer->GREATER(pSMARTPLLexer)
++ * - void pSMARTPLLexer->GREATEREQUAL(pSMARTPLLexer)
++ * - void pSMARTPLLexer->LESS(pSMARTPLLexer)
++ * - void pSMARTPLLexer->LESSEQUAL(pSMARTPLLexer)
++ * - void pSMARTPLLexer->EQUAL(pSMARTPLLexer)
++ * - void pSMARTPLLexer->AFTER(pSMARTPLLexer)
++ * - void pSMARTPLLexer->BEFORE(pSMARTPLLexer)
++ * - void pSMARTPLLexer->AGO(pSMARTPLLexer)
++ * - void pSMARTPLLexer->AND(pSMARTPLLexer)
++ * - void pSMARTPLLexer->OR(pSMARTPLLexer)
++ * - void pSMARTPLLexer->NOT(pSMARTPLLexer)
++ * - void pSMARTPLLexer->LPAR(pSMARTPLLexer)
++ * - void pSMARTPLLexer->RPAR(pSMARTPLLexer)
++ * - void pSMARTPLLexer->DATE(pSMARTPLLexer)
++ * - void pSMARTPLLexer->DATINTERVAL(pSMARTPLLexer)
++ * - void pSMARTPLLexer->ENUMVAL(pSMARTPLLexer)
++ * - void pSMARTPLLexer->STR(pSMARTPLLexer)
++ * - void pSMARTPLLexer->INT(pSMARTPLLexer)
++ * - void pSMARTPLLexer->WHITESPACE(pSMARTPLLexer)
++ * - void pSMARTPLLexer->Tokens(pSMARTPLLexer)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _SMARTPLLexer_H
++#define _SMARTPLLexer_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct SMARTPLLexer_Ctx_struct SMARTPLLexer, * pSMARTPLLexer;
++
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++
++/** Context tracking structure for SMARTPLLexer
++ */
++struct SMARTPLLexer_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_LEXER pLexer;
++
++
++ void (*mT__30) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mT__31) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mSTRTAG) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mINTTAG) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mDATETAG) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mENUMTAG) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mINCLUDES) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mIS) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mINTBOOL) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mGREATER) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mGREATEREQUAL) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mLESS) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mLESSEQUAL) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mEQUAL) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mAFTER) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mBEFORE) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mAGO) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mAND) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mOR) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mNOT) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mLPAR) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mRPAR) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mDATE) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mDATINTERVAL) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mENUMVAL) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mSTR) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mINT) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mWHITESPACE) (struct SMARTPLLexer_Ctx_struct * ctx);
++ void (*mTokens) (struct SMARTPLLexer_Ctx_struct * ctx); const char * (*getGrammarFileName)();
++ void (*free) (struct SMARTPLLexer_Ctx_struct * ctx);
++
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pSMARTPLLexer SMARTPLLexerNew (pANTLR3_INPUT_STREAM instream);
++ANTLR3_API pSMARTPLLexer SMARTPLLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the lexer will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define INTBOOL 14
++#define STRTAG 10
++#define AGO 22
++#define WHITESPACE 29
++#define GREATEREQUAL 25
++#define BEFORE 18
++#define DATETAG 16
++#define INT 15
++#define NOT 7
++#define AFTER 17
++#define AND 6
++#define EOF -1
++#define INCLUDES 11
++#define STR 4
++#define T__30 30
++#define T__31 31
++#define GREATER 24
++#define LPAR 8
++#define ENUMTAG 19
++#define IS 12
++#define ENUMVAL 20
++#define EQUAL 28
++#define OR 5
++#define LESS 26
++#define RPAR 9
++#define DATE 21
++#define LESSEQUAL 27
++#define INTTAG 13
++#define DATINTERVAL 23
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for SMARTPLLexer
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/SMARTPLParser.c b/src/pregen/SMARTPLParser.c
+new file mode 100644
+index 0000000..afe9f99
+--- /dev/null
++++ b/src/pregen/SMARTPLParser.c
+@@ -0,0 +1,1812 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : SMARTPL.g
++ * - On : 2015-06-27 19:05:15
++ * - for the parser : SMARTPLParserParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "SMARTPLParser.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pSMARTPLParser_##scope##_SCOPE
++#define SCOPE_STACK(scope) pSMARTPLParser_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pSMARTPLParser_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pSMARTPLParser_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++/* Macros for accessing things in the parser
++ */
++
++#undef PARSER
++#undef RECOGNIZER
++#undef HAVEPARSEDRULE
++#undef MEMOIZE
++#undef INPUT
++#undef STRSTREAM
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef MATCHT
++#undef MATCHANYT
++#undef FOLLOWSTACK
++#undef FOLLOWPUSH
++#undef FOLLOWPOP
++#undef PRECOVER
++#undef PREPORTERROR
++#undef LA
++#undef LT
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef PERRORRECOVERY
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef RECOVERFROMMISMATCHEDSET
++#undef RECOVERFROMMISMATCHEDELEMENT
++#undef INDEX
++#undef ADAPTOR
++#undef SEEK
++#undef RULEMEMO
++#undef DBG
++
++#define PARSER ctx->pParser
++#define RECOGNIZER PARSER->rec
++#define PSRSTATE RECOGNIZER->state
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
++#define INPUT PARSER->tstream
++#define STRSTREAM INPUT
++#define ISTREAM INPUT->istream
++#define INDEX() ISTREAM->index(INPUT->istream)
++#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION PSRSTATE->exception
++#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
++#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
++#define FOLLOWSTACK PSRSTATE->following
++#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
++#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
++#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
++#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
++#define LA(n) INPUT->istream->_LA(ISTREAM, n)
++#define LT(n) INPUT->_LT(INPUT, n)
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define CONSUME() ISTREAM->consume(ISTREAM)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define PERRORRECOVERY PSRSTATE->errorRecovery
++#define FAILEDFLAG PSRSTATE->failed
++#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
++#define BACKTRACKING PSRSTATE->backtracking
++#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
++#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
++#define ADAPTOR ctx->adaptor
++#define RULEMEMO PSRSTATE->ruleMemo
++#define DBG RECOGNIZER->debugger
++
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++
++/** \brief Table of all token names in symbolic order, mainly used for
++ * error reporting.
++ */
++pANTLR3_UINT8 SMARTPLParserTokenNames[28+4]
++ = {
++ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
++ (pANTLR3_UINT8) "<EOR>",
++ (pANTLR3_UINT8) "<DOWN>",
++ (pANTLR3_UINT8) "<UP>",
++ (pANTLR3_UINT8) "STR",
++ (pANTLR3_UINT8) "OR",
++ (pANTLR3_UINT8) "AND",
++ (pANTLR3_UINT8) "NOT",
++ (pANTLR3_UINT8) "LPAR",
++ (pANTLR3_UINT8) "RPAR",
++ (pANTLR3_UINT8) "STRTAG",
++ (pANTLR3_UINT8) "INCLUDES",
++ (pANTLR3_UINT8) "IS",
++ (pANTLR3_UINT8) "INTTAG",
++ (pANTLR3_UINT8) "INTBOOL",
++ (pANTLR3_UINT8) "INT",
++ (pANTLR3_UINT8) "DATETAG",
++ (pANTLR3_UINT8) "AFTER",
++ (pANTLR3_UINT8) "BEFORE",
++ (pANTLR3_UINT8) "ENUMTAG",
++ (pANTLR3_UINT8) "ENUMVAL",
++ (pANTLR3_UINT8) "DATE",
++ (pANTLR3_UINT8) "AGO",
++ (pANTLR3_UINT8) "DATINTERVAL",
++ (pANTLR3_UINT8) "GREATER",
++ (pANTLR3_UINT8) "GREATEREQUAL",
++ (pANTLR3_UINT8) "LESS",
++ (pANTLR3_UINT8) "LESSEQUAL",
++ (pANTLR3_UINT8) "EQUAL",
++ (pANTLR3_UINT8) "WHITESPACE",
++ (pANTLR3_UINT8) "'{'",
++ (pANTLR3_UINT8) "'}'"
++ };
++
++
++
++// Forward declare the locally static matching functions we have generated.
++//
++static SMARTPLParser_playlist_return playlist (pSMARTPLParser ctx);
++static SMARTPLParser_expression_return expression (pSMARTPLParser ctx);
++static SMARTPLParser_aexpr_return aexpr (pSMARTPLParser ctx);
++static SMARTPLParser_nexpr_return nexpr (pSMARTPLParser ctx);
++static SMARTPLParser_crit_return crit (pSMARTPLParser ctx);
++static SMARTPLParser_dateval_return dateval (pSMARTPLParser ctx);
++static SMARTPLParser_interval_return interval (pSMARTPLParser ctx);
++static void SMARTPLParserFree(pSMARTPLParser ctx);
++/* For use in tree output where we are accumulating rule labels via label += ruleRef
++ * we need a function that knows how to free a return scope when the list is destroyed.
++ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
++ */
++static void ANTLR3_CDECL freeScope(void * scope)
++{
++ ANTLR3_FREE(scope);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "SMARTPL.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++/** \brief Create a new SMARTPLParser parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pSMARTPLParser
++SMARTPLParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
++{
++ // See if we can create a new parser with the standard constructor
++ //
++ return SMARTPLParserNewSSD(instream, NULL);
++}
++
++/** \brief Create a new SMARTPLParser parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pSMARTPLParser
++SMARTPLParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pSMARTPLParser ctx; /* Context structure we will build and return */
++
++ ctx = (pSMARTPLParser) ANTLR3_CALLOC(1, sizeof(SMARTPLParser));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for parser context
++ //
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * the base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 parser function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in SMARTPLParser.h here, in order that you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base parser/recognizer, using the supplied token stream
++ */
++ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
++ /* Install the implementation of our SMARTPLParser interface
++ */
++ ctx->playlist = playlist;
++ ctx->expression = expression;
++ ctx->aexpr = aexpr;
++ ctx->nexpr = nexpr;
++ ctx->crit = crit;
++ ctx->dateval = dateval;
++ ctx->interval = interval;
++ ctx->free = SMARTPLParserFree;
++ ctx->getGrammarFileName = getGrammarFileName;
++
++ /* Install the scope pushing methods.
++ */
++ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
++ ctx->vectors = antlr3VectorFactoryNew(0);
++
++
++
++ /* Install the token table
++ */
++ PSRSTATE->tokenNames = SMARTPLParserTokenNames;
++
++
++ /* Return the newly built parser to the caller
++ */
++ return ctx;
++}
++
++/** Free the parser resources
++ */
++ static void
++ SMARTPLParserFree(pSMARTPLParser ctx)
++ {
++ /* Free any scope memory
++ */
++
++ ctx->vectors->close(ctx->vectors);
++ /* We created the adaptor so we must free it
++ */
++ ADAPTOR->free(ADAPTOR);
++ // Free this parser
++ //
++ ctx->pParser->free(ctx->pParser);
++ ANTLR3_FREE(ctx);
++
++ /* Everything is released, so we can return
++ */
++ return;
++ }
++
++/** Return token names used by this parser
++ *
++ * The returned pointer is used as an index into the token names table (using the token
++ * number as the index).
++ *
++ * \return Pointer to first char * in the table.
++ */
++static pANTLR3_UINT8 *getTokenNames()
++{
++ return SMARTPLParserTokenNames;
++}
++
++
++/* Declare the bitsets
++ */
++
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_playlist42 */
++static ANTLR3_BITWORD FOLLOW_STR_in_playlist42_bits[] = { ANTLR3_UINT64_LIT(0x0000000040000000) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_playlist42 = { FOLLOW_STR_in_playlist42_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_30_in_playlist44 */
++static ANTLR3_BITWORD FOLLOW_30_in_playlist44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
++static ANTLR3_BITSET_LIST FOLLOW_30_in_playlist44 = { FOLLOW_30_in_playlist44_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_playlist46 */
++static ANTLR3_BITWORD FOLLOW_expression_in_playlist46_bits[] = { ANTLR3_UINT64_LIT(0x0000000080000000) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_playlist46 = { FOLLOW_expression_in_playlist46_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_31_in_playlist48 */
++static ANTLR3_BITWORD FOLLOW_31_in_playlist48_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) };
++static ANTLR3_BITSET_LIST FOLLOW_31_in_playlist48 = { FOLLOW_31_in_playlist48_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_playlist50 */
++static ANTLR3_BITWORD FOLLOW_EOF_in_playlist50_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_EOF_in_playlist50 = { FOLLOW_EOF_in_playlist50_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expression62 */
++static ANTLR3_BITWORD FOLLOW_aexpr_in_expression62_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
++static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expression62 = { FOLLOW_aexpr_in_expression62_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expression65 */
++static ANTLR3_BITWORD FOLLOW_OR_in_expression65_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
++static ANTLR3_BITSET_LIST FOLLOW_OR_in_expression65 = { FOLLOW_OR_in_expression65_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expression68 */
++static ANTLR3_BITWORD FOLLOW_aexpr_in_expression68_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
++static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expression68 = { FOLLOW_aexpr_in_expression68_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_nexpr_in_aexpr83 */
++static ANTLR3_BITWORD FOLLOW_nexpr_in_aexpr83_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
++static ANTLR3_BITSET_LIST FOLLOW_nexpr_in_aexpr83 = { FOLLOW_nexpr_in_aexpr83_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_aexpr86 */
++static ANTLR3_BITWORD FOLLOW_AND_in_aexpr86_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
++static ANTLR3_BITSET_LIST FOLLOW_AND_in_aexpr86 = { FOLLOW_AND_in_aexpr86_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_nexpr_in_aexpr89 */
++static ANTLR3_BITWORD FOLLOW_nexpr_in_aexpr89_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
++static ANTLR3_BITSET_LIST FOLLOW_nexpr_in_aexpr89 = { FOLLOW_nexpr_in_aexpr89_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_nexpr104 */
++static ANTLR3_BITWORD FOLLOW_NOT_in_nexpr104_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
++static ANTLR3_BITSET_LIST FOLLOW_NOT_in_nexpr104 = { FOLLOW_NOT_in_nexpr104_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_nexpr107 */
++static ANTLR3_BITWORD FOLLOW_crit_in_nexpr107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_crit_in_nexpr107 = { FOLLOW_crit_in_nexpr107_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_nexpr114 */
++static ANTLR3_BITWORD FOLLOW_crit_in_nexpr114_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_crit_in_nexpr114 = { FOLLOW_crit_in_nexpr114_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit127 */
++static ANTLR3_BITWORD FOLLOW_LPAR_in_crit127_bits[] = { ANTLR3_UINT64_LIT(0x0000000000092580) };
++static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit127 = { FOLLOW_LPAR_in_crit127_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expression_in_crit129 */
++static ANTLR3_BITWORD FOLLOW_expression_in_crit129_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000200) };
++static ANTLR3_BITSET_LIST FOLLOW_expression_in_crit129 = { FOLLOW_expression_in_crit129_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit131 */
++static ANTLR3_BITWORD FOLLOW_RPAR_in_crit131_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit131 = { FOLLOW_RPAR_in_crit131_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRTAG_in_crit142 */
++static ANTLR3_BITWORD FOLLOW_STRTAG_in_crit142_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001800) };
++static ANTLR3_BITSET_LIST FOLLOW_STRTAG_in_crit142 = { FOLLOW_STRTAG_in_crit142_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_crit144 */
++static ANTLR3_BITWORD FOLLOW_set_in_crit144_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_crit144 = { FOLLOW_set_in_crit144_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_crit150 */
++static ANTLR3_BITWORD FOLLOW_STR_in_crit150_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_crit150 = { FOLLOW_STR_in_crit150_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTTAG_in_crit157 */
++static ANTLR3_BITWORD FOLLOW_INTTAG_in_crit157_bits[] = { ANTLR3_UINT64_LIT(0x0000000000004000) };
++static ANTLR3_BITSET_LIST FOLLOW_INTTAG_in_crit157 = { FOLLOW_INTTAG_in_crit157_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INTBOOL_in_crit159 */
++static ANTLR3_BITWORD FOLLOW_INTBOOL_in_crit159_bits[] = { ANTLR3_UINT64_LIT(0x0000000000008000) };
++static ANTLR3_BITSET_LIST FOLLOW_INTBOOL_in_crit159 = { FOLLOW_INTBOOL_in_crit159_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_crit161 */
++static ANTLR3_BITWORD FOLLOW_INT_in_crit161_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_crit161 = { FOLLOW_INT_in_crit161_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATETAG_in_crit168 */
++static ANTLR3_BITWORD FOLLOW_DATETAG_in_crit168_bits[] = { ANTLR3_UINT64_LIT(0x0000000000060000) };
++static ANTLR3_BITSET_LIST FOLLOW_DATETAG_in_crit168 = { FOLLOW_DATETAG_in_crit168_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_crit170 */
++static ANTLR3_BITWORD FOLLOW_set_in_crit170_bits[] = { ANTLR3_UINT64_LIT(0x0000000000208000) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_crit170 = { FOLLOW_set_in_crit170_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateval_in_crit176 */
++static ANTLR3_BITWORD FOLLOW_dateval_in_crit176_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_dateval_in_crit176 = { FOLLOW_dateval_in_crit176_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMTAG_in_crit183 */
++static ANTLR3_BITWORD FOLLOW_ENUMTAG_in_crit183_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001000) };
++static ANTLR3_BITSET_LIST FOLLOW_ENUMTAG_in_crit183 = { FOLLOW_ENUMTAG_in_crit183_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_IS_in_crit185 */
++static ANTLR3_BITWORD FOLLOW_IS_in_crit185_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) };
++static ANTLR3_BITSET_LIST FOLLOW_IS_in_crit185 = { FOLLOW_IS_in_crit185_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENUMVAL_in_crit187 */
++static ANTLR3_BITWORD FOLLOW_ENUMVAL_in_crit187_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_ENUMVAL_in_crit187 = { FOLLOW_ENUMVAL_in_crit187_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval200 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateval200_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval200 = { FOLLOW_DATE_in_dateval200_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval207 */
++static ANTLR3_BITWORD FOLLOW_interval_in_dateval207_bits[] = { ANTLR3_UINT64_LIT(0x0000000000040000) };
++static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval207 = { FOLLOW_interval_in_dateval207_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateval209 */
++static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateval209_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
++static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateval209 = { FOLLOW_BEFORE_in_dateval209_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval211 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateval211_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval211 = { FOLLOW_DATE_in_dateval211_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval218 */
++static ANTLR3_BITWORD FOLLOW_interval_in_dateval218_bits[] = { ANTLR3_UINT64_LIT(0x0000000000020000) };
++static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval218 = { FOLLOW_interval_in_dateval218_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateval220 */
++static ANTLR3_BITWORD FOLLOW_AFTER_in_dateval220_bits[] = { ANTLR3_UINT64_LIT(0x0000000000200000) };
++static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateval220 = { FOLLOW_AFTER_in_dateval220_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateval222 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateval222_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateval222 = { FOLLOW_DATE_in_dateval222_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_interval_in_dateval229 */
++static ANTLR3_BITWORD FOLLOW_interval_in_dateval229_bits[] = { ANTLR3_UINT64_LIT(0x0000000000400000) };
++static ANTLR3_BITSET_LIST FOLLOW_interval_in_dateval229 = { FOLLOW_interval_in_dateval229_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AGO_in_dateval231 */
++static ANTLR3_BITWORD FOLLOW_AGO_in_dateval231_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_AGO_in_dateval231 = { FOLLOW_AGO_in_dateval231_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_interval243 */
++static ANTLR3_BITWORD FOLLOW_INT_in_interval243_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_interval243 = { FOLLOW_INT_in_interval243_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATINTERVAL_in_interval245 */
++static ANTLR3_BITWORD FOLLOW_DATINTERVAL_in_interval245_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATINTERVAL_in_interval245 = { FOLLOW_DATINTERVAL_in_interval245_bits, 1 };
++
++
++
++
++/* ==============================================
++ * Parsing rules
++ */
++/**
++ * $ANTLR start playlist
++ * SMARTPL.g:27:1: playlist : STR '{' expression '}' EOF ;
++ */
++static SMARTPLParser_playlist_return
++playlist(pSMARTPLParser ctx)
++{
++ SMARTPLParser_playlist_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN STR1;
++ pANTLR3_COMMON_TOKEN char_literal2;
++ pANTLR3_COMMON_TOKEN char_literal4;
++ pANTLR3_COMMON_TOKEN EOF5;
++ SMARTPLParser_expression_return expression3;
++ #undef RETURN_TYPE_expression3
++ #define RETURN_TYPE_expression3 SMARTPLParser_expression_return
++
++ pANTLR3_BASE_TREE STR1_tree;
++ pANTLR3_BASE_TREE char_literal2_tree;
++ pANTLR3_BASE_TREE char_literal4_tree;
++ pANTLR3_BASE_TREE EOF5_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ STR1 = NULL;
++ char_literal2 = NULL;
++ char_literal4 = NULL;
++ EOF5 = NULL;
++ expression3.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ STR1_tree = NULL;
++ char_literal2_tree = NULL;
++ char_literal4_tree = NULL;
++ EOF5_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // SMARTPL.g:27:10: ( STR '{' expression '}' EOF )
++ // SMARTPL.g:27:12: STR '{' expression '}' EOF
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ STR1 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_playlist42);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ STR1_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STR1));
++ ADAPTOR->addChild(ADAPTOR, root_0, STR1_tree);
++
++ char_literal2 = (pANTLR3_COMMON_TOKEN) MATCHT(30, &FOLLOW_30_in_playlist44);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ char_literal2_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal2));
++ ADAPTOR->addChild(ADAPTOR, root_0, char_literal2_tree);
++
++ FOLLOWPUSH(FOLLOW_expression_in_playlist46);
++ expression3=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, expression3.tree);
++ char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(31, &FOLLOW_31_in_playlist48);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ char_literal4_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal4));
++ ADAPTOR->addChild(ADAPTOR, root_0, char_literal4_tree);
++
++ EOF5 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_playlist50);
++ if (HASEXCEPTION())
++ {
++ goto ruleplaylistEx;
++ }
++
++ EOF5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EOF5));
++ ADAPTOR->addChild(ADAPTOR, root_0, EOF5_tree);
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleplaylistEx; /* Prevent compiler warnings */
++ ruleplaylistEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end playlist */
++
++/**
++ * $ANTLR start expression
++ * SMARTPL.g:30:1: expression : aexpr ( OR aexpr )* ;
++ */
++static SMARTPLParser_expression_return
++expression(pSMARTPLParser ctx)
++{
++ SMARTPLParser_expression_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN OR7;
++ SMARTPLParser_aexpr_return aexpr6;
++ #undef RETURN_TYPE_aexpr6
++ #define RETURN_TYPE_aexpr6 SMARTPLParser_aexpr_return
++
++ SMARTPLParser_aexpr_return aexpr8;
++ #undef RETURN_TYPE_aexpr8
++ #define RETURN_TYPE_aexpr8 SMARTPLParser_aexpr_return
++
++ pANTLR3_BASE_TREE OR7_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ OR7 = NULL;
++ aexpr6.tree = NULL;
++
++ aexpr8.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ OR7_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // SMARTPL.g:30:12: ( aexpr ( OR aexpr )* )
++ // SMARTPL.g:30:14: aexpr ( OR aexpr )*
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_aexpr_in_expression62);
++ aexpr6=aexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree);
++
++ // SMARTPL.g:30:20: ( OR aexpr )*
++
++ for (;;)
++ {
++ int alt1=2;
++ switch ( LA(1) )
++ {
++ case OR:
++ {
++ alt1=1;
++ }
++ break;
++
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // SMARTPL.g:30:21: OR aexpr
++ {
++ OR7 = (pANTLR3_COMMON_TOKEN) MATCHT(OR, &FOLLOW_OR_in_expression65);
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ OR7_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OR7));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OR7_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_aexpr_in_expression68);
++ aexpr8=aexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexpressionEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, aexpr8.tree);
++
++ }
++ break;
++
++ default:
++ goto loop1; /* break out of the loop */
++ break;
++ }
++ }
++ loop1: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleexpressionEx; /* Prevent compiler warnings */
++ ruleexpressionEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end expression */
++
++/**
++ * $ANTLR start aexpr
++ * SMARTPL.g:33:1: aexpr : nexpr ( AND nexpr )* ;
++ */
++static SMARTPLParser_aexpr_return
++aexpr(pSMARTPLParser ctx)
++{
++ SMARTPLParser_aexpr_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN AND10;
++ SMARTPLParser_nexpr_return nexpr9;
++ #undef RETURN_TYPE_nexpr9
++ #define RETURN_TYPE_nexpr9 SMARTPLParser_nexpr_return
++
++ SMARTPLParser_nexpr_return nexpr11;
++ #undef RETURN_TYPE_nexpr11
++ #define RETURN_TYPE_nexpr11 SMARTPLParser_nexpr_return
++
++ pANTLR3_BASE_TREE AND10_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ AND10 = NULL;
++ nexpr9.tree = NULL;
++
++ nexpr11.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ AND10_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // SMARTPL.g:33:8: ( nexpr ( AND nexpr )* )
++ // SMARTPL.g:33:10: nexpr ( AND nexpr )*
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_nexpr_in_aexpr83);
++ nexpr9=nexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, nexpr9.tree);
++
++ // SMARTPL.g:33:16: ( AND nexpr )*
++
++ for (;;)
++ {
++ int alt2=2;
++ switch ( LA(1) )
++ {
++ case AND:
++ {
++ alt2=1;
++ }
++ break;
++
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // SMARTPL.g:33:17: AND nexpr
++ {
++ AND10 = (pANTLR3_COMMON_TOKEN) MATCHT(AND, &FOLLOW_AND_in_aexpr86);
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ AND10_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AND10));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, AND10_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_nexpr_in_aexpr89);
++ nexpr11=nexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, nexpr11.tree);
++
++ }
++ break;
++
++ default:
++ goto loop2; /* break out of the loop */
++ break;
++ }
++ }
++ loop2: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleaexprEx; /* Prevent compiler warnings */
++ ruleaexprEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end aexpr */
++
++/**
++ * $ANTLR start nexpr
++ * SMARTPL.g:36:1: nexpr : ( NOT crit | crit );
++ */
++static SMARTPLParser_nexpr_return
++nexpr(pSMARTPLParser ctx)
++{
++ SMARTPLParser_nexpr_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN NOT12;
++ SMARTPLParser_crit_return crit13;
++ #undef RETURN_TYPE_crit13
++ #define RETURN_TYPE_crit13 SMARTPLParser_crit_return
++
++ SMARTPLParser_crit_return crit14;
++ #undef RETURN_TYPE_crit14
++ #define RETURN_TYPE_crit14 SMARTPLParser_crit_return
++
++ pANTLR3_BASE_TREE NOT12_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ NOT12 = NULL;
++ crit13.tree = NULL;
++
++ crit14.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ NOT12_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ {
++ // SMARTPL.g:36:8: ( NOT crit | crit )
++
++ ANTLR3_UINT32 alt3;
++
++ alt3=2;
++
++ switch ( LA(1) )
++ {
++ case NOT:
++ {
++ alt3=1;
++ }
++ break;
++ case LPAR:
++ case STRTAG:
++ case INTTAG:
++ case DATETAG:
++ case ENUMTAG:
++ {
++ alt3=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 0;
++
++
++ goto rulenexprEx;
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // SMARTPL.g:36:10: NOT crit
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ NOT12 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_nexpr104);
++ if (HASEXCEPTION())
++ {
++ goto rulenexprEx;
++ }
++
++ NOT12_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NOT12));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, NOT12_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_crit_in_nexpr107);
++ crit13=crit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulenexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, crit13.tree);
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:37:6: crit
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_crit_in_nexpr114);
++ crit14=crit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulenexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, crit14.tree);
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulenexprEx; /* Prevent compiler warnings */
++ rulenexprEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end nexpr */
++
++/**
++ * $ANTLR start crit
++ * SMARTPL.g:40:1: crit : ( LPAR expression RPAR -> expression | STRTAG ( INCLUDES | IS ) STR | INTTAG INTBOOL INT | DATETAG ( AFTER | BEFORE ) dateval | ENUMTAG IS ENUMVAL );
++ */
++static SMARTPLParser_crit_return
++crit(pSMARTPLParser ctx)
++{
++ SMARTPLParser_crit_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN LPAR15;
++ pANTLR3_COMMON_TOKEN RPAR17;
++ pANTLR3_COMMON_TOKEN STRTAG18;
++ pANTLR3_COMMON_TOKEN set19;
++ pANTLR3_COMMON_TOKEN STR20;
++ pANTLR3_COMMON_TOKEN INTTAG21;
++ pANTLR3_COMMON_TOKEN INTBOOL22;
++ pANTLR3_COMMON_TOKEN INT23;
++ pANTLR3_COMMON_TOKEN DATETAG24;
++ pANTLR3_COMMON_TOKEN set25;
++ pANTLR3_COMMON_TOKEN ENUMTAG27;
++ pANTLR3_COMMON_TOKEN IS28;
++ pANTLR3_COMMON_TOKEN ENUMVAL29;
++ SMARTPLParser_expression_return expression16;
++ #undef RETURN_TYPE_expression16
++ #define RETURN_TYPE_expression16 SMARTPLParser_expression_return
++
++ SMARTPLParser_dateval_return dateval26;
++ #undef RETURN_TYPE_dateval26
++ #define RETURN_TYPE_dateval26 SMARTPLParser_dateval_return
++
++ pANTLR3_BASE_TREE LPAR15_tree;
++ pANTLR3_BASE_TREE RPAR17_tree;
++ pANTLR3_BASE_TREE STRTAG18_tree;
++ pANTLR3_BASE_TREE set19_tree;
++ pANTLR3_BASE_TREE STR20_tree;
++ pANTLR3_BASE_TREE INTTAG21_tree;
++ pANTLR3_BASE_TREE INTBOOL22_tree;
++ pANTLR3_BASE_TREE INT23_tree;
++ pANTLR3_BASE_TREE DATETAG24_tree;
++ pANTLR3_BASE_TREE set25_tree;
++ pANTLR3_BASE_TREE ENUMTAG27_tree;
++ pANTLR3_BASE_TREE IS28_tree;
++ pANTLR3_BASE_TREE ENUMVAL29_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expression;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ LPAR15 = NULL;
++ RPAR17 = NULL;
++ STRTAG18 = NULL;
++ set19 = NULL;
++ STR20 = NULL;
++ INTTAG21 = NULL;
++ INTBOOL22 = NULL;
++ INT23 = NULL;
++ DATETAG24 = NULL;
++ set25 = NULL;
++ ENUMTAG27 = NULL;
++ IS28 = NULL;
++ ENUMVAL29 = NULL;
++ expression16.tree = NULL;
++
++ dateval26.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ LPAR15_tree = NULL;
++ RPAR17_tree = NULL;
++ STRTAG18_tree = NULL;
++ set19_tree = NULL;
++ STR20_tree = NULL;
++ INTTAG21_tree = NULL;
++ INTBOOL22_tree = NULL;
++ INT23_tree = NULL;
++ DATETAG24_tree = NULL;
++ set25_tree = NULL;
++ ENUMTAG27_tree = NULL;
++ IS28_tree = NULL;
++ ENUMVAL29_tree = NULL;
++
++ stream_RPAR = NULL;
++ #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); }
++ stream_LPAR = NULL;
++ #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); }
++ stream_expression = NULL;
++ #define CREATE_stream_expression if (stream_expression == NULL) {stream_expression = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expression"); }
++
++ retval.tree = NULL;
++ {
++ {
++ // SMARTPL.g:40:7: ( LPAR expression RPAR -> expression | STRTAG ( INCLUDES | IS ) STR | INTTAG INTBOOL INT | DATETAG ( AFTER | BEFORE ) dateval | ENUMTAG IS ENUMVAL )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=5;
++
++ switch ( LA(1) )
++ {
++ case LPAR:
++ {
++ alt4=1;
++ }
++ break;
++ case STRTAG:
++ {
++ alt4=2;
++ }
++ break;
++ case INTTAG:
++ {
++ alt4=3;
++ }
++ break;
++ case DATETAG:
++ {
++ alt4=4;
++ }
++ break;
++ case ENUMTAG:
++ {
++ alt4=5;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto rulecritEx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // SMARTPL.g:40:9: LPAR expression RPAR
++ {
++ LPAR15 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit127);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR15, NULL);
++
++ FOLLOWPUSH(FOLLOW_expression_in_crit129);
++ expression16=expression(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_expression; stream_expression->add(stream_expression, expression16.tree, NULL);
++ RPAR17 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit131);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR17, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : expression
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 40:30: -> expression
++ {
++ ADAPTOR->addChild(ADAPTOR, root_0, stream_expression == NULL ? NULL : stream_expression->nextTree(stream_expression));
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++ case 2:
++ // SMARTPL.g:41:6: STRTAG ( INCLUDES | IS ) STR
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ STRTAG18 = (pANTLR3_COMMON_TOKEN) MATCHT(STRTAG, &FOLLOW_STRTAG_in_crit142);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ STRTAG18_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STRTAG18));
++ ADAPTOR->addChild(ADAPTOR, root_0, STRTAG18_tree);
++
++ set19=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( ((LA(1) >= INCLUDES) && (LA(1) <= IS)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set19)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_crit144;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_crit144); goto rulecritEx;
++ }
++
++ STR20 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_crit150);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ STR20_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STR20));
++ ADAPTOR->addChild(ADAPTOR, root_0, STR20_tree);
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:42:6: INTTAG INTBOOL INT
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ INTTAG21 = (pANTLR3_COMMON_TOKEN) MATCHT(INTTAG, &FOLLOW_INTTAG_in_crit157);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ INTTAG21_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INTTAG21));
++ ADAPTOR->addChild(ADAPTOR, root_0, INTTAG21_tree);
++
++ INTBOOL22 = (pANTLR3_COMMON_TOKEN) MATCHT(INTBOOL, &FOLLOW_INTBOOL_in_crit159);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ INTBOOL22_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INTBOOL22));
++ ADAPTOR->addChild(ADAPTOR, root_0, INTBOOL22_tree);
++
++ INT23 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_crit161);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ INT23_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT23));
++ ADAPTOR->addChild(ADAPTOR, root_0, INT23_tree);
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:43:6: DATETAG ( AFTER | BEFORE ) dateval
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ DATETAG24 = (pANTLR3_COMMON_TOKEN) MATCHT(DATETAG, &FOLLOW_DATETAG_in_crit168);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ DATETAG24_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATETAG24));
++ ADAPTOR->addChild(ADAPTOR, root_0, DATETAG24_tree);
++
++ set25=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( ((LA(1) >= AFTER) && (LA(1) <= BEFORE)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set25)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_crit170;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_crit170); goto rulecritEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_dateval_in_crit176);
++ dateval26=dateval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, dateval26.tree);
++
++ }
++ break;
++ case 5:
++ // SMARTPL.g:44:6: ENUMTAG IS ENUMVAL
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ ENUMTAG27 = (pANTLR3_COMMON_TOKEN) MATCHT(ENUMTAG, &FOLLOW_ENUMTAG_in_crit183);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ ENUMTAG27_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, ENUMTAG27));
++ ADAPTOR->addChild(ADAPTOR, root_0, ENUMTAG27_tree);
++
++ IS28 = (pANTLR3_COMMON_TOKEN) MATCHT(IS, &FOLLOW_IS_in_crit185);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ IS28_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, IS28));
++ ADAPTOR->addChild(ADAPTOR, root_0, IS28_tree);
++
++ ENUMVAL29 = (pANTLR3_COMMON_TOKEN) MATCHT(ENUMVAL, &FOLLOW_ENUMVAL_in_crit187);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ ENUMVAL29_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, ENUMVAL29));
++ ADAPTOR->addChild(ADAPTOR, root_0, ENUMVAL29_tree);
++
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulecritEx; /* Prevent compiler warnings */
++ rulecritEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR);
++ if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR);
++ if (stream_expression != NULL) stream_expression->free(stream_expression);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end crit */
++
++/**
++ * $ANTLR start dateval
++ * SMARTPL.g:47:1: dateval : ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO );
++ */
++static SMARTPLParser_dateval_return
++dateval(pSMARTPLParser ctx)
++{
++ SMARTPLParser_dateval_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN DATE30;
++ pANTLR3_COMMON_TOKEN BEFORE32;
++ pANTLR3_COMMON_TOKEN DATE33;
++ pANTLR3_COMMON_TOKEN AFTER35;
++ pANTLR3_COMMON_TOKEN DATE36;
++ pANTLR3_COMMON_TOKEN AGO38;
++ SMARTPLParser_interval_return interval31;
++ #undef RETURN_TYPE_interval31
++ #define RETURN_TYPE_interval31 SMARTPLParser_interval_return
++
++ SMARTPLParser_interval_return interval34;
++ #undef RETURN_TYPE_interval34
++ #define RETURN_TYPE_interval34 SMARTPLParser_interval_return
++
++ SMARTPLParser_interval_return interval37;
++ #undef RETURN_TYPE_interval37
++ #define RETURN_TYPE_interval37 SMARTPLParser_interval_return
++
++ pANTLR3_BASE_TREE DATE30_tree;
++ pANTLR3_BASE_TREE BEFORE32_tree;
++ pANTLR3_BASE_TREE DATE33_tree;
++ pANTLR3_BASE_TREE AFTER35_tree;
++ pANTLR3_BASE_TREE DATE36_tree;
++ pANTLR3_BASE_TREE AGO38_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ DATE30 = NULL;
++ BEFORE32 = NULL;
++ DATE33 = NULL;
++ AFTER35 = NULL;
++ DATE36 = NULL;
++ AGO38 = NULL;
++ interval31.tree = NULL;
++
++ interval34.tree = NULL;
++
++ interval37.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ DATE30_tree = NULL;
++ BEFORE32_tree = NULL;
++ DATE33_tree = NULL;
++ AFTER35_tree = NULL;
++ DATE36_tree = NULL;
++ AGO38_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ {
++ // SMARTPL.g:47:10: ( DATE | interval BEFORE DATE | interval AFTER DATE | interval AGO )
++
++ ANTLR3_UINT32 alt5;
++
++ alt5=4;
++
++ switch ( LA(1) )
++ {
++ case DATE:
++ {
++ alt5=1;
++ }
++ break;
++ case INT:
++ {
++ switch ( LA(2) )
++ {
++ case DATINTERVAL:
++ {
++ switch ( LA(3) )
++ {
++ case AGO:
++ {
++ alt5=4;
++ }
++ break;
++ case AFTER:
++ {
++ alt5=3;
++ }
++ break;
++ case BEFORE:
++ {
++ alt5=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 3;
++
++
++ goto ruledatevalEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 2;
++
++
++ goto ruledatevalEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 0;
++
++
++ goto ruledatevalEx;
++ }
++
++ switch (alt5)
++ {
++ case 1:
++ // SMARTPL.g:47:12: DATE
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ DATE30 = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateval200);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ DATE30_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATE30));
++ ADAPTOR->addChild(ADAPTOR, root_0, DATE30_tree);
++
++
++ }
++ break;
++ case 2:
++ // SMARTPL.g:48:6: interval BEFORE DATE
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_interval_in_dateval207);
++ interval31=interval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, interval31.tree);
++ BEFORE32 = (pANTLR3_COMMON_TOKEN) MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateval209);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ BEFORE32_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, BEFORE32));
++ ADAPTOR->addChild(ADAPTOR, root_0, BEFORE32_tree);
++
++ DATE33 = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateval211);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ DATE33_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATE33));
++ ADAPTOR->addChild(ADAPTOR, root_0, DATE33_tree);
++
++
++ }
++ break;
++ case 3:
++ // SMARTPL.g:49:6: interval AFTER DATE
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_interval_in_dateval218);
++ interval34=interval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, interval34.tree);
++ AFTER35 = (pANTLR3_COMMON_TOKEN) MATCHT(AFTER, &FOLLOW_AFTER_in_dateval220);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ AFTER35_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AFTER35));
++ ADAPTOR->addChild(ADAPTOR, root_0, AFTER35_tree);
++
++ DATE36 = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateval222);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ DATE36_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATE36));
++ ADAPTOR->addChild(ADAPTOR, root_0, DATE36_tree);
++
++
++ }
++ break;
++ case 4:
++ // SMARTPL.g:50:6: interval AGO
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_interval_in_dateval229);
++ interval37=interval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, interval37.tree);
++ AGO38 = (pANTLR3_COMMON_TOKEN) MATCHT(AGO, &FOLLOW_AGO_in_dateval231);
++ if (HASEXCEPTION())
++ {
++ goto ruledatevalEx;
++ }
++
++ AGO38_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AGO38));
++ ADAPTOR->addChild(ADAPTOR, root_0, AGO38_tree);
++
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledatevalEx; /* Prevent compiler warnings */
++ ruledatevalEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end dateval */
++
++/**
++ * $ANTLR start interval
++ * SMARTPL.g:53:1: interval : INT DATINTERVAL ;
++ */
++static SMARTPLParser_interval_return
++interval(pSMARTPLParser ctx)
++{
++ SMARTPLParser_interval_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN INT39;
++ pANTLR3_COMMON_TOKEN DATINTERVAL40;
++
++ pANTLR3_BASE_TREE INT39_tree;
++ pANTLR3_BASE_TREE DATINTERVAL40_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ INT39 = NULL;
++ DATINTERVAL40 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ INT39_tree = NULL;
++ DATINTERVAL40_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // SMARTPL.g:53:10: ( INT DATINTERVAL )
++ // SMARTPL.g:53:12: INT DATINTERVAL
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ INT39 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_interval243);
++ if (HASEXCEPTION())
++ {
++ goto ruleintervalEx;
++ }
++
++ INT39_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT39));
++ ADAPTOR->addChild(ADAPTOR, root_0, INT39_tree);
++
++ DATINTERVAL40 = (pANTLR3_COMMON_TOKEN) MATCHT(DATINTERVAL, &FOLLOW_DATINTERVAL_in_interval245);
++ if (HASEXCEPTION())
++ {
++ goto ruleintervalEx;
++ }
++
++ DATINTERVAL40_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, DATINTERVAL40));
++ ADAPTOR->addChild(ADAPTOR, root_0, DATINTERVAL40_tree);
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleintervalEx; /* Prevent compiler warnings */
++ ruleintervalEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end interval */
++/* End of parsing rules
++ * ==============================================
++ */
++
++/* ==============================================
++ * Syntactic predicates
++ */
++/* End of syntactic predicates
++ * ==============================================
++ */
++
++
++
++
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/SMARTPLParser.h b/src/pregen/SMARTPLParser.h
+new file mode 100644
+index 0000000..5360136
+--- /dev/null
++++ b/src/pregen/SMARTPLParser.h
+@@ -0,0 +1,285 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : SMARTPL.g
++ * - On : 2015-06-27 19:05:15
++ * - for the parser : SMARTPLParserParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The parser SMARTPLParser has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pSMARTPLParser, which is returned from a call to SMARTPLParserNew().
++ *
++ * The methods in pSMARTPLParser are as follows:
++ *
++ * - SMARTPLParser_playlist_return pSMARTPLParser->playlist(pSMARTPLParser)
++ * - SMARTPLParser_expression_return pSMARTPLParser->expression(pSMARTPLParser)
++ * - SMARTPLParser_aexpr_return pSMARTPLParser->aexpr(pSMARTPLParser)
++ * - SMARTPLParser_nexpr_return pSMARTPLParser->nexpr(pSMARTPLParser)
++ * - SMARTPLParser_crit_return pSMARTPLParser->crit(pSMARTPLParser)
++ * - SMARTPLParser_dateval_return pSMARTPLParser->dateval(pSMARTPLParser)
++ * - SMARTPLParser_interval_return pSMARTPLParser->interval(pSMARTPLParser)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _SMARTPLParser_H
++#define _SMARTPLParser_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct SMARTPLParser_Ctx_struct SMARTPLParser, * pSMARTPLParser;
++
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++typedef struct SMARTPLParser_playlist_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_playlist_return;
++
++typedef struct SMARTPLParser_expression_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_expression_return;
++
++typedef struct SMARTPLParser_aexpr_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_aexpr_return;
++
++typedef struct SMARTPLParser_nexpr_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_nexpr_return;
++
++typedef struct SMARTPLParser_crit_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_crit_return;
++
++typedef struct SMARTPLParser_dateval_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_dateval_return;
++
++typedef struct SMARTPLParser_interval_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ SMARTPLParser_interval_return;
++
++
++
++/** Context tracking structure for SMARTPLParser
++ */
++struct SMARTPLParser_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_PARSER pParser;
++
++
++ SMARTPLParser_playlist_return (*playlist) (struct SMARTPLParser_Ctx_struct * ctx);
++ SMARTPLParser_expression_return (*expression) (struct SMARTPLParser_Ctx_struct * ctx);
++ SMARTPLParser_aexpr_return (*aexpr) (struct SMARTPLParser_Ctx_struct * ctx);
++ SMARTPLParser_nexpr_return (*nexpr) (struct SMARTPLParser_Ctx_struct * ctx);
++ SMARTPLParser_crit_return (*crit) (struct SMARTPLParser_Ctx_struct * ctx);
++ SMARTPLParser_dateval_return (*dateval) (struct SMARTPLParser_Ctx_struct * ctx);
++ SMARTPLParser_interval_return (*interval) (struct SMARTPLParser_Ctx_struct * ctx);
++ // Delegated rules
++ const char * (*getGrammarFileName)();
++ void (*free) (struct SMARTPLParser_Ctx_struct * ctx);
++ /* @headerFile.members() */
++ pANTLR3_BASE_TREE_ADAPTOR adaptor;
++ pANTLR3_VECTOR_FACTORY vectors;
++ /* End @headerFile.members() */
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pSMARTPLParser SMARTPLParserNew (pANTLR3_COMMON_TOKEN_STREAM instream);
++ANTLR3_API pSMARTPLParser SMARTPLParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the parser will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define INTBOOL 14
++#define STRTAG 10
++#define AGO 22
++#define WHITESPACE 29
++#define GREATEREQUAL 25
++#define BEFORE 18
++#define DATETAG 16
++#define INT 15
++#define NOT 7
++#define AFTER 17
++#define AND 6
++#define EOF -1
++#define INCLUDES 11
++#define STR 4
++#define T__30 30
++#define T__31 31
++#define GREATER 24
++#define LPAR 8
++#define ENUMTAG 19
++#define IS 12
++#define ENUMVAL 20
++#define EQUAL 28
++#define OR 5
++#define LESS 26
++#define RPAR 9
++#define DATE 21
++#define LESSEQUAL 27
++#define DATINTERVAL 23
++#define INTTAG 13
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for SMARTPLParser
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
projects / feed / packages.git / commitdiff