forked-daapd: update to 23.4 + add missing iconv dependency 2222/head
authorejurgensen <espenjurgensen@gmail.com>
Fri, 1 Jan 2016 15:21:57 +0000 (16:21 +0100)
committerejurgensen <espenjurgensen@gmail.com>
Fri, 1 Jan 2016 15:21:57 +0000 (16:21 +0100)
Signed-off-by: Espen Jürgensen <espenjurgensen+openwrt@gmail.com>
sound/forked-daapd/Makefile
sound/forked-daapd/patches/010-include_pregen.patch

index 51f459f0f4703f0429acfe7604ec8e41604c5ba1..d93c493e4e315c85c38573a67d7fe25e738e1a3e 100644 (file)
@@ -8,9 +8,9 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=forked-daapd
-PKG_VERSION:=23.2
-PKG_RELEASE:=20150622
-PKG_REV:=227017ef5ba8df921b2f1db681a46494ec296b8b
+PKG_VERSION:=23.4
+PKG_RELEASE:=20160101
+PKG_REV:=90514de7c8d9bf06b54596bc66e0668181eee25a
 
 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.bz2
 PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
@@ -36,7 +36,7 @@ TITLE:=iTunes (DAAP) server for Apple Remote and AirPlay
 URL:=https://github.com/ejurgensen/forked-daapd
 DEPENDS:=+libgpg-error +libgcrypt +libgdbm +zlib +libexpat +libunistring \
        +libevent2 +libdaemon +libantlr3c +confuse +alsa-lib +libffmpeg-full \
-       +mxml +libavahi-client +sqlite3-cli +libplist +libcurl
+       +mxml +libavahi-client +sqlite3-cli +libplist +libcurl +libiconv
 endef
 
 define Package/forked-daapd/description
index 6236acecb0f617a34cee396357dc04bb478b7066..762f62509fcaf87c65bb89ed16532b762b3edb64 100644 (file)
@@ -13,7 +13,7 @@ index 0000000..3de527b
 \ No newline at end of file
 diff --git a/src/pregen/DAAP2SQL.c b/src/pregen/DAAP2SQL.c
 new file mode 100644
-index 0000000..f13209c
+index 0000000..04d6153
 --- /dev/null
 +++ b/src/pregen/DAAP2SQL.c
 @@ -0,0 +1,975 @@
@@ -21,7 +21,7 @@ index 0000000..f13209c
 + *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : DAAP2SQL.g
-+ *     -                            On : 2015-06-27 19:05:20
++ *     -                            On : 2016-01-01 12:23:43
 + *     -           for the tree parser : DAAP2SQLTreeParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -994,7 +994,7 @@ index 0000000..f13209c
 + */
 diff --git a/src/pregen/DAAP2SQL.h b/src/pregen/DAAP2SQL.h
 new file mode 100644
-index 0000000..2b1e806
+index 0000000..e829049
 --- /dev/null
 +++ b/src/pregen/DAAP2SQL.h
 @@ -0,0 +1,195 @@
@@ -1002,7 +1002,7 @@ index 0000000..2b1e806
 + *  This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : DAAP2SQL.g
-+ *     -                            On : 2015-06-27 19:05:20
++ *     -                            On : 2016-01-01 12:23:43
 + *     -           for the tree parser : DAAP2SQLTreeParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -1207,7 +1207,7 @@ index 0000000..385d80b
 \ No newline at end of file
 diff --git a/src/pregen/DAAPLexer.c b/src/pregen/DAAPLexer.c
 new file mode 100644
-index 0000000..b72f28a
+index 0000000..eab3ff4
 --- /dev/null
 +++ b/src/pregen/DAAPLexer.c
 @@ -0,0 +1,1101 @@
@@ -1215,7 +1215,7 @@ index 0000000..b72f28a
 + *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : DAAP.g
-+ *     -                            On : 2015-06-27 19:05:17
++ *     -                            On : 2016-01-01 12:23:41
 + *     -                 for the lexer : DAAPLexerLexer *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -2314,7 +2314,7 @@ index 0000000..b72f28a
 + */
 diff --git a/src/pregen/DAAPLexer.h b/src/pregen/DAAPLexer.h
 new file mode 100644
-index 0000000..401b214
+index 0000000..685a0bc
 --- /dev/null
 +++ b/src/pregen/DAAPLexer.h
 @@ -0,0 +1,188 @@
@@ -2322,7 +2322,7 @@ index 0000000..401b214
 + *  This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : DAAP.g
-+ *     -                            On : 2015-06-27 19:05:17
++ *     -                            On : 2016-01-01 12:23:41
 + *     -                 for the lexer : DAAPLexerLexer *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -2508,7 +2508,7 @@ index 0000000..401b214
 +/* 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..7a9aae9
+index 0000000..1091f05
 --- /dev/null
 +++ b/src/pregen/DAAPParser.c
 @@ -0,0 +1,1014 @@
@@ -2516,7 +2516,7 @@ index 0000000..7a9aae9
 + *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : DAAP.g
-+ *     -                            On : 2015-06-27 19:05:16
++ *     -                            On : 2016-01-01 12:23:41
 + *     -                for the parser : DAAPParserParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -3528,7 +3528,7 @@ index 0000000..7a9aae9
 + */
 diff --git a/src/pregen/DAAPParser.h b/src/pregen/DAAPParser.h
 new file mode 100644
-index 0000000..82ce85e
+index 0000000..e206694
 --- /dev/null
 +++ b/src/pregen/DAAPParser.h
 @@ -0,0 +1,226 @@
@@ -3536,7 +3536,7 @@ index 0000000..82ce85e
 + *  This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : DAAP.g
-+ *     -                            On : 2015-06-27 19:05:16
++ *     -                            On : 2016-01-01 12:23:41
 + *     -                for the parser : DAAPParserParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -3773,7 +3773,7 @@ index 0000000..89256ff
 \ No newline at end of file
 diff --git a/src/pregen/RSP2SQL.c b/src/pregen/RSP2SQL.c
 new file mode 100644
-index 0000000..05b54d3
+index 0000000..40958f9
 --- /dev/null
 +++ b/src/pregen/RSP2SQL.c
 @@ -0,0 +1,2546 @@
@@ -3781,7 +3781,7 @@ index 0000000..05b54d3
 + *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : RSP2SQL.g
-+ *     -                            On : 2015-06-27 19:05:19
++ *     -                            On : 2016-01-01 12:23:43
 + *     -           for the tree parser : RSP2SQLTreeParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -6325,7 +6325,7 @@ index 0000000..05b54d3
 + */
 diff --git a/src/pregen/RSP2SQL.h b/src/pregen/RSP2SQL.h
 new file mode 100644
-index 0000000..a94e317
+index 0000000..08ac7bb
 --- /dev/null
 +++ b/src/pregen/RSP2SQL.h
 @@ -0,0 +1,291 @@
@@ -6333,7 +6333,7 @@ index 0000000..a94e317
 + *  This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : RSP2SQL.g
-+ *     -                            On : 2015-06-27 19:05:19
++ *     -                            On : 2016-01-01 12:23:43
 + *     -           for the tree parser : RSP2SQLTreeParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -6634,7 +6634,7 @@ index 0000000..53d8cda
 \ No newline at end of file
 diff --git a/src/pregen/RSPLexer.c b/src/pregen/RSPLexer.c
 new file mode 100644
-index 0000000..bc4245a
+index 0000000..2e3faae
 --- /dev/null
 +++ b/src/pregen/RSPLexer.c
 @@ -0,0 +1,4867 @@
@@ -6642,7 +6642,7 @@ index 0000000..bc4245a
 + *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : RSP.g
-+ *     -                            On : 2015-06-27 19:05:18
++ *     -                            On : 2016-01-01 12:23:42
 + *     -                 for the lexer : RSPLexerLexer *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -11507,7 +11507,7 @@ index 0000000..bc4245a
 + */
 diff --git a/src/pregen/RSPLexer.h b/src/pregen/RSPLexer.h
 new file mode 100644
-index 0000000..d93f93e
+index 0000000..27bc791
 --- /dev/null
 +++ b/src/pregen/RSPLexer.h
 @@ -0,0 +1,254 @@
@@ -11515,7 +11515,7 @@ index 0000000..d93f93e
 + *  This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : RSP.g
-+ *     -                            On : 2015-06-27 19:05:18
++ *     -                            On : 2016-01-01 12:23:42
 + *     -                 for the lexer : RSPLexerLexer *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -11767,15 +11767,15 @@ index 0000000..d93f93e
 +/* 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..c0f3e2a
+index 0000000..ba8a9d2
 --- /dev/null
 +++ b/src/pregen/RSPParser.c
-@@ -0,0 +1,2684 @@
+@@ -0,0 +1,3152 @@
 +/** \file
 + *  This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : RSP.g
-+ *     -                            On : 2015-06-27 19:05:18
++ *     -                            On : 2016-01-01 12:23:42
 + *     -                for the parser : RSPParserParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -12214,66 +12214,102 @@ index 0000000..c0f3e2a
 +/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit161  */
 +static        ANTLR3_BITWORD FOLLOW_STR_in_strcrit161_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
 +static  ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit161   = { FOLLOW_STR_in_strcrit161_bits, 1    };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_strop0  */
-+static        ANTLR3_BITWORD FOLLOW_set_in_strop0_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_set_in_strop0       = { FOLLOW_set_in_strop0_bits, 1        };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit211  */
-+static        ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit211_bits[]        = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit211 = { FOLLOW_FIELD_in_intcrit211_bits, 1  };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit213  */
-+static        ANTLR3_BITWORD FOLLOW_intop_in_intcrit213_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000010000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit213 = { FOLLOW_intop_in_intcrit213_bits, 1  };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit215  */
-+static        ANTLR3_BITWORD FOLLOW_INT_in_intcrit215_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit215   = { FOLLOW_INT_in_intcrit215_bits, 1    };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit232  */
-+static        ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit232_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000800) };
-+static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit232 = { FOLLOW_FIELD_in_intcrit232_bits, 1  };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_intcrit234  */
-+static        ANTLR3_BITWORD FOLLOW_NOT_in_intcrit234_bits[]  = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_NOT_in_intcrit234   = { FOLLOW_NOT_in_intcrit234_bits, 1    };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit236  */
-+static        ANTLR3_BITWORD FOLLOW_intop_in_intcrit236_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000010000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit236 = { FOLLOW_intop_in_intcrit236_bits, 1  };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit238  */
-+static        ANTLR3_BITWORD FOLLOW_INT_in_intcrit238_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit238   = { FOLLOW_INT_in_intcrit238_bits, 1    };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_intop0  */
-+static        ANTLR3_BITWORD FOLLOW_set_in_intop0_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_set_in_intop0       = { FOLLOW_set_in_intop0_bits, 1        };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit292  */
-+static        ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit292_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000600000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit292        = { FOLLOW_FIELD_in_datecrit292_bits, 1 };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit294  */
-+static        ANTLR3_BITWORD FOLLOW_dateop_in_datecrit294_bits[]      = { ANTLR3_UINT64_LIT(0x0000000001810000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit294       = { FOLLOW_dateop_in_datecrit294_bits, 1        };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit296  */
-+static        ANTLR3_BITWORD FOLLOW_datespec_in_datecrit296_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit296     = { FOLLOW_datespec_in_datecrit296_bits, 1      };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateop0  */
-+static        ANTLR3_BITWORD FOLLOW_set_in_dateop0_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_set_in_dateop0      = { FOLLOW_set_in_dateop0_bits, 1       };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec331  */
-+static        ANTLR3_BITWORD FOLLOW_dateref_in_datespec331_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec331      = { FOLLOW_dateref_in_datespec331_bits, 1       };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec336  */
-+static        ANTLR3_BITWORD FOLLOW_INT_in_datespec336_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec336  = { FOLLOW_INT_in_datespec336_bits, 1   };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec338  */
-+static        ANTLR3_BITWORD FOLLOW_dateintval_in_datespec338_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000600000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec338   = { FOLLOW_dateintval_in_datespec338_bits, 1    };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec340  */
-+static        ANTLR3_BITWORD FOLLOW_dateop_in_datespec340_bits[]      = { ANTLR3_UINT64_LIT(0x0000000001800000) };
-+static  ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec340       = { FOLLOW_dateop_in_datespec340_bits, 1        };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec342  */
-+static        ANTLR3_BITWORD FOLLOW_dateref_in_datespec342_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec342      = { FOLLOW_dateref_in_datespec342_bits, 1       };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateref0  */
-+static        ANTLR3_BITWORD FOLLOW_set_in_dateref0_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_set_in_dateref0     = { FOLLOW_set_in_dateref0_bits, 1      };
-+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateintval0  */
-+static        ANTLR3_BITWORD FOLLOW_set_in_dateintval0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
-+static  ANTLR3_BITSET_LIST FOLLOW_set_in_dateintval0  = { FOLLOW_set_in_dateintval0_bits, 1   };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_strop188  */
++static        ANTLR3_BITWORD FOLLOW_EQUAL_in_strop188_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_strop188   = { FOLLOW_EQUAL_in_strop188_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INCLUDES_in_strop195  */
++static        ANTLR3_BITWORD FOLLOW_INCLUDES_in_strop195_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_INCLUDES_in_strop195        = { FOLLOW_INCLUDES_in_strop195_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STARTSW_in_strop202  */
++static        ANTLR3_BITWORD FOLLOW_STARTSW_in_strop202_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_STARTSW_in_strop202 = { FOLLOW_STARTSW_in_strop202_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENDSW_in_strop209  */
++static        ANTLR3_BITWORD FOLLOW_ENDSW_in_strop209_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_ENDSW_in_strop209   = { FOLLOW_ENDSW_in_strop209_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit219  */
++static        ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit219_bits[]        = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
++static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit219 = { FOLLOW_FIELD_in_intcrit219_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit221  */
++static        ANTLR3_BITWORD FOLLOW_intop_in_intcrit221_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000010000) };
++static  ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit221 = { FOLLOW_intop_in_intcrit221_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit223  */
++static        ANTLR3_BITWORD FOLLOW_INT_in_intcrit223_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit223   = { FOLLOW_INT_in_intcrit223_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit240  */
++static        ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit240_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000800) };
++static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit240 = { FOLLOW_FIELD_in_intcrit240_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_intcrit242  */
++static        ANTLR3_BITWORD FOLLOW_NOT_in_intcrit242_bits[]  = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
++static  ANTLR3_BITSET_LIST FOLLOW_NOT_in_intcrit242   = { FOLLOW_NOT_in_intcrit242_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit244  */
++static        ANTLR3_BITWORD FOLLOW_intop_in_intcrit244_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000010000) };
++static  ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit244 = { FOLLOW_intop_in_intcrit244_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit246  */
++static        ANTLR3_BITWORD FOLLOW_INT_in_intcrit246_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit246   = { FOLLOW_INT_in_intcrit246_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_intop273  */
++static        ANTLR3_BITWORD FOLLOW_EQUAL_in_intop273_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_intop273   = { FOLLOW_EQUAL_in_intop273_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LESS_in_intop280  */
++static        ANTLR3_BITWORD FOLLOW_LESS_in_intop280_bits[]   = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_LESS_in_intop280    = { FOLLOW_LESS_in_intop280_bits, 1     };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_in_intop287  */
++static        ANTLR3_BITWORD FOLLOW_GREATER_in_intop287_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_GREATER_in_intop287 = { FOLLOW_GREATER_in_intop287_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LTE_in_intop294  */
++static        ANTLR3_BITWORD FOLLOW_LTE_in_intop294_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_LTE_in_intop294     = { FOLLOW_LTE_in_intop294_bits, 1      };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_GTE_in_intop301  */
++static        ANTLR3_BITWORD FOLLOW_GTE_in_intop301_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_GTE_in_intop301     = { FOLLOW_GTE_in_intop301_bits, 1      };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit310  */
++static        ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit310_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000600000) };
++static  ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit310        = { FOLLOW_FIELD_in_datecrit310_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit312  */
++static        ANTLR3_BITWORD FOLLOW_dateop_in_datecrit312_bits[]      = { ANTLR3_UINT64_LIT(0x0000000001810000) };
++static  ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit312       = { FOLLOW_dateop_in_datecrit312_bits, 1        };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit314  */
++static        ANTLR3_BITWORD FOLLOW_datespec_in_datecrit314_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit314     = { FOLLOW_datespec_in_datecrit314_bits, 1      };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateop337  */
++static        ANTLR3_BITWORD FOLLOW_BEFORE_in_dateop337_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateop337 = { FOLLOW_BEFORE_in_dateop337_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateop344  */
++static        ANTLR3_BITWORD FOLLOW_AFTER_in_dateop344_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateop344  = { FOLLOW_AFTER_in_dateop344_bits, 1   };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec353  */
++static        ANTLR3_BITWORD FOLLOW_dateref_in_datespec353_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec353      = { FOLLOW_dateref_in_datespec353_bits, 1       };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec358  */
++static        ANTLR3_BITWORD FOLLOW_INT_in_datespec358_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) };
++static  ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec358  = { FOLLOW_INT_in_datespec358_bits, 1   };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec360  */
++static        ANTLR3_BITWORD FOLLOW_dateintval_in_datespec360_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000600000) };
++static  ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec360   = { FOLLOW_dateintval_in_datespec360_bits, 1    };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec362  */
++static        ANTLR3_BITWORD FOLLOW_dateop_in_datespec362_bits[]      = { ANTLR3_UINT64_LIT(0x0000000001800000) };
++static  ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec362       = { FOLLOW_dateop_in_datespec362_bits, 1        };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec364  */
++static        ANTLR3_BITWORD FOLLOW_dateref_in_datespec364_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec364      = { FOLLOW_dateref_in_datespec364_bits, 1       };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateref388  */
++static        ANTLR3_BITWORD FOLLOW_DATE_in_dateref388_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateref388  = { FOLLOW_DATE_in_dateref388_bits, 1   };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_TODAY_in_dateref395  */
++static        ANTLR3_BITWORD FOLLOW_TODAY_in_dateref395_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_TODAY_in_dateref395 = { FOLLOW_TODAY_in_dateref395_bits, 1  };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DAY_in_dateintval408  */
++static        ANTLR3_BITWORD FOLLOW_DAY_in_dateintval408_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_DAY_in_dateintval408        = { FOLLOW_DAY_in_dateintval408_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_WEEK_in_dateintval415  */
++static        ANTLR3_BITWORD FOLLOW_WEEK_in_dateintval415_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_WEEK_in_dateintval415       = { FOLLOW_WEEK_in_dateintval415_bits, 1        };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_MONTH_in_dateintval422  */
++static        ANTLR3_BITWORD FOLLOW_MONTH_in_dateintval422_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_MONTH_in_dateintval422      = { FOLLOW_MONTH_in_dateintval422_bits, 1       };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_YEAR_in_dateintval429  */
++static        ANTLR3_BITWORD FOLLOW_YEAR_in_dateintval429_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static  ANTLR3_BITSET_LIST FOLLOW_YEAR_in_dateintval429       = { FOLLOW_YEAR_in_dateintval429_bits, 1        };
 +     
 +
 + 
@@ -12819,13 +12855,6 @@ index 0000000..c0f3e2a
 +
 +                                              }
 +                                          break;
-+                                      case INCLUDES:
-+                                      case STARTSW:
-+                                      case ENDSW:
-+                                              {
-+                                                      alt4=2;
-+                                              }
-+                                          break;
 +                                      case LESS:
 +                                      case GREATER:
 +                                      case LTE:
@@ -12834,6 +12863,13 @@ index 0000000..c0f3e2a
 +                                                      alt4=3;
 +                                              }
 +                                          break;
++                                      case INCLUDES:
++                                      case STARTSW:
++                                      case ENDSW:
++                                              {
++                                                      alt4=2;
++                                              }
++                                          break;
 +
 +                                      default:
 +                                          CONSTRUCTEX();
@@ -12848,6 +12884,12 @@ index 0000000..c0f3e2a
 +
 +                              }
 +                          break;
++                      case BEFORE:
++                      case AFTER:
++                              {
++                                      alt4=4;
++                              }
++                          break;
 +                      case EQUAL:
 +                              {
 +                                      switch ( LA(3) ) 
@@ -12868,7 +12910,7 @@ index 0000000..c0f3e2a
 +                                          EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
 +                                          EXCEPTION->message      = (void *)"";
 +                                          EXCEPTION->decisionNum  = 4;
-+                                          EXCEPTION->state        = 4;
++                                          EXCEPTION->state        = 5;
 +
 +
 +                                          goto rulecritEx;
@@ -12876,12 +12918,6 @@ index 0000000..c0f3e2a
 +
 +                              }
 +                          break;
-+                      case BEFORE:
-+                      case AFTER:
-+                              {
-+                                      alt4=4;
-+                              }
-+                          break;
 +                      case LESS:
 +                      case GREATER:
 +                      case LTE:
@@ -13221,7 +13257,7 @@ index 0000000..c0f3e2a
 +
 +                       
 +                      /* AST REWRITE
-+                       * elements          : strop, STR, FIELD
++                       * elements          : FIELD, STR, strop
 +                       * token labels      : 
 +                       * rule labels       : retval
 +                       * token list labels : 
@@ -13296,7 +13332,7 @@ index 0000000..c0f3e2a
 +
 +                       
 +                      /* AST REWRITE
-+                       * elements          : NOT, strop, STR, FIELD
++                       * elements          : STR, FIELD, strop, NOT
 +                       * token labels      : 
 +                       * rule labels       : retval
 +                       * token list labels : 
@@ -13373,7 +13409,7 @@ index 0000000..c0f3e2a
 +
 +/** 
 + * $ANTLR start strop
-+ * RSP.g:46:1: strop : ( EQUAL | INCLUDES | STARTSW | ENDSW );
++ * RSP.g:46:1: strop : (equal= EQUAL | includes= INCLUDES | startsw= STARTSW | endsw= ENDSW );
 + */
 +static RSPParser_strop_return
 +strop(pRSPParser ctx)
@@ -13382,9 +13418,15 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    set23;
++    pANTLR3_COMMON_TOKEN    equal;
++    pANTLR3_COMMON_TOKEN    includes;
++    pANTLR3_COMMON_TOKEN    startsw;
++    pANTLR3_COMMON_TOKEN    endsw;
 +
-+    pANTLR3_BASE_TREE set23_tree;
++    pANTLR3_BASE_TREE equal_tree;
++    pANTLR3_BASE_TREE includes_tree;
++    pANTLR3_BASE_TREE startsw_tree;
++    pANTLR3_BASE_TREE endsw_tree;
 +
 +    /* Initialize rule variables
 +     */
@@ -13392,38 +13434,134 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    set23       = NULL;
++    equal       = NULL;
++    includes       = NULL;
++    startsw       = NULL;
++    endsw       = NULL;
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    set23_tree   = NULL;
++    equal_tree   = NULL;
++    includes_tree   = NULL;
++    startsw_tree   = NULL;
++    endsw_tree   = NULL;
 +
 +
 +    retval.tree  = NULL;
 +    {
-+        // RSP.g:46:7: ( EQUAL | INCLUDES | STARTSW | ENDSW )
-+        // RSP.g:
 +        {
-+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++            //  RSP.g:46:7: (equal= EQUAL | includes= INCLUDES | startsw= STARTSW | endsw= ENDSW )
++            
++            ANTLR3_UINT32 alt6;
 +
-+            set23=(pANTLR3_COMMON_TOKEN)LT(1);
-+            if ( ((LA(1) >= EQUAL) && (LA(1) <= ENDSW)) )
-+            {
-+                CONSUME();
-+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set23)));
-+                PERRORRECOVERY=ANTLR3_FALSE;
-+            }
-+            else 
++            alt6=4;
++
++            switch ( LA(1) ) 
 +            {
++            case EQUAL:
++              {
++                      alt6=1;
++              }
++                break;
++            case INCLUDES:
++              {
++                      alt6=2;
++              }
++                break;
++            case STARTSW:
++              {
++                      alt6=3;
++              }
++                break;
++            case ENDSW:
++              {
++                      alt6=4;
++              }
++                break;
++
++            default:
 +                CONSTRUCTEX();
-+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
-+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
-+                EXCEPTION->expectingSet = &FOLLOW_set_in_strop0;
-+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_strop0);    goto rulestropEx;
++                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++                EXCEPTION->message      = (void *)"";
++                EXCEPTION->decisionNum  = 6;
++                EXCEPTION->state        = 0;
++
++
++                goto rulestropEx;
 +            }
 +
++            switch (alt6) 
++            {
++              case 1:
++                  // RSP.g:46:9: equal= EQUAL
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
 +
-+        }
++                      equal = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_strop188); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto rulestropEx;
++                      }
++
++                      equal_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, equal));
++                      ADAPTOR->addChild(ADAPTOR, root_0, equal_tree);
++
++
++                  }
++                  break;
++              case 2:
++                  // RSP.g:47:4: includes= INCLUDES
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      includes = (pANTLR3_COMMON_TOKEN) MATCHT(INCLUDES, &FOLLOW_INCLUDES_in_strop195); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto rulestropEx;
++                      }
++
++                      includes_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, includes));
++                      ADAPTOR->addChild(ADAPTOR, root_0, includes_tree);
++
++
++                  }
++                  break;
++              case 3:
++                  // RSP.g:48:4: startsw= STARTSW
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      startsw = (pANTLR3_COMMON_TOKEN) MATCHT(STARTSW, &FOLLOW_STARTSW_in_strop202); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto rulestropEx;
++                      }
++
++                      startsw_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, startsw));
++                      ADAPTOR->addChild(ADAPTOR, root_0, startsw_tree);
++
++
++                  }
++                  break;
++              case 4:
++                  // RSP.g:49:4: endsw= ENDSW
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      endsw = (pANTLR3_COMMON_TOKEN) MATCHT(ENDSW, &FOLLOW_ENDSW_in_strop209); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto rulestropEx;
++                      }
++
++                      endsw_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, endsw));
++                      ADAPTOR->addChild(ADAPTOR, root_0, endsw_tree);
 +
++
++                  }
++                  break;
++
++            }
++        }
 +    }
 +    
 +
@@ -13460,24 +13598,24 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    FIELD24;
-+    pANTLR3_COMMON_TOKEN    INT26;
-+    pANTLR3_COMMON_TOKEN    FIELD27;
-+    pANTLR3_COMMON_TOKEN    NOT28;
-+    pANTLR3_COMMON_TOKEN    INT30;
-+    RSPParser_intop_return intop25;
-+    #undef    RETURN_TYPE_intop25
-+    #define   RETURN_TYPE_intop25 RSPParser_intop_return
-+
-+    RSPParser_intop_return intop29;
-+    #undef    RETURN_TYPE_intop29
-+    #define   RETURN_TYPE_intop29 RSPParser_intop_return
-+
-+    pANTLR3_BASE_TREE FIELD24_tree;
-+    pANTLR3_BASE_TREE INT26_tree;
-+    pANTLR3_BASE_TREE FIELD27_tree;
-+    pANTLR3_BASE_TREE NOT28_tree;
-+    pANTLR3_BASE_TREE INT30_tree;
++    pANTLR3_COMMON_TOKEN    FIELD23;
++    pANTLR3_COMMON_TOKEN    INT25;
++    pANTLR3_COMMON_TOKEN    FIELD26;
++    pANTLR3_COMMON_TOKEN    NOT27;
++    pANTLR3_COMMON_TOKEN    INT29;
++    RSPParser_intop_return intop24;
++    #undef    RETURN_TYPE_intop24
++    #define   RETURN_TYPE_intop24 RSPParser_intop_return
++
++    RSPParser_intop_return intop28;
++    #undef    RETURN_TYPE_intop28
++    #define   RETURN_TYPE_intop28 RSPParser_intop_return
++
++    pANTLR3_BASE_TREE FIELD23_tree;
++    pANTLR3_BASE_TREE INT25_tree;
++    pANTLR3_BASE_TREE FIELD26_tree;
++    pANTLR3_BASE_TREE NOT27_tree;
++    pANTLR3_BASE_TREE INT29_tree;
 +    pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
 +    pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT;
 +    pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT;
@@ -13488,22 +13626,22 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    FIELD24       = NULL;
-+    INT26       = NULL;
-+    FIELD27       = NULL;
-+    NOT28       = NULL;
-+    INT30       = NULL;
-+    intop25.tree = NULL;
++    FIELD23       = NULL;
++    INT25       = NULL;
++    FIELD26       = NULL;
++    NOT27       = NULL;
++    INT29       = NULL;
++    intop24.tree = NULL;
 +
-+    intop29.tree = NULL;
++    intop28.tree = NULL;
 +
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    FIELD24_tree   = NULL;
-+    INT26_tree   = NULL;
-+    FIELD27_tree   = NULL;
-+    NOT28_tree   = NULL;
-+    INT30_tree   = NULL;
++    FIELD23_tree   = NULL;
++    INT25_tree   = NULL;
++    FIELD26_tree   = NULL;
++    NOT27_tree   = NULL;
++    INT29_tree   = NULL;
 +
 +    stream_FIELD   = NULL;
 +    #define CREATE_stream_FIELD  if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); } 
@@ -13519,9 +13657,9 @@ index 0000000..c0f3e2a
 +        {
 +            //  RSP.g:52:9: ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) )
 +            
-+            ANTLR3_UINT32 alt6;
++            ANTLR3_UINT32 alt7;
 +
-+            alt6=2;
++            alt7=2;
 +
 +            switch ( LA(1) ) 
 +            {
@@ -13531,7 +13669,7 @@ index 0000000..c0f3e2a
 +                      {
 +                      case NOT:
 +                              {
-+                                      alt6=2;
++                                      alt7=2;
 +                              }
 +                          break;
 +                      case EQUAL:
@@ -13540,7 +13678,7 @@ index 0000000..c0f3e2a
 +                      case LTE:
 +                      case GTE:
 +                              {
-+                                      alt6=1;
++                                      alt7=1;
 +                              }
 +                          break;
 +
@@ -13548,7 +13686,7 @@ index 0000000..c0f3e2a
 +                          CONSTRUCTEX();
 +                          EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
 +                          EXCEPTION->message      = (void *)"";
-+                          EXCEPTION->decisionNum  = 6;
++                          EXCEPTION->decisionNum  = 7;
 +                          EXCEPTION->state        = 1;
 +
 +
@@ -13562,28 +13700,28 @@ index 0000000..c0f3e2a
 +                CONSTRUCTEX();
 +                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
 +                EXCEPTION->message      = (void *)"";
-+                EXCEPTION->decisionNum  = 6;
++                EXCEPTION->decisionNum  = 7;
 +                EXCEPTION->state        = 0;
 +
 +
 +                goto ruleintcritEx;
 +            }
 +
-+            switch (alt6
++            switch (alt7
 +            {
 +              case 1:
 +                  // RSP.g:52:11: FIELD intop INT
 +                  {
-+                      FIELD24 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit211); 
++                      FIELD23 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit219); 
 +                      if  (HASEXCEPTION())
 +                      {
 +                          goto ruleintcritEx;
 +                      }
 +                       
-+                      CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD24, NULL);
++                      CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD23, NULL);
 +
-+                      FOLLOWPUSH(FOLLOW_intop_in_intcrit213);
-+                      intop25=intop(ctx);
++                      FOLLOWPUSH(FOLLOW_intop_in_intcrit221);
++                      intop24=intop(ctx);
 +
 +                      FOLLOWPOP();
 +                      if  (HASEXCEPTION())
@@ -13591,19 +13729,19 @@ index 0000000..c0f3e2a
 +                          goto ruleintcritEx;
 +                      }
 +
-+                      CREATE_stream_intop; stream_intop->add(stream_intop, intop25.tree, NULL);
-+                      INT26 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit215); 
++                      CREATE_stream_intop; stream_intop->add(stream_intop, intop24.tree, NULL);
++                      INT25 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit223); 
 +                      if  (HASEXCEPTION())
 +                      {
 +                          goto ruleintcritEx;
 +                      }
 +                       
-+                      CREATE_stream_INT; stream_INT->add(stream_INT, INT26, NULL);
++                      CREATE_stream_INT; stream_INT->add(stream_INT, INT25, NULL);
 +
 +
 +                       
 +                      /* AST REWRITE
-+                       * elements          : intop, INT, FIELD
++                       * elements          : FIELD, INT, intop
 +                       * token labels      : 
 +                       * rule labels       : retval
 +                       * token list labels : 
@@ -13641,24 +13779,24 @@ index 0000000..c0f3e2a
 +              case 2:
 +                  // RSP.g:53:4: FIELD NOT intop INT
 +                  {
-+                      FIELD27 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit232); 
++                      FIELD26 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit240); 
 +                      if  (HASEXCEPTION())
 +                      {
 +                          goto ruleintcritEx;
 +                      }
 +                       
-+                      CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD27, NULL);
++                      CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD26, NULL);
 +
-+                      NOT28 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_intcrit234); 
++                      NOT27 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_intcrit242); 
 +                      if  (HASEXCEPTION())
 +                      {
 +                          goto ruleintcritEx;
 +                      }
 +                       
-+                      CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT28, NULL);
++                      CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT27, NULL);
 +
-+                      FOLLOWPUSH(FOLLOW_intop_in_intcrit236);
-+                      intop29=intop(ctx);
++                      FOLLOWPUSH(FOLLOW_intop_in_intcrit244);
++                      intop28=intop(ctx);
 +
 +                      FOLLOWPOP();
 +                      if  (HASEXCEPTION())
@@ -13666,19 +13804,19 @@ index 0000000..c0f3e2a
 +                          goto ruleintcritEx;
 +                      }
 +
-+                      CREATE_stream_intop; stream_intop->add(stream_intop, intop29.tree, NULL);
-+                      INT30 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit238); 
++                      CREATE_stream_intop; stream_intop->add(stream_intop, intop28.tree, NULL);
++                      INT29 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit246); 
 +                      if  (HASEXCEPTION())
 +                      {
 +                          goto ruleintcritEx;
 +                      }
 +                       
-+                      CREATE_stream_INT; stream_INT->add(stream_INT, INT30, NULL);
++                      CREATE_stream_INT; stream_INT->add(stream_INT, INT29, NULL);
 +
 +
 +                       
 +                      /* AST REWRITE
-+                       * elements          : INT, FIELD, intop, NOT
++                       * elements          : intop, NOT, INT, FIELD
 +                       * token labels      : 
 +                       * rule labels       : retval
 +                       * token list labels : 
@@ -13755,7 +13893,7 @@ index 0000000..c0f3e2a
 +
 +/** 
 + * $ANTLR start intop
-+ * RSP.g:56:1: intop : ( EQUAL | LESS | GREATER | LTE | GTE );
++ * RSP.g:56:1: intop : (equal= EQUAL | less= LESS | greater= GREATER | lte= LTE | gte= GTE );
 + */
 +static RSPParser_intop_return
 +intop(pRSPParser ctx)
@@ -13764,9 +13902,17 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    set31;
++    pANTLR3_COMMON_TOKEN    equal;
++    pANTLR3_COMMON_TOKEN    less;
++    pANTLR3_COMMON_TOKEN    greater;
++    pANTLR3_COMMON_TOKEN    lte;
++    pANTLR3_COMMON_TOKEN    gte;
 +
-+    pANTLR3_BASE_TREE set31_tree;
++    pANTLR3_BASE_TREE equal_tree;
++    pANTLR3_BASE_TREE less_tree;
++    pANTLR3_BASE_TREE greater_tree;
++    pANTLR3_BASE_TREE lte_tree;
++    pANTLR3_BASE_TREE gte_tree;
 +
 +    /* Initialize rule variables
 +     */
@@ -13774,38 +13920,158 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    set31       = NULL;
++    equal       = NULL;
++    less       = NULL;
++    greater       = NULL;
++    lte       = NULL;
++    gte       = NULL;
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    set31_tree   = NULL;
++    equal_tree   = NULL;
++    less_tree   = NULL;
++    greater_tree   = NULL;
++    lte_tree   = NULL;
++    gte_tree   = NULL;
 +
 +
 +    retval.tree  = NULL;
 +    {
-+        // RSP.g:56:7: ( EQUAL | LESS | GREATER | LTE | GTE )
-+        // RSP.g:
 +        {
-+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++            //  RSP.g:56:7: (equal= EQUAL | less= LESS | greater= GREATER | lte= LTE | gte= GTE )
++            
++            ANTLR3_UINT32 alt8;
 +
-+            set31=(pANTLR3_COMMON_TOKEN)LT(1);
-+            if ( LA(1) == EQUAL || ((LA(1) >= LESS) && (LA(1) <= GTE)) )
-+            {
-+                CONSUME();
-+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set31)));
-+                PERRORRECOVERY=ANTLR3_FALSE;
-+            }
-+            else 
++            alt8=5;
++
++            switch ( LA(1) ) 
 +            {
++            case EQUAL:
++              {
++                      alt8=1;
++              }
++                break;
++            case LESS:
++              {
++                      alt8=2;
++              }
++                break;
++            case GREATER:
++              {
++                      alt8=3;
++              }
++                break;
++            case LTE:
++              {
++                      alt8=4;
++              }
++                break;
++            case GTE:
++              {
++                      alt8=5;
++              }
++                break;
++
++            default:
 +                CONSTRUCTEX();
-+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
-+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
-+                EXCEPTION->expectingSet = &FOLLOW_set_in_intop0;
-+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_intop0);    goto ruleintopEx;
++                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++                EXCEPTION->message      = (void *)"";
++                EXCEPTION->decisionNum  = 8;
++                EXCEPTION->state        = 0;
++
++
++                goto ruleintopEx;
 +            }
 +
++            switch (alt8) 
++            {
++              case 1:
++                  // RSP.g:56:9: equal= EQUAL
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
 +
-+        }
++                      equal = (pANTLR3_COMMON_TOKEN) MATCHT(EQUAL, &FOLLOW_EQUAL_in_intop273); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruleintopEx;
++                      }
++
++                      equal_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, equal));
++                      ADAPTOR->addChild(ADAPTOR, root_0, equal_tree);
++
++
++                  }
++                  break;
++              case 2:
++                  // RSP.g:57:4: less= LESS
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      less = (pANTLR3_COMMON_TOKEN) MATCHT(LESS, &FOLLOW_LESS_in_intop280); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruleintopEx;
++                      }
++
++                      less_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, less));
++                      ADAPTOR->addChild(ADAPTOR, root_0, less_tree);
++
++
++                  }
++                  break;
++              case 3:
++                  // RSP.g:58:4: greater= GREATER
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      greater = (pANTLR3_COMMON_TOKEN) MATCHT(GREATER, &FOLLOW_GREATER_in_intop287); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruleintopEx;
++                      }
++
++                      greater_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, greater));
++                      ADAPTOR->addChild(ADAPTOR, root_0, greater_tree);
++
++
++                  }
++                  break;
++              case 4:
++                  // RSP.g:59:4: lte= LTE
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      lte = (pANTLR3_COMMON_TOKEN) MATCHT(LTE, &FOLLOW_LTE_in_intop294); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruleintopEx;
++                      }
++
++                      lte_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, lte));
++                      ADAPTOR->addChild(ADAPTOR, root_0, lte_tree);
++
++
++                  }
++                  break;
++              case 5:
++                  // RSP.g:60:4: gte= GTE
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      gte = (pANTLR3_COMMON_TOKEN) MATCHT(GTE, &FOLLOW_GTE_in_intop301); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruleintopEx;
++                      }
++
++                      gte_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, gte));
++                      ADAPTOR->addChild(ADAPTOR, root_0, gte_tree);
 +
++
++                  }
++                  break;
++
++            }
++        }
 +    }
 +    
 +
@@ -13842,16 +14108,16 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    FIELD32;
-+    RSPParser_dateop_return dateop33;
-+    #undef    RETURN_TYPE_dateop33
-+    #define   RETURN_TYPE_dateop33 RSPParser_dateop_return
++    pANTLR3_COMMON_TOKEN    FIELD30;
++    RSPParser_dateop_return dateop31;
++    #undef    RETURN_TYPE_dateop31
++    #define   RETURN_TYPE_dateop31 RSPParser_dateop_return
 +
-+    RSPParser_datespec_return datespec34;
-+    #undef    RETURN_TYPE_datespec34
-+    #define   RETURN_TYPE_datespec34 RSPParser_datespec_return
++    RSPParser_datespec_return datespec32;
++    #undef    RETURN_TYPE_datespec32
++    #define   RETURN_TYPE_datespec32 RSPParser_datespec_return
 +
-+    pANTLR3_BASE_TREE FIELD32_tree;
++    pANTLR3_BASE_TREE FIELD30_tree;
 +    pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
 +    pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_datespec;
 +    pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop;
@@ -13861,14 +14127,14 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    FIELD32       = NULL;
-+    dateop33.tree = NULL;
++    FIELD30       = NULL;
++    dateop31.tree = NULL;
 +
-+    datespec34.tree = NULL;
++    datespec32.tree = NULL;
 +
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    FIELD32_tree   = NULL;
++    FIELD30_tree   = NULL;
 +
 +    stream_FIELD   = NULL;
 +    #define CREATE_stream_FIELD  if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); } 
@@ -13882,16 +14148,16 @@ index 0000000..c0f3e2a
 +        // RSP.g:63:9: ( FIELD dateop datespec -> ^( dateop FIELD datespec ) )
 +        // RSP.g:63:11: FIELD dateop datespec
 +        {
-+            FIELD32 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit292); 
++            FIELD30 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit310); 
 +            if  (HASEXCEPTION())
 +            {
 +                goto ruledatecritEx;
 +            }
 +             
-+            CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD32, NULL);
++            CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD30, NULL);
 +
-+            FOLLOWPUSH(FOLLOW_dateop_in_datecrit294);
-+            dateop33=dateop(ctx);
++            FOLLOWPUSH(FOLLOW_dateop_in_datecrit312);
++            dateop31=dateop(ctx);
 +
 +            FOLLOWPOP();
 +            if  (HASEXCEPTION())
@@ -13899,9 +14165,9 @@ index 0000000..c0f3e2a
 +                goto ruledatecritEx;
 +            }
 +
-+            CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop33.tree, NULL);
-+            FOLLOWPUSH(FOLLOW_datespec_in_datecrit296);
-+            datespec34=datespec(ctx);
++            CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop31.tree, NULL);
++            FOLLOWPUSH(FOLLOW_datespec_in_datecrit314);
++            datespec32=datespec(ctx);
 +
 +            FOLLOWPOP();
 +            if  (HASEXCEPTION())
@@ -13909,11 +14175,11 @@ index 0000000..c0f3e2a
 +                goto ruledatecritEx;
 +            }
 +
-+            CREATE_stream_datespec; stream_datespec->add(stream_datespec, datespec34.tree, NULL);
++            CREATE_stream_datespec; stream_datespec->add(stream_datespec, datespec32.tree, NULL);
 +
 +             
 +            /* AST REWRITE
-+             * elements          : datespec, FIELD, dateop
++             * elements          : FIELD, dateop, datespec
 +             * token labels      : 
 +             * rule labels       : retval
 +             * token list labels : 
@@ -13978,7 +14244,7 @@ index 0000000..c0f3e2a
 +
 +/** 
 + * $ANTLR start dateop
-+ * RSP.g:66:1: dateop : ( BEFORE | AFTER );
++ * RSP.g:66:1: dateop : (before= BEFORE | after= AFTER );
 + */
 +static RSPParser_dateop_return
 +dateop(pRSPParser ctx)
@@ -13987,9 +14253,11 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    set35;
++    pANTLR3_COMMON_TOKEN    before;
++    pANTLR3_COMMON_TOKEN    after;
 +
-+    pANTLR3_BASE_TREE set35_tree;
++    pANTLR3_BASE_TREE before_tree;
++    pANTLR3_BASE_TREE after_tree;
 +
 +    /* Initialize rule variables
 +     */
@@ -13997,38 +14265,86 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    set35       = NULL;
++    before       = NULL;
++    after       = NULL;
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    set35_tree   = NULL;
++    before_tree   = NULL;
++    after_tree   = NULL;
 +
 +
 +    retval.tree  = NULL;
 +    {
-+        // RSP.g:66:8: ( BEFORE | AFTER )
-+        // RSP.g:
 +        {
-+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++            //  RSP.g:66:8: (before= BEFORE | after= AFTER )
++            
++            ANTLR3_UINT32 alt9;
 +
-+            set35=(pANTLR3_COMMON_TOKEN)LT(1);
-+            if ( ((LA(1) >= BEFORE) && (LA(1) <= AFTER)) )
-+            {
-+                CONSUME();
-+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set35)));
-+                PERRORRECOVERY=ANTLR3_FALSE;
-+            }
-+            else 
++            alt9=2;
++
++            switch ( LA(1) ) 
 +            {
++            case BEFORE:
++              {
++                      alt9=1;
++              }
++                break;
++            case AFTER:
++              {
++                      alt9=2;
++              }
++                break;
++
++            default:
 +                CONSTRUCTEX();
-+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
-+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
-+                EXCEPTION->expectingSet = &FOLLOW_set_in_dateop0;
-+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateop0);    goto ruledateopEx;
++                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++                EXCEPTION->message      = (void *)"";
++                EXCEPTION->decisionNum  = 9;
++                EXCEPTION->state        = 0;
++
++
++                goto ruledateopEx;
 +            }
 +
++            switch (alt9) 
++            {
++              case 1:
++                  // RSP.g:66:10: before= BEFORE
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
 +
-+        }
++                      before = (pANTLR3_COMMON_TOKEN) MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateop337); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledateopEx;
++                      }
++
++                      before_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, before));
++                      ADAPTOR->addChild(ADAPTOR, root_0, before_tree);
++
++
++                  }
++                  break;
++              case 2:
++                  // RSP.g:67:4: after= AFTER
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      after = (pANTLR3_COMMON_TOKEN) MATCHT(AFTER, &FOLLOW_AFTER_in_dateop344); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledateopEx;
++                      }
++
++                      after_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, after));
++                      ADAPTOR->addChild(ADAPTOR, root_0, after_tree);
++
++
++                  }
++                  break;
 +
++            }
++        }
 +    }
 +    
 +
@@ -14065,24 +14381,24 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    INT37;
-+    RSPParser_dateref_return dateref36;
-+    #undef    RETURN_TYPE_dateref36
-+    #define   RETURN_TYPE_dateref36 RSPParser_dateref_return
++    pANTLR3_COMMON_TOKEN    INT34;
++    RSPParser_dateref_return dateref33;
++    #undef    RETURN_TYPE_dateref33
++    #define   RETURN_TYPE_dateref33 RSPParser_dateref_return
 +
-+    RSPParser_dateintval_return dateintval38;
-+    #undef    RETURN_TYPE_dateintval38
-+    #define   RETURN_TYPE_dateintval38 RSPParser_dateintval_return
++    RSPParser_dateintval_return dateintval35;
++    #undef    RETURN_TYPE_dateintval35
++    #define   RETURN_TYPE_dateintval35 RSPParser_dateintval_return
 +
-+    RSPParser_dateop_return dateop39;
-+    #undef    RETURN_TYPE_dateop39
-+    #define   RETURN_TYPE_dateop39 RSPParser_dateop_return
++    RSPParser_dateop_return dateop36;
++    #undef    RETURN_TYPE_dateop36
++    #define   RETURN_TYPE_dateop36 RSPParser_dateop_return
 +
-+    RSPParser_dateref_return dateref40;
-+    #undef    RETURN_TYPE_dateref40
-+    #define   RETURN_TYPE_dateref40 RSPParser_dateref_return
++    RSPParser_dateref_return dateref37;
++    #undef    RETURN_TYPE_dateref37
++    #define   RETURN_TYPE_dateref37 RSPParser_dateref_return
 +
-+    pANTLR3_BASE_TREE INT37_tree;
++    pANTLR3_BASE_TREE INT34_tree;
 +    pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT;
 +    pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateintval;
 +    pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateref;
@@ -14093,18 +14409,18 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    INT37       = NULL;
-+    dateref36.tree = NULL;
++    INT34       = NULL;
++    dateref33.tree = NULL;
 +
-+    dateintval38.tree = NULL;
++    dateintval35.tree = NULL;
 +
-+    dateop39.tree = NULL;
++    dateop36.tree = NULL;
 +
-+    dateref40.tree = NULL;
++    dateref37.tree = NULL;
 +
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    INT37_tree   = NULL;
++    INT34_tree   = NULL;
 +
 +    stream_INT   = NULL;
 +    #define CREATE_stream_INT  if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); } 
@@ -14120,21 +14436,21 @@ index 0000000..c0f3e2a
 +        {
 +            //  RSP.g:70:9: ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) )
 +            
-+            ANTLR3_UINT32 alt7;
++            ANTLR3_UINT32 alt10;
 +
-+            alt7=2;
++            alt10=2;
 +
 +            switch ( LA(1) ) 
 +            {
 +            case DATE:
 +            case TODAY:
 +              {
-+                      alt7=1;
++                      alt10=1;
 +              }
 +                break;
 +            case INT:
 +              {
-+                      alt7=2;
++                      alt10=2;
 +              }
 +                break;
 +
@@ -14142,22 +14458,22 @@ index 0000000..c0f3e2a
 +                CONSTRUCTEX();
 +                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
 +                EXCEPTION->message      = (void *)"";
-+                EXCEPTION->decisionNum  = 7;
++                EXCEPTION->decisionNum  = 10;
 +                EXCEPTION->state        = 0;
 +
 +
 +                goto ruledatespecEx;
 +            }
 +
-+            switch (alt7
++            switch (alt10
 +            {
 +              case 1:
 +                  // RSP.g:70:11: dateref
 +                  {
 +                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
 +
-+                      FOLLOWPUSH(FOLLOW_dateref_in_datespec331);
-+                      dateref36=dateref(ctx);
++                      FOLLOWPUSH(FOLLOW_dateref_in_datespec353);
++                      dateref33=dateref(ctx);
 +
 +                      FOLLOWPOP();
 +                      if  (HASEXCEPTION())
@@ -14165,23 +14481,23 @@ index 0000000..c0f3e2a
 +                          goto ruledatespecEx;
 +                      }
 +
-+                      ADAPTOR->addChild(ADAPTOR, root_0, dateref36.tree);
++                      ADAPTOR->addChild(ADAPTOR, root_0, dateref33.tree);
 +
 +                  }
 +                  break;
 +              case 2:
 +                  // RSP.g:71:4: INT dateintval dateop dateref
 +                  {
-+                      INT37 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_datespec336); 
++                      INT34 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_datespec358); 
 +                      if  (HASEXCEPTION())
 +                      {
 +                          goto ruledatespecEx;
 +                      }
 +                       
-+                      CREATE_stream_INT; stream_INT->add(stream_INT, INT37, NULL);
++                      CREATE_stream_INT; stream_INT->add(stream_INT, INT34, NULL);
 +
-+                      FOLLOWPUSH(FOLLOW_dateintval_in_datespec338);
-+                      dateintval38=dateintval(ctx);
++                      FOLLOWPUSH(FOLLOW_dateintval_in_datespec360);
++                      dateintval35=dateintval(ctx);
 +
 +                      FOLLOWPOP();
 +                      if  (HASEXCEPTION())
@@ -14189,9 +14505,9 @@ index 0000000..c0f3e2a
 +                          goto ruledatespecEx;
 +                      }
 +
-+                      CREATE_stream_dateintval; stream_dateintval->add(stream_dateintval, dateintval38.tree, NULL);
-+                      FOLLOWPUSH(FOLLOW_dateop_in_datespec340);
-+                      dateop39=dateop(ctx);
++                      CREATE_stream_dateintval; stream_dateintval->add(stream_dateintval, dateintval35.tree, NULL);
++                      FOLLOWPUSH(FOLLOW_dateop_in_datespec362);
++                      dateop36=dateop(ctx);
 +
 +                      FOLLOWPOP();
 +                      if  (HASEXCEPTION())
@@ -14199,9 +14515,9 @@ index 0000000..c0f3e2a
 +                          goto ruledatespecEx;
 +                      }
 +
-+                      CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop39.tree, NULL);
-+                      FOLLOWPUSH(FOLLOW_dateref_in_datespec342);
-+                      dateref40=dateref(ctx);
++                      CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop36.tree, NULL);
++                      FOLLOWPUSH(FOLLOW_dateref_in_datespec364);
++                      dateref37=dateref(ctx);
 +
 +                      FOLLOWPOP();
 +                      if  (HASEXCEPTION())
@@ -14209,11 +14525,11 @@ index 0000000..c0f3e2a
 +                          goto ruledatespecEx;
 +                      }
 +
-+                      CREATE_stream_dateref; stream_dateref->add(stream_dateref, dateref40.tree, NULL);
++                      CREATE_stream_dateref; stream_dateref->add(stream_dateref, dateref37.tree, NULL);
 +
 +                       
 +                      /* AST REWRITE
-+                       * elements          : INT, dateintval, dateop, dateref
++                       * elements          : dateop, INT, dateintval, dateref
 +                       * token labels      : 
 +                       * rule labels       : retval
 +                       * token list labels : 
@@ -14283,7 +14599,7 @@ index 0000000..c0f3e2a
 +
 +/** 
 + * $ANTLR start dateref
-+ * RSP.g:74:1: dateref : ( DATE | TODAY );
++ * RSP.g:74:1: dateref : (date= DATE | today= TODAY );
 + */
 +static RSPParser_dateref_return
 +dateref(pRSPParser ctx)
@@ -14292,9 +14608,11 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    set41;
++    pANTLR3_COMMON_TOKEN    date;
++    pANTLR3_COMMON_TOKEN    today;
 +
-+    pANTLR3_BASE_TREE set41_tree;
++    pANTLR3_BASE_TREE date_tree;
++    pANTLR3_BASE_TREE today_tree;
 +
 +    /* Initialize rule variables
 +     */
@@ -14302,38 +14620,86 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    set41       = NULL;
++    date       = NULL;
++    today       = NULL;
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    set41_tree   = NULL;
++    date_tree   = NULL;
++    today_tree   = NULL;
 +
 +
 +    retval.tree  = NULL;
 +    {
-+        // RSP.g:74:9: ( DATE | TODAY )
-+        // RSP.g:
 +        {
-+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++            //  RSP.g:74:9: (date= DATE | today= TODAY )
++            
++            ANTLR3_UINT32 alt11;
 +
-+            set41=(pANTLR3_COMMON_TOKEN)LT(1);
-+            if ( ((LA(1) >= DATE) && (LA(1) <= TODAY)) )
-+            {
-+                CONSUME();
-+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set41)));
-+                PERRORRECOVERY=ANTLR3_FALSE;
-+            }
-+            else 
++            alt11=2;
++
++            switch ( LA(1) ) 
 +            {
++            case DATE:
++              {
++                      alt11=1;
++              }
++                break;
++            case TODAY:
++              {
++                      alt11=2;
++              }
++                break;
++
++            default:
 +                CONSTRUCTEX();
-+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
-+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
-+                EXCEPTION->expectingSet = &FOLLOW_set_in_dateref0;
-+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateref0);    goto ruledaterefEx;
++                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++                EXCEPTION->message      = (void *)"";
++                EXCEPTION->decisionNum  = 11;
++                EXCEPTION->state        = 0;
++
++
++                goto ruledaterefEx;
 +            }
 +
++            switch (alt11) 
++            {
++              case 1:
++                  // RSP.g:74:11: date= DATE
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
 +
-+        }
++                      date = (pANTLR3_COMMON_TOKEN) MATCHT(DATE, &FOLLOW_DATE_in_dateref388); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledaterefEx;
++                      }
++
++                      date_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, date));
++                      ADAPTOR->addChild(ADAPTOR, root_0, date_tree);
++
++
++                  }
++                  break;
++              case 2:
++                  // RSP.g:75:4: today= TODAY
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
 +
++                      today = (pANTLR3_COMMON_TOKEN) MATCHT(TODAY, &FOLLOW_TODAY_in_dateref395); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledaterefEx;
++                      }
++
++                      today_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, today));
++                      ADAPTOR->addChild(ADAPTOR, root_0, today_tree);
++
++
++                  }
++                  break;
++
++            }
++        }
 +    }
 +    
 +
@@ -14361,7 +14727,7 @@ index 0000000..c0f3e2a
 +
 +/** 
 + * $ANTLR start dateintval
-+ * RSP.g:78:1: dateintval : ( DAY | WEEK | MONTH | YEAR );
++ * RSP.g:78:1: dateintval : (day= DAY | week= WEEK | month= MONTH | year= YEAR );
 + */
 +static RSPParser_dateintval_return
 +dateintval(pRSPParser ctx)
@@ -14370,9 +14736,15 @@ index 0000000..c0f3e2a
 +
 +    pANTLR3_BASE_TREE root_0;
 +
-+    pANTLR3_COMMON_TOKEN    set42;
++    pANTLR3_COMMON_TOKEN    day;
++    pANTLR3_COMMON_TOKEN    week;
++    pANTLR3_COMMON_TOKEN    month;
++    pANTLR3_COMMON_TOKEN    year;
 +
-+    pANTLR3_BASE_TREE set42_tree;
++    pANTLR3_BASE_TREE day_tree;
++    pANTLR3_BASE_TREE week_tree;
++    pANTLR3_BASE_TREE month_tree;
++    pANTLR3_BASE_TREE year_tree;
 +
 +    /* Initialize rule variables
 +     */
@@ -14380,38 +14752,134 @@ index 0000000..c0f3e2a
 +
 +    root_0 = NULL;
 +
-+    set42       = NULL;
++    day       = NULL;
++    week       = NULL;
++    month       = NULL;
++    year       = NULL;
 +    retval.start = LT(1); retval.stop = retval.start;
 +
-+    set42_tree   = NULL;
++    day_tree   = NULL;
++    week_tree   = NULL;
++    month_tree   = NULL;
++    year_tree   = NULL;
 +
 +
 +    retval.tree  = NULL;
 +    {
-+        // RSP.g:79:2: ( DAY | WEEK | MONTH | YEAR )
-+        // RSP.g:
 +        {
-+            root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++            //  RSP.g:79:2: (day= DAY | week= WEEK | month= MONTH | year= YEAR )
++            
++            ANTLR3_UINT32 alt12;
 +
-+            set42=(pANTLR3_COMMON_TOKEN)LT(1);
-+            if ( ((LA(1) >= DAY) && (LA(1) <= YEAR)) )
-+            {
-+                CONSUME();
-+                ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set42)));
-+                PERRORRECOVERY=ANTLR3_FALSE;
-+            }
-+            else 
++            alt12=4;
++
++            switch ( LA(1) ) 
 +            {
++            case DAY:
++              {
++                      alt12=1;
++              }
++                break;
++            case WEEK:
++              {
++                      alt12=2;
++              }
++                break;
++            case MONTH:
++              {
++                      alt12=3;
++              }
++                break;
++            case YEAR:
++              {
++                      alt12=4;
++              }
++                break;
++
++            default:
 +                CONSTRUCTEX();
-+                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
-+                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;
-+                EXCEPTION->expectingSet = &FOLLOW_set_in_dateintval0;
-+                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateintval0);    goto ruledateintvalEx;
++                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++                EXCEPTION->message      = (void *)"";
++                EXCEPTION->decisionNum  = 12;
++                EXCEPTION->state        = 0;
++
++
++                goto ruledateintvalEx;
 +            }
 +
++            switch (alt12) 
++            {
++              case 1:
++                  // RSP.g:79:4: day= DAY
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      day = (pANTLR3_COMMON_TOKEN) MATCHT(DAY, &FOLLOW_DAY_in_dateintval408); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledateintvalEx;
++                      }
++
++                      day_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, day));
++                      ADAPTOR->addChild(ADAPTOR, root_0, day_tree);
 +
-+        }
 +
++                  }
++                  break;
++              case 2:
++                  // RSP.g:80:4: week= WEEK
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      week = (pANTLR3_COMMON_TOKEN) MATCHT(WEEK, &FOLLOW_WEEK_in_dateintval415); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledateintvalEx;
++                      }
++
++                      week_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, week));
++                      ADAPTOR->addChild(ADAPTOR, root_0, week_tree);
++
++
++                  }
++                  break;
++              case 3:
++                  // RSP.g:81:4: month= MONTH
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      month = (pANTLR3_COMMON_TOKEN) MATCHT(MONTH, &FOLLOW_MONTH_in_dateintval422); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledateintvalEx;
++                      }
++
++                      month_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, month));
++                      ADAPTOR->addChild(ADAPTOR, root_0, month_tree);
++
++
++                  }
++                  break;
++              case 4:
++                  // RSP.g:82:4: year= YEAR
++                  {
++                      root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++                      year = (pANTLR3_COMMON_TOKEN) MATCHT(YEAR, &FOLLOW_YEAR_in_dateintval429); 
++                      if  (HASEXCEPTION())
++                      {
++                          goto ruledateintvalEx;
++                      }
++
++                      year_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, year));
++                      ADAPTOR->addChild(ADAPTOR, root_0, year_tree);
++
++
++                  }
++                  break;
++
++            }
++        }
 +    }
 +    
 +
@@ -14457,7 +14925,7 @@ index 0000000..c0f3e2a
 + */
 diff --git a/src/pregen/RSPParser.h b/src/pregen/RSPParser.h
 new file mode 100644
-index 0000000..4b3bbfe
+index 0000000..1796c0a
 --- /dev/null
 +++ b/src/pregen/RSPParser.h
 @@ -0,0 +1,365 @@
@@ -14465,7 +14933,7 @@ index 0000000..4b3bbfe
 + *  This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
 + *
 + *     -  From the grammar source file : RSP.g
-+ *     -                            On : 2015-06-27 19:05:18
++ *     -                            On : 2016-01-01 12:23:42
 + *     -                for the parser : RSPParserParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -14841,7 +15309,7 @@ index 0000000..2a66bf3
 \ 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
+index 0000000..bd93752
 --- /dev/null
 +++ b/src/pregen/SMARTPL2SQL.c
 @@ -0,0 +1,1649 @@
@@ -14849,7 +15317,7 @@ index 0000000..c435f37
 + *  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
++ *     -                            On : 2016-01-01 12:23:44
 + *     -           for the tree parser : SMARTPL2SQLTreeParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -16008,7 +16476,7 @@ index 0000000..c435f37
 +                                                      }
 +                                                      else if (strcmp((char *)val, "url") == 0)
 +                                                      {
-+                                                              sprintf(str, "f.data_kind = %d", DATA_KIND_URL);
++                                                              sprintf(str, "f.data_kind = %d", DATA_KIND_HTTP);
 +                                                      }
 +                                                      else if (strcmp((char *)val, "spotify") == 0)
 +                                                      {
@@ -16496,7 +16964,7 @@ index 0000000..c435f37
 + */
 diff --git a/src/pregen/SMARTPL2SQL.h b/src/pregen/SMARTPL2SQL.h
 new file mode 100644
-index 0000000..322e8fd
+index 0000000..8e06de7
 --- /dev/null
 +++ b/src/pregen/SMARTPL2SQL.h
 @@ -0,0 +1,220 @@
@@ -16504,7 +16972,7 @@ index 0000000..322e8fd
 + *  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
++ *     -                            On : 2016-01-01 12:23:44
 + *     -           for the tree parser : SMARTPL2SQLTreeParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -16734,7 +17202,7 @@ index 0000000..85567d1
 \ 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
+index 0000000..91d6e99
 --- /dev/null
 +++ b/src/pregen/SMARTPLLexer.c
 @@ -0,0 +1,4168 @@
@@ -16742,7 +17210,7 @@ index 0000000..9ea1a83
 + *  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
++ *     -                            On : 2016-01-01 12:23:40
 + *     -                 for the lexer : SMARTPLLexerLexer *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -20908,7 +21376,7 @@ index 0000000..9ea1a83
 + */
 diff --git a/src/pregen/SMARTPLLexer.h b/src/pregen/SMARTPLLexer.h
 new file mode 100644
-index 0000000..9d73721
+index 0000000..87e8c7e
 --- /dev/null
 +++ b/src/pregen/SMARTPLLexer.h
 @@ -0,0 +1,248 @@
@@ -20916,7 +21384,7 @@ index 0000000..9d73721
 + *  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
++ *     -                            On : 2016-01-01 12:23:40
 + *     -                 for the lexer : SMARTPLLexerLexer *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -21162,7 +21630,7 @@ index 0000000..9d73721
 +/* 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
+index 0000000..f39e5ae
 --- /dev/null
 +++ b/src/pregen/SMARTPLParser.c
 @@ -0,0 +1,1812 @@
@@ -21170,7 +21638,7 @@ index 0000000..afe9f99
 + *  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
++ *     -                            On : 2016-01-01 12:23:40
 + *     -                for the parser : SMARTPLParserParser *
 + * Editing it, at least manually, is not wise. 
 + *
@@ -22980,7 +23448,7 @@ index 0000000..afe9f99
 + */
 diff --git a/src/pregen/SMARTPLParser.h b/src/pregen/SMARTPLParser.h
 new file mode 100644
-index 0000000..5360136
+index 0000000..38ef500
 --- /dev/null
 +++ b/src/pregen/SMARTPLParser.h
 @@ -0,0 +1,285 @@
@@ -22988,7 +23456,7 @@ index 0000000..5360136
 + *  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
++ *     -                            On : 2016-01-01 12:23:40
 + *     -                for the parser : SMARTPLParserParser *
 + * Editing it, at least manually, is not wise. 
 + *