diff --git a/sound/forked-daapd/Makefile b/sound/forked-daapd/Makefile
new file mode 100644
index 000000000..585fa4fe1
--- /dev/null
+++ b/sound/forked-daapd/Makefile
@@ -0,0 +1,66 @@
+#
+# Copyright (C) 2006-2014 OpenWrt.org
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=forked-daapd
+PKG_VERSION:=22.0
+PKG_RELEASE:=20141016
+PKG_REV:=61a4da215c05b621951aa3903d7d390fd1839537
+
+PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.bz2
+PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=git://github.com/ejurgensen/forked-daapd.git
+PKG_SOURCE_VERSION:=$(PKG_REV)
+PKG_FIXUP:=autoreconf
+PKG_USE_MIPS16:=0
+PKG_INSTALL:=1
+
+PKG_MAINTAINER:=Espen Jürgensen <espenjurgensen+openwrt@gmail.com>
+PKG_LICENSE:=GPL-2.0
+PKG_LICENSE_FILES:=COPYING
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/forked-daapd
+SECTION:=sound
+CATEGORY:=Sound
+TITLE:=Improved iTunes (DAAP) server. Support for Apple Remote and AirPlay.
+URL:=https://github.com/ejurgensen/forked-daapd
+DEPENDS:=+libgpg-error +libgcrypt +libgdbm +zlib +libexpat +libunistring \
+ +libevent +libdaemon +libantlr3c +confuse +glib2 +alsa-lib +libffmpeg-full \
+ +mxml +libavl +avahi-daemon +libavahi-client +sqlite3-cli +libplist
+endef
+
+define Package/forked-daapd/conffiles
+/etc/forked-daapd.conf
+endef
+
+CONFIGURE_ARGS += \
+ --enable-itunes
+
+# Fix for libevent
+TARGET_CPPFLAGS += -I$(STAGING_DIR)/usr/include/libevent
+TARGET_LDFLAGS += -L$(STAGING_DIR)/usr/lib/libevent
+
+TARGET_CFLAGS += $(FPIC)
+TARGET_LDFLAGS += -Wl,-rpath-link,$(STAGING_DIR)/usr/lib
+
+define Package/forked-daapd/install
+ $(INSTALL_DIR) $(1)/etc
+ $(INSTALL_DATA) ./files/forked-daapd.conf $(1)/etc/
+ $(INSTALL_DIR) $(1)/usr/lib
+ $(INSTALL_DIR) $(1)/usr/lib/forked-daapd
+ $(INSTALL_BIN) $(PKG_INSTALL_DIR)/usr/lib/forked-daapd/* $(1)/usr/lib/forked-daapd/
+ $(INSTALL_DIR) $(1)/usr/sbin
+ $(INSTALL_BIN) $(PKG_INSTALL_DIR)/usr/sbin/forked-daapd $(1)/usr/sbin/
+ $(INSTALL_DIR) $(1)/etc/init.d
+ $(INSTALL_BIN) ./files/forked-daapd.init $(1)/etc/init.d/forked-daapd
+endef
+
+$(eval $(call BuildPackage,forked-daapd))
diff --git a/sound/forked-daapd/files/forked-daapd.conf b/sound/forked-daapd/files/forked-daapd.conf
new file mode 100644
index 000000000..e0b3c0ccb
--- /dev/null
+++ b/sound/forked-daapd/files/forked-daapd.conf
@@ -0,0 +1,139 @@
+# A quick guide to configuring forked-daapd:
+#
+# For regular use, the most important setting to configure is "directories",
+# which should be the location of your media. Whatever user you have set as
+# "uid" must have read access to this location. Also make sure to add the user.
+# If the location is a network mount, please see the README.
+#
+# In all likelihood, that's all you need to do!
+
+general {
+ # Username
+ uid = "daapd"
+ logfile = "/var/log/forked-daapd.log"
+ # Database location
+ db_path = "/var/run/forked-daapd.db"
+ # Available levels: fatal, log, warning, info, debug, spam
+ loglevel = log
+ # Admin password for the non-existent web interface
+ admin_password = "unused"
+ # Enable/disable IPv6
+ ipv6 = no
+ # Location of DAAP cache
+ daapcache_path = "/var/run/daapcache.db"
+ # DAAP requests that take longer than this threshold (in msec) get their
+ # replies cached for next time. Set to 0 to disable caching.
+# daapcache_threshold = 1000
+}
+
+# Library configuration
+library {
+ # Name of the library as displayed by the clients
+ # %h: hostname, %v: version
+ name = "My Music on %h"
+ # TCP port to listen on. Default port is 3689 (daap)
+ port = 3689
+ # Password for the library. Optional.
+# password = ""
+
+ # Directories to index
+ directories = { "/srv/music" }
+
+ # Directories containing podcasts
+ # For each directory that is indexed the path is matched against these
+ # names. If there is a match all items in the directory are marked as
+ # podcasts. Eg. if you index /srv/music, and your podcasts are in
+ # /srv/music/Podcasts, you can set this to "/Podcasts".
+ # (changing this setting only takes effect after rescan, see the README)
+ podcasts = { "/Podcasts" }
+
+ # Directories containing audiobooks
+ # For each directory that is indexed the path is matched against these
+ # names. If there is a match all items in the directory are marked as
+ # audiobooks.
+ # (changing this setting only takes effect after rescan, see the README)
+ audiobooks = { "/Audiobooks" }
+
+ # Directories containing compilations (eg soundtracks)
+ # For each directory that is indexed the path is matched against these
+ # names. If there is a match all items in the directory are marked as
+ # compilations.
+ # (changing this setting only takes effect after rescan, see the README)
+ compilations = { "/Compilations" }
+
+ # Compilations usually have many artists, and if you don't want every
+ # artist to be listed when artist browsing in Remote, you can set
+ # a single name which will be used for all music in the compilation dir
+ # (changing this setting only takes effect after rescan, see the README)
+ compilation_artist = "Various artists"
+
+ # There are 5 default playlists: "Library", "Music", "Movies", "TV Shows"
+ # and "Podcasts". Here you can change the names of these playlists.
+# name_library = "Library"
+# name_music = "Music"
+# name_movies = "Movies"
+# name_tvshows = "TV Shows"
+# name_podcasts = "Podcasts"
+# name_audiobooks = "Audiobooks"
+
+ # Artwork file names (without file type extension)
+ # forked-daapd will look for jpg and png files with these base names
+# artwork_basenames = { "artwork", "cover", "Folder" }
+
+ # File types the scanner should ignore
+ # Non-audio files will never be added to the database, but here you
+ # can prevent the scanner from even probing them. This might improve
+ # scan time. By default .db and .ini are ignored.
+# filetypes_ignore = { ".db", ".ini" }
+
+ # Disable startup file scanning
+ # When forked-daapd starts it will do an initial file scan of your
+ # library (and then watch it for changes). If you are sure your library
+ # never changes while forked-daapd is not running, you can disable the
+ # initial file scan and save some system ressources. Disabling this scan
+ # may lead to forked-daapd's database coming out of sync with the
+ # library. If that happens read the instructions in the README on how
+ # to trigger a full rescan.
+# filescan_disable = false
+
+ # Should iTunes metadata override ours?
+# itunes_overrides = false
+
+ # Formats: mp4a, mp4v, mpeg, alac, flac, mpc, ogg, wma, wmal, wmav, aif, wav
+ # Formats that should never be transcoded
+# no_transcode = { "alac", "mp4a" }
+ # Formats that should always be transcoded
+# force_transcode = { "ogg", "flac" }
+}
+
+# Local audio output
+audio {
+ # Name - used in the speaker list in Remote
+ nickname = "OpenWrt"
+ # Audio device name for local audio output
+# card = "default"
+ # Mixer channel to use for volume control - ALSA/Linux only
+ # If not set, PCM will be used if available, otherwise Master.
+# mixer = ""
+}
+
+# AirPlay/Airport Express device settings
+# (make sure you get the capitalization of the device name right)
+#airplay "My AirPlay device" {
+ # forked-daapd's volume goes to 11! If that's more than you can handle
+ # you can set a lower value here
+# max_volume = 11
+ # AirPlay password
+# password = "s1kr3t"
+#}
+
+# Spotify settings (only have effect if Spotify enabled - see README/INSTALL)
+spotify {
+ # Directory where user settings should be stored (credentials)
+# settings_dir = "/var/cache/forked-daapd/libspotify"
+ # Cache directory
+# cache_dir = "/tmp"
+ # Set preferred bitrate for music streaming
+ # 0: No preference (default), 1: 96kbps, 2: 160kbps, 3: 320kbps
+# bitrate = 0
+}
diff --git a/sound/forked-daapd/files/forked-daapd.init b/sound/forked-daapd/files/forked-daapd.init
new file mode 100644
index 000000000..3ae38f9ab
--- /dev/null
+++ b/sound/forked-daapd/files/forked-daapd.init
@@ -0,0 +1,15 @@
+#!/bin/sh /etc/rc.common
+# Copyright (C) 2014 OpenWrt.org
+
+START=99
+BIN=/usr/sbin/forked-daapd
+PID=/var/run/forked-daapd.pid
+SSD=start-stop-daemon
+
+start() {
+ $SSD -p $PID -S -x $BIN -- -P $PID
+}
+
+stop() {
+ $SSD -p $PID -K -s SIGINT
+}
diff --git a/sound/forked-daapd/patches/010-include_pregen.patch b/sound/forked-daapd/patches/010-include_pregen.patch
new file mode 100644
index 000000000..2518ddae1
--- /dev/null
+++ b/sound/forked-daapd/patches/010-include_pregen.patch
@@ -0,0 +1,14782 @@
+diff --git a/src/pregen/DAAP.u b/src/pregen/DAAP.u
+new file mode 100644
+index 0000000..3de527b
+--- /dev/null
++++ b/src/pregen/DAAP.u
+@@ -0,0 +1,6 @@
++DAAPParser.c : DAAP.g
++./DAAP.tokens : DAAP.g
++DAAPParser.h : DAAP.g
++DAAPLexer.c : DAAP.g
++DAAPLexer.h : DAAP.g
++ANTLR_PRODUCTS += DAAPParser.c ./DAAP.tokens DAAPParser.h DAAPLexer.c DAAPLexer.h
+\ No newline at end of file
+diff --git a/src/pregen/DAAP2SQL.c b/src/pregen/DAAP2SQL.c
+new file mode 100644
+index 0000000..3f94589
+--- /dev/null
++++ b/src/pregen/DAAP2SQL.c
+@@ -0,0 +1,929 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : DAAP2SQL.g
++ * - On : 2014-09-30 21:42:43
++ * - for the tree parser : DAAP2SQLTreeParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++
++/* =============================================================================
++ * This is what the grammar programmer asked us to put at the top of every file.
++ */
++
++ #include <stdio.h>
++ #include <stdlib.h>
++ #include <string.h>
++ #include <limits.h>
++ #include <errno.h>
++
++ #include "logger.h"
++ #include "db.h"
++ #include "daap_query.h"
++
++/* End of Header action.
++ * =============================================================================
++ */
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "DAAP2SQL.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pDAAP2SQL_##scope##_SCOPE
++#define SCOPE_STACK(scope) pDAAP2SQL_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pDAAP2SQL_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pDAAP2SQL_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++/* Macros for accessing things in the parser
++ */
++
++#undef PARSER
++#undef RECOGNIZER
++#undef HAVEPARSEDRULE
++#undef INPUT
++#undef STRSTREAM
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef MATCHT
++#undef MATCHANYT
++#undef FOLLOWSTACK
++#undef FOLLOWPUSH
++#undef FOLLOWPOP
++#undef PRECOVER
++#undef PREPORTERROR
++#undef LA
++#undef LT
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef PERRORRECOVERY
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef RECOVERFROMMISMATCHEDSET
++#undef RECOVERFROMMISMATCHEDELEMENT
++#undef BACKTRACKING
++#undef ADAPTOR
++#undef RULEMEMO
++#undef SEEK
++#undef INDEX
++#undef DBG
++
++#define PARSER ctx->pTreeParser
++#define RECOGNIZER PARSER->rec
++#define PSRSTATE RECOGNIZER->state
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define INPUT PARSER->ctnstream
++#define ISTREAM INPUT->tnstream->istream
++#define STRSTREAM INPUT->tnstream
++#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION PSRSTATE->exception
++#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
++#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
++#define FOLLOWSTACK PSRSTATE->following
++#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
++#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
++#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
++#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
++#define LA(n) ISTREAM->_LA(ISTREAM, n)
++#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define CONSUME() ISTREAM->consume(ISTREAM)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define PERRORRECOVERY PSRSTATE->errorRecovery
++#define FAILEDFLAG PSRSTATE->failed
++#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
++#define BACKTRACKING PSRSTATE->backtracking
++#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
++#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
++#define ADAPTOR INPUT->adaptor
++#define RULEMEMO PSRSTATE->ruleMemo
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define INDEX() ISTREAM->index(ISTREAM)
++#define DBG RECOGNIZER->debugger
++
++
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++
++/** \brief Table of all token names in symbolic order, mainly used for
++ * error reporting.
++ */
++pANTLR3_UINT8 DAAP2SQLTokenNames[8+4]
++ = {
++ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
++ (pANTLR3_UINT8) "<EOR>",
++ (pANTLR3_UINT8) "<DOWN>",
++ (pANTLR3_UINT8) "<UP>",
++ (pANTLR3_UINT8) "NEWLINE",
++ (pANTLR3_UINT8) "OPOR",
++ (pANTLR3_UINT8) "OPAND",
++ (pANTLR3_UINT8) "LPAR",
++ (pANTLR3_UINT8) "RPAR",
++ (pANTLR3_UINT8) "STR",
++ (pANTLR3_UINT8) "QUOTE",
++ (pANTLR3_UINT8) "ESCAPED"
++ };
++
++
++
++// Forward declare the locally static matching functions we have generated.
++//
++static pANTLR3_STRING query (pDAAP2SQL ctx);
++static DAAP2SQL_expr_return expr (pDAAP2SQL ctx);
++static void DAAP2SQLFree(pDAAP2SQL ctx);
++/* For use in tree output where we are accumulating rule labels via label += ruleRef
++ * we need a function that knows how to free a return scope when the list is destroyed.
++ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
++ */
++static void ANTLR3_CDECL freeScope(void * scope)
++{
++ ANTLR3_FREE(scope);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "DAAP2SQL.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++/** \brief Create a new DAAP2SQL parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pDAAP2SQL
++DAAP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
++{
++ // See if we can create a new parser with the standard constructor
++ //
++ return DAAP2SQLNewSSD(instream, NULL);
++}
++
++/** \brief Create a new DAAP2SQL parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pDAAP2SQL
++DAAP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pDAAP2SQL ctx; /* Context structure we will build and return */
++
++ ctx = (pDAAP2SQL) ANTLR3_CALLOC(1, sizeof(DAAP2SQL));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for parser context
++ //
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * the base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 parser function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in DAAP2SQL.h here, in order that you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base Tree parser/recognizer, using the supplied tree node stream
++ */
++ ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
++ /* Install the implementation of our DAAP2SQL interface
++ */
++ ctx->query = query;
++ ctx->expr = expr;
++ ctx->free = DAAP2SQLFree;
++ ctx->getGrammarFileName = getGrammarFileName;
++
++ /* Install the scope pushing methods.
++ */
++
++
++
++
++
++ /* Install the token table
++ */
++ PSRSTATE->tokenNames = DAAP2SQLTokenNames;
++
++
++ /* Return the newly built parser to the caller
++ */
++ return ctx;
++}
++
++/** Free the parser resources
++ */
++ static void
++ DAAP2SQLFree(pDAAP2SQL ctx)
++ {
++ /* Free any scope memory
++ */
++
++
++ // Free this parser
++ //
++ ctx->pTreeParser->free(ctx->pTreeParser);
++ ANTLR3_FREE(ctx);
++
++ /* Everything is released, so we can return
++ */
++ return;
++ }
++
++/** Return token names used by this tree parser
++ *
++ * The returned pointer is used as an index into the token names table (using the token
++ * number as the index).
++ *
++ * \return Pointer to first char * in the table.
++ */
++static pANTLR3_UINT8 *getTokenNames()
++{
++ return DAAP2SQLTokenNames;
++}
++
++
++ struct dmap_query_field_map {
++ char *dmap_field;
++ char *db_col;
++ int as_int;
++ };
++
++ /* gperf static hash, daap_query.gperf */
++ #include "daap_query_hash.c"
++
++
++/* Declare the bitsets
++ */
++
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query70 */
++static ANTLR3_BITWORD FOLLOW_expr_in_query70_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_query70 = { FOLLOW_expr_in_query70_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPAND_in_expr95 */
++static ANTLR3_BITWORD FOLLOW_OPAND_in_expr95_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_OPAND_in_expr95 = { FOLLOW_OPAND_in_expr95_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr101 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000260) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr101 = { FOLLOW_expr_in_expr101_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr107 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr107 = { FOLLOW_expr_in_expr107_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPOR_in_expr118 */
++static ANTLR3_BITWORD FOLLOW_OPOR_in_expr118_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_OPOR_in_expr118 = { FOLLOW_OPOR_in_expr118_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr124 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr124_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000260) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr124 = { FOLLOW_expr_in_expr124_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr130 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr130_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr130 = { FOLLOW_expr_in_expr130_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_expr140 */
++static ANTLR3_BITWORD FOLLOW_STR_in_expr140_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_expr140 = { FOLLOW_STR_in_expr140_bits, 1 };
++
++
++
++
++/* ==============================================
++ * Parsing rules
++ */
++/**
++ * $ANTLR start query
++ * DAAP2SQL.g:50:1: query returns [ pANTLR3_STRING result ] : e= expr ;
++ */
++static pANTLR3_STRING
++query(pDAAP2SQL ctx)
++{
++ pANTLR3_STRING result = NULL;
++
++ DAAP2SQL_expr_return e;
++ #undef RETURN_TYPE_e
++ #define RETURN_TYPE_e DAAP2SQL_expr_return
++
++ /* Initialize rule variables
++ */
++
++
++ result= NULL;
++ {
++ // DAAP2SQL.g:52:2: (e= expr )
++ // DAAP2SQL.g:52:4: e= expr
++ {
++ FOLLOWPUSH(FOLLOW_expr_in_query70);
++ e=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ {
++
++ if (!e.valid)
++ {
++ result= NULL;
++ }
++ else
++ {
++ result= e.result->factory->newRaw(e.result->factory);
++ result->append8(result, "(");
++ result->appendS(result, e.result);
++ result->append8(result, ")");
++ }
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulequeryEx; /* Prevent compiler warnings */
++ rulequeryEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return result;
++}
++/* $ANTLR end query */
++
++/**
++ * $ANTLR start expr
++ * DAAP2SQL.g:68:1: expr returns [ pANTLR3_STRING result, int valid ] : ( ^( OPAND a= expr b= expr ) | ^( OPOR a= expr b= expr ) | STR );
++ */
++static DAAP2SQL_expr_return
++expr(pDAAP2SQL ctx)
++{
++ DAAP2SQL_expr_return retval;
++
++ pANTLR3_BASE_TREE STR1;
++ DAAP2SQL_expr_return a;
++ #undef RETURN_TYPE_a
++ #define RETURN_TYPE_a DAAP2SQL_expr_return
++
++ DAAP2SQL_expr_return b;
++ #undef RETURN_TYPE_b
++ #define RETURN_TYPE_b DAAP2SQL_expr_return
++
++ /* Initialize rule variables
++ */
++
++
++ retval.result= NULL; retval.valid= 1;
++ STR1 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ {
++ // DAAP2SQL.g:70:2: ( ^( OPAND a= expr b= expr ) | ^( OPOR a= expr b= expr ) | STR )
++
++ ANTLR3_UINT32 alt1;
++
++ alt1=3;
++
++ switch ( LA(1) )
++ {
++ case OPAND:
++ {
++ alt1=1;
++ }
++ break;
++ case OPOR:
++ {
++ alt1=2;
++ }
++ break;
++ case STR:
++ {
++ alt1=3;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 0;
++
++
++ goto ruleexprEx;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // DAAP2SQL.g:70:4: ^( OPAND a= expr b= expr )
++ {
++ MATCHT(OPAND, &FOLLOW_OPAND_in_expr95);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr101);
++ a=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr107);
++ b=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ if (!a.valid || !b.valid)
++ {
++ retval.valid= 0;
++ }
++ else
++ {
++ retval.result= a.result->factory->newRaw(a.result->factory);
++ retval.result->append8(retval.result, "(");
++ retval.result->appendS(retval.result, a.result);
++ retval.result->append8(retval.result, " AND ");
++ retval.result->appendS(retval.result, b.result);
++ retval.result->append8(retval.result, ")");
++ }
++
++ }
++
++ }
++ break;
++ case 2:
++ // DAAP2SQL.g:86:4: ^( OPOR a= expr b= expr )
++ {
++ MATCHT(OPOR, &FOLLOW_OPOR_in_expr118);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr124);
++ a=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr130);
++ b=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ if (!a.valid || !b.valid)
++ {
++ retval.valid= 0;
++ }
++ else
++ {
++ retval.result= a.result->factory->newRaw(a.result->factory);
++ retval.result->append8(retval.result, "(");
++ retval.result->appendS(retval.result, a.result);
++ retval.result->append8(retval.result, " OR ");
++ retval.result->appendS(retval.result, b.result);
++ retval.result->append8(retval.result, ")");
++ }
++
++ }
++
++ }
++ break;
++ case 3:
++ // DAAP2SQL.g:102:4: STR
++ {
++ STR1 = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_expr140);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ pANTLR3_STRING str;
++ pANTLR3_UINT8 field;
++ pANTLR3_UINT8 val;
++ pANTLR3_UINT8 escaped;
++ ANTLR3_UINT8 op;
++ int neg_op;
++ const struct dmap_query_field_map *dqfm;
++ char *end;
++ long long llval;
++
++ escaped = NULL;
++
++ retval.result= (STR1->getText(STR1))->factory->newRaw((STR1->getText(STR1))->factory);
++
++ str = (STR1->getText(STR1))->toUTF8((STR1->getText(STR1)));
++
++ /* NOTE: the lexer delivers the string without quotes
++ which may not be obvious from the grammar due to embedded code
++ */
++
++ /* Make daap.songalbumid:0 a no-op */
++ if (strcmp((char *)str->chars, "daap.songalbumid:0") == 0)
++ {
++ retval.result->append8(retval.result, "1 = 1");
++
++ goto STR_out;
++ }
++
++ field = str->chars;
++
++ val = field;
++ while ((*val != '\0') && ((*val == '.')
++ || (*val == '-')
++ || ((*val >= 'a') && (*val <= 'z'))
++ || ((*val >= 'A') && (*val <= 'Z'))
++ || ((*val >= '0') && (*val <= '9'))))
++ {
++ val++;
++ }
++
++ if (*field == '\0')
++ {
++ DPRINTF(E_LOG, L_DAAP, "No field name found in clause '%s'\n", field);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ if (*val == '\0')
++ {
++ DPRINTF(E_LOG, L_DAAP, "No operator found in clause '%s'\n", field);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ op = *val;
++ *val = '\0';
++ val++;
++
++ if (op == '!')
++ {
++ if (*val == '\0')
++ {
++ DPRINTF(E_LOG, L_DAAP, "Negation found but operator missing in clause '%s%c'\n", field, op);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ neg_op = 1;
++ op = *val;
++ val++;
++ }
++ else
++ neg_op = 0;
++
++ /* Lookup DMAP field in the query field map */
++ dqfm = daap_query_field_lookup((char *)field, strlen((char *)field));
++ if (!dqfm)
++ {
++ DPRINTF(E_LOG, L_DAAP, "DMAP field '%s' is not a valid field in queries\n", field);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ /* Empty values OK for string fields, NOK for integer */
++ if (*val == '\0')
++ {
++ if (dqfm->as_int)
++ {
++ DPRINTF(E_LOG, L_DAAP, "No value given in clause '%s%s%c'\n", field, (neg_op) ? "!" : "", op);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ /* Need to check against NULL too */
++ if (op == ':')
++ retval.result->append8(retval.result, "(");
++ }
++
++ retval.result->append8(retval.result, dqfm->db_col);
++
++ /* Int field: check integer conversion */
++ if (dqfm->as_int)
++ {
++ errno = 0;
++ llval = strtoll((const char *)val, &end, 10);
++
++ if (((errno == ERANGE) && ((llval == LLONG_MAX) || (llval == LLONG_MIN)))
++ || ((errno != 0) && (llval == 0)))
++ {
++ DPRINTF(E_LOG, L_DAAP, "Value '%s' in clause '%s%s%c%s' does not convert to an integer type\n",
++ val, field, (neg_op) ? "!" : "", op, val);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ if (end == (char *)val)
++ {
++ DPRINTF(E_LOG, L_DAAP, "Value '%s' in clause '%s%s%c%s' does not represent an integer value\n",
++ val, field, (neg_op) ? "!" : "", op, val);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ *end = '\0'; /* Cut out potential garbage - we're being kind */
++ }
++ /* String field: escape string, check for '*' */
++ else
++ {
++ if (op != ':')
++ {
++ DPRINTF(E_LOG, L_DAAP, "Operation '%c' not valid for string values\n", op);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ escaped = (pANTLR3_UINT8)db_escape_string((char *)val);
++ if (!escaped)
++ {
++ DPRINTF(E_LOG, L_DAAP, "Could not escape value\n");
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ }
++
++ val = escaped;
++
++ if (val[0] == '*')
++ {
++ op = '%';
++ val[0] = '%';
++ }
++
++ if (val[strlen((char *)val) - 1] == '*')
++ {
++ op = '%';
++ val[strlen((char *)val) - 1] = '%';
++ }
++ }
++
++ switch(op)
++ {
++ case ':':
++ if (neg_op)
++ retval.result->append8(retval.result, " <> ");
++ else
++ retval.result->append8(retval.result, " = ");
++ break;
++
++ case '+':
++ if (neg_op)
++ retval.result->append8(retval.result, " <= ");
++ else
++ retval.result->append8(retval.result, " > ");
++ break;
++
++ case '-':
++ if (neg_op)
++ retval.result->append8(retval.result, " >= ");
++ else
++ retval.result->append8(retval.result, " < ");
++ break;
++
++ case '%':
++ retval.result->append8(retval.result, " LIKE ");
++ break;
++
++ default:
++ if (neg_op)
++ DPRINTF(E_LOG, L_DAAP, "Missing or unknown operator '%c' in clause '%s!%c%s'\n", op, field, op, val);
++ else
++ DPRINTF(E_LOG, L_DAAP, "Unknown operator '%c' in clause '%s%c%s'\n", op, field, op, val);
++ retval.valid= 0;
++ goto STR_result_valid_0; /* ABORT */
++ break;
++ }
++
++ if (!dqfm->as_int)
++ retval.result->append8(retval.result, "'");
++
++ retval.result->append8(retval.result, (const char *)val);
++
++ if (!dqfm->as_int)
++ retval.result->append8(retval.result, "'");
++
++ /* For empty string value, we need to check against NULL too */
++ if ((*val == '\0') && (op == ':'))
++ {
++ if (neg_op)
++ retval.result->append8(retval.result, " AND ");
++ else
++ retval.result->append8(retval.result, " OR ");
++
++ retval.result->append8(retval.result, dqfm->db_col);
++
++ if (neg_op)
++ retval.result->append8(retval.result, " IS NOT NULL");
++ else
++ retval.result->append8(retval.result, " IS NULL");
++
++ retval.result->append8(retval.result, ")");
++ }
++
++ STR_result_valid_0: /* bail out label */
++ ;
++
++ if (escaped)
++ free(escaped);
++
++ STR_out: /* get out of here */
++ ;
++
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleexprEx; /* Prevent compiler warnings */
++ ruleexprEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end expr */
++/* End of parsing rules
++ * ==============================================
++ */
++
++/* ==============================================
++ * Syntactic predicates
++ */
++/* End of syntactic predicates
++ * ==============================================
++ */
++
++
++
++
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/DAAP2SQL.h b/src/pregen/DAAP2SQL.h
+new file mode 100644
+index 0000000..e170f6c
+--- /dev/null
++++ b/src/pregen/DAAP2SQL.h
+@@ -0,0 +1,195 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : DAAP2SQL.g
++ * - On : 2014-09-30 21:42:43
++ * - for the tree parser : DAAP2SQLTreeParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The tree parser DAAP2SQL has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pDAAP2SQL, which is returned from a call to DAAP2SQLNew().
++ *
++ * The methods in pDAAP2SQL are as follows:
++ *
++ * - pANTLR3_STRING pDAAP2SQL->query(pDAAP2SQL)
++ * - DAAP2SQL_expr_return pDAAP2SQL->expr(pDAAP2SQL)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _DAAP2SQL_H
++#define _DAAP2SQL_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct DAAP2SQL_Ctx_struct DAAP2SQL, * pDAAP2SQL;
++
++
++
++ #include <stdio.h>
++ #include <stdlib.h>
++ #include <string.h>
++ #include <limits.h>
++ #include <errno.h>
++
++ #include "logger.h"
++ #include "db.h"
++ #include "daap_query.h"
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++typedef struct DAAP2SQL_expr_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ pANTLR3_STRING result;
++ int valid;
++}
++ DAAP2SQL_expr_return;
++
++
++
++/** Context tracking structure for DAAP2SQL
++ */
++struct DAAP2SQL_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_TREE_PARSER pTreeParser;
++
++
++ pANTLR3_STRING (*query) (struct DAAP2SQL_Ctx_struct * ctx);
++ DAAP2SQL_expr_return (*expr) (struct DAAP2SQL_Ctx_struct * ctx);
++ // Delegated rules
++ const char * (*getGrammarFileName)();
++ void (*free) (struct DAAP2SQL_Ctx_struct * ctx);
++
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pDAAP2SQL DAAP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream);
++ANTLR3_API pDAAP2SQL DAAP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the tree parser will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define STR 9
++#define QUOTE 10
++#define NEWLINE 4
++#define LPAR 7
++#define OPOR 5
++#define RPAR 8
++#define ESCAPED 11
++#define OPAND 6
++#define EOF -1
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for DAAP2SQL
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/DAAP2SQL.u b/src/pregen/DAAP2SQL.u
+new file mode 100644
+index 0000000..385d80b
+--- /dev/null
++++ b/src/pregen/DAAP2SQL.u
+@@ -0,0 +1,5 @@
++DAAP2SQL.g: DAAP.tokens
++DAAP2SQL.c : DAAP2SQL.g
++./DAAP2SQL.tokens : DAAP2SQL.g
++DAAP2SQL.h : DAAP2SQL.g
++ANTLR_PRODUCTS += DAAP2SQL.c ./DAAP2SQL.tokens DAAP2SQL.h
+\ No newline at end of file
+diff --git a/src/pregen/DAAPLexer.c b/src/pregen/DAAPLexer.c
+new file mode 100644
+index 0000000..12e7ef3
+--- /dev/null
++++ b/src/pregen/DAAPLexer.c
+@@ -0,0 +1,1101 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : DAAP.g
++ * - On : 2014-09-30 21:42:40
++ * - for the lexer : DAAPLexerLexer *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "DAAPLexer.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pDAAPLexer_##scope##_SCOPE
++#define SCOPE_STACK(scope) pDAAPLexer_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pDAAPLexer_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pDAAPLexer_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++
++/* Macros for accessing things in a lexer
++ */
++#undef LEXER
++#undef RECOGNIZER
++#undef RULEMEMO
++#undef GETCHARINDEX
++#undef GETLINE
++#undef GETCHARPOSITIONINLINE
++#undef EMIT
++#undef EMITNEW
++#undef MATCHC
++#undef MATCHS
++#undef MATCHRANGE
++#undef LTOKEN
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef INPUT
++#undef STRSTREAM
++#undef LA
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef LRECOVER
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef BACKTRACKING
++#undef MATCHANY
++#undef MEMOIZE
++#undef HAVEPARSEDRULE
++#undef GETTEXT
++#undef INDEX
++#undef SEEK
++#undef PUSHSTREAM
++#undef POPSTREAM
++#undef SETTEXT
++#undef SETTEXT8
++
++#define LEXER ctx->pLexer
++#define RECOGNIZER LEXER->rec
++#define LEXSTATE RECOGNIZER->state
++#define TOKSOURCE LEXSTATE->tokSource
++#define GETCHARINDEX() LEXER->getCharIndex(LEXER)
++#define GETLINE() LEXER->getLine(LEXER)
++#define GETTEXT() LEXER->getText(LEXER)
++#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
++#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER)
++#define EMITNEW(t) LEXER->emitNew(LEXER, t)
++#define MATCHC(c) LEXER->matchc(LEXER, c)
++#define MATCHS(s) LEXER->matchs(LEXER, s)
++#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2)
++#define MATCHANY() LEXER->matchAny(LEXER)
++#define LTOKEN LEXSTATE->token
++#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE)
++#define BACKTRACKING LEXSTATE->backtracking
++#define FAILEDFLAG LEXSTATE->failed
++#define INPUT LEXER->input
++#define STRSTREAM INPUT
++#define ISTREAM INPUT->istream
++#define INDEX() ISTREAM->index(ISTREAM)
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken)
++#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION LEXSTATE->exception
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define LRECOVER() LEXER->recover(LEXER)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str)
++#define POPSTREAM() LEXER->popCharStream(LEXER)
++#define SETTEXT(str) LEXSTATE->text = str
++#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken)
++#define USER1 LEXSTATE->user1
++#define USER2 LEXSTATE->user2
++#define USER3 LEXSTATE->user3
++#define CUSTOM LEXSTATE->custom
++#define RULEMEMO LEXSTATE->ruleMemo
++#define DBG RECOGNIZER->debugger
++
++/* If we have been told we can rely on the standard 8 bit or 16 bit input
++ * stream, then we can define our macros to use the direct pointers
++ * in the input object, which is much faster than indirect calls. This
++ * is really only significant to lexers with a lot of fragment rules (which
++ * do not place LA(1) in a temporary at the moment) and even then
++ * only if there is a lot of input (order of say 1M or so).
++ */
++#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
++
++# ifdef ANTLR3_INLINE_INPUT_ASCII
++
++/* 8 bit "ASCII" (actually any 8 bit character set) */
++
++# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar))
++# define DATAP ((pANTLR3_UINT8)(INPUT->data))
++
++# else
++
++# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar))
++# define DATAP ((pANTLR3_UINT16)(INPUT->data))
++
++# endif
++
++# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
++# define CONSUME() \
++{ \
++ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \
++ { \
++ INPUT->charPositionInLine++; \
++ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \
++ { \
++ INPUT->line++; \
++ INPUT->charPositionInLine = 0; \
++ INPUT->currentLine = (void *)(NEXTCHAR + 1); \
++ } \
++ INPUT->nextChar = (void *)(NEXTCHAR + 1); \
++ } \
++}
++
++#else
++
++// Pick up the input character by calling the input stream implementation.
++//
++#define CONSUME() INPUT->istream->consume(INPUT->istream)
++#define LA(n) INPUT->istream->_LA(INPUT->istream, n)
++
++#endif
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++/* Forward declare the locally static matching functions we have generated and any predicate functions.
++ */
++static ANTLR3_INLINE void mQUOTE (pDAAPLexer ctx);
++static ANTLR3_INLINE void mLPAR (pDAAPLexer ctx);
++static ANTLR3_INLINE void mRPAR (pDAAPLexer ctx);
++static ANTLR3_INLINE void mOPAND (pDAAPLexer ctx);
++static ANTLR3_INLINE void mOPOR (pDAAPLexer ctx);
++static ANTLR3_INLINE void mNEWLINE (pDAAPLexer ctx);
++static ANTLR3_INLINE void mSTR (pDAAPLexer ctx);
++static ANTLR3_INLINE void mESCAPED (pDAAPLexer ctx);
++static ANTLR3_INLINE void mTokens (pDAAPLexer ctx);
++static void DAAPLexerFree(pDAAPLexer ctx);
++
++/* =========================================================================
++ * Lexer matching rules end.
++ * =========================================================================
++ */
++
++
++
++static void
++DAAPLexerFree (pDAAPLexer ctx)
++{
++ LEXER->free(LEXER);
++
++ ANTLR3_FREE(ctx);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "DAAP.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++
++/** \brief Create a new lexer called DAAPLexer
++ *
++ * \param[in] instream Pointer to an initialized input stream
++ * \return
++ * - Success pDAAPLexer initialized for the lex start
++ * - Fail NULL
++ */
++ANTLR3_API pDAAPLexer DAAPLexerNew
++(pANTLR3_INPUT_STREAM instream)
++{
++ // See if we can create a new lexer with the standard constructor
++ //
++ return DAAPLexerNewSSD(instream, NULL);
++}
++
++/** \brief Create a new lexer called DAAPLexer
++ *
++ * \param[in] instream Pointer to an initialized input stream
++ * \param[state] state Previously created shared recognizer stat
++ * \return
++ * - Success pDAAPLexer initialized for the lex start
++ * - Fail NULL
++ */
++ANTLR3_API pDAAPLexer DAAPLexerNewSSD
++(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pDAAPLexer ctx; // Context structure we will build and return
++
++ ctx = (pDAAPLexer) ANTLR3_CALLOC(1, sizeof(DAAPLexer));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for lexer context
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * in base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 lexer function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in DAAPLexer.h here so you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base lexer, using the supplied input stream
++ */
++ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
++
++ /* Check that we allocated the memory correctly
++ */
++ if (ctx->pLexer == NULL)
++ {
++ ANTLR3_FREE(ctx);
++ return NULL;
++ }
++ /* Install the implementation of our DAAPLexer interface
++ */
++ ctx->mQUOTE = mQUOTE;
++ ctx->mLPAR = mLPAR;
++ ctx->mRPAR = mRPAR;
++ ctx->mOPAND = mOPAND;
++ ctx->mOPOR = mOPOR;
++ ctx->mNEWLINE = mNEWLINE;
++ ctx->mSTR = mSTR;
++ ctx->mESCAPED = mESCAPED;
++ ctx->mTokens = mTokens;
++
++ /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
++ * it will call mTokens() in this generated code, and will pass it the ctx
++ * pointer of this lexer, not the context of the base lexer, so store that now.
++ */
++ ctx->pLexer->ctx = ctx;
++
++ /**Install the token matching function
++ */
++ ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
++
++ ctx->getGrammarFileName = getGrammarFileName;
++ ctx->free = DAAPLexerFree;
++
++
++
++
++
++ /* Return the newly built lexer to the caller
++ */
++ return ctx;
++}
++
++
++/* =========================================================================
++ * Functions to match the lexer grammar defined tokens from the input stream
++ */
++
++// Comes from: 40:7: ( '\\'' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start QUOTE
++ *
++ * Looks to match the characters the constitute the token QUOTE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mQUOTE(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = QUOTE;
++
++
++ // DAAP.g:40:7: ( '\\'' )
++ // DAAP.g:40:9: '\\''
++ {
++ MATCHC('\'');
++ if (HASEXCEPTION())
++ {
++ goto ruleQUOTEEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleQUOTEEx; /* Prevent compiler warnings */
++ ruleQUOTEEx: ;
++
++}
++// $ANTLR end QUOTE
++
++// Comes from: 41:6: ( '(' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LPAR
++ *
++ * Looks to match the characters the constitute the token LPAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLPAR(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = LPAR;
++
++
++ // DAAP.g:41:6: ( '(' )
++ // DAAP.g:41:8: '('
++ {
++ MATCHC('(');
++ if (HASEXCEPTION())
++ {
++ goto ruleLPAREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLPAREx; /* Prevent compiler warnings */
++ ruleLPAREx: ;
++
++}
++// $ANTLR end LPAR
++
++// Comes from: 42:6: ( ')' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start RPAR
++ *
++ * Looks to match the characters the constitute the token RPAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mRPAR(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = RPAR;
++
++
++ // DAAP.g:42:6: ( ')' )
++ // DAAP.g:42:8: ')'
++ {
++ MATCHC(')');
++ if (HASEXCEPTION())
++ {
++ goto ruleRPAREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleRPAREx; /* Prevent compiler warnings */
++ ruleRPAREx: ;
++
++}
++// $ANTLR end RPAR
++
++// Comes from: 44:7: ( '+' | ' ' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start OPAND
++ *
++ * Looks to match the characters the constitute the token OPAND
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mOPAND(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = OPAND;
++
++
++ // DAAP.g:44:7: ( '+' | ' ' )
++ // DAAP.g:
++ {
++ if ( LA(1) == ' ' || LA(1) == '+' )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleOPANDEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleOPANDEx; /* Prevent compiler warnings */
++ ruleOPANDEx: ;
++
++}
++// $ANTLR end OPAND
++
++// Comes from: 45:6: ( ',' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start OPOR
++ *
++ * Looks to match the characters the constitute the token OPOR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mOPOR(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = OPOR;
++
++
++ // DAAP.g:45:6: ( ',' )
++ // DAAP.g:45:8: ','
++ {
++ MATCHC(',');
++ if (HASEXCEPTION())
++ {
++ goto ruleOPOREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleOPOREx; /* Prevent compiler warnings */
++ ruleOPOREx: ;
++
++}
++// $ANTLR end OPOR
++
++// Comes from: 47:9: ( ( '\\r' )? '\\n' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start NEWLINE
++ *
++ * Looks to match the characters the constitute the token NEWLINE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mNEWLINE(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = NEWLINE;
++
++
++ // DAAP.g:47:9: ( ( '\\r' )? '\\n' )
++ // DAAP.g:47:11: ( '\\r' )? '\\n'
++ {
++
++ // DAAP.g:47:11: ( '\\r' )?
++ {
++ int alt1=2;
++ switch ( LA(1) )
++ {
++ case '\r':
++ {
++ alt1=1;
++ }
++ break;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // DAAP.g:47:11: '\\r'
++ {
++ MATCHC('\r');
++ if (HASEXCEPTION())
++ {
++ goto ruleNEWLINEEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++ MATCHC('\n');
++ if (HASEXCEPTION())
++ {
++ goto ruleNEWLINEEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleNEWLINEEx; /* Prevent compiler warnings */
++ ruleNEWLINEEx: ;
++
++}
++// $ANTLR end NEWLINE
++
++// Comes from: 55:2: ( QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start STR
++ *
++ * Looks to match the characters the constitute the token STR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mSTR(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++ pANTLR3_COMMON_TOKEN esc;
++ ANTLR3_UINT32 reg;
++
++
++ esc = NULL;
++
++ _type = STR;
++
++ pANTLR3_STRING unesc = GETTEXT()->factory->newRaw(GETTEXT()->factory);
++
++ // DAAP.g:55:2: ( QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE )
++ // DAAP.g:55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE
++ {
++ /* 55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE */
++ mQUOTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ // DAAP.g:55:10: (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+
++ {
++ int cnt2=0;
++
++ for (;;)
++ {
++ int alt2=3;
++ {
++ /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
++ */
++ int LA2_0 = LA(1);
++ if ( (((LA2_0 >= 0x0000) && (LA2_0 <= '&')) || ((LA2_0 >= '(') && (LA2_0 <= '[')) || ((LA2_0 >= ']') && (LA2_0 <= 0xFFFF))) )
++ {
++ alt2=1;
++ }
++ else if ( (LA2_0 == '\\') )
++ {
++ alt2=2;
++ }
++
++ }
++ switch (alt2)
++ {
++ case 1:
++ // DAAP.g:55:12: reg=~ ( '\\\\' | '\\'' )
++ {
++ reg= LA(1);
++ if ( ((LA(1) >= 0x0000) && (LA(1) <= '&')) || ((LA(1) >= '(') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleSTREx;
++ }
++
++ {
++ unesc->addc(unesc, reg);
++ }
++
++ }
++ break;
++ case 2:
++ // DAAP.g:56:6: esc= ESCAPED
++ {
++ /* 56:6: esc= ESCAPED */
++ {
++ ANTLR3_MARKER escStart118 = GETCHARINDEX();
++ mESCAPED(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ esc = LEXSTATE->tokFactory->newToken(LEXSTATE->tokFactory);
++ esc->setType(esc, ANTLR3_TOKEN_INVALID);
++ esc->setStartIndex(esc, escStart118);
++ esc->setStopIndex(esc, GETCHARINDEX()-1);
++ esc->input = INPUT;
++ }
++ {
++ unesc->appendS(unesc, GETTEXT());
++ }
++
++ }
++ break;
++
++ default:
++
++ if ( cnt2 >= 1 )
++ {
++ goto loop2;
++ }
++ /* mismatchedSetEx()
++ */
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
++
++
++ goto ruleSTREx;
++ }
++ cnt2++;
++ }
++ loop2: ; /* Jump to here if this rule does not match */
++ }
++ /* 55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE */
++ mQUOTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ {
++ SETTEXT(unesc);
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleSTREx; /* Prevent compiler warnings */
++ ruleSTREx: ;
++
++ esc = NULL;
++
++}
++// $ANTLR end STR
++
++// Comes from: 59:9: ( '\\\\' ( '\\\\' | '\\'' ) )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start ESCAPED
++ *
++ * Looks to match the characters the constitute the token ESCAPED
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mESCAPED(pDAAPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // DAAP.g:59:9: ( '\\\\' ( '\\\\' | '\\'' ) )
++ // DAAP.g:59:11: '\\\\' ( '\\\\' | '\\'' )
++ {
++ MATCHC('\\');
++ if (HASEXCEPTION())
++ {
++ goto ruleESCAPEDEx;
++ }
++
++
++ // DAAP.g:60:3: ( '\\\\' | '\\'' )
++ {
++ int alt3=2;
++ switch ( LA(1) )
++ {
++ case '\\':
++ {
++ alt3=1;
++ }
++ break;
++ case '\'':
++ {
++ alt3=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 0;
++
++
++ goto ruleESCAPEDEx;
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // DAAP.g:60:5: '\\\\'
++ {
++ MATCHC('\\');
++ if (HASEXCEPTION())
++ {
++ goto ruleESCAPEDEx;
++ }
++
++ {
++ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\\"));
++ }
++
++ }
++ break;
++ case 2:
++ // DAAP.g:61:5: '\\''
++ {
++ MATCHC('\'');
++ if (HASEXCEPTION())
++ {
++ goto ruleESCAPEDEx;
++ }
++
++ {
++ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\'"));
++ }
++
++ }
++ break;
++
++ }
++ }
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleESCAPEDEx; /* Prevent compiler warnings */
++ ruleESCAPEDEx: ;
++
++}
++// $ANTLR end ESCAPED
++
++/** This is the entry point in to the lexer from an object that
++ * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
++ */
++static void
++mTokens(pDAAPLexer ctx)
++{
++ {
++ // DAAP.g:1:8: ( QUOTE | LPAR | RPAR | OPAND | OPOR | NEWLINE | STR )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=7;
++
++ switch ( LA(1) )
++ {
++ case '\'':
++ {
++
++ {
++ int LA4_1 = LA(2);
++ if ( (((LA4_1 >= 0x0000) && (LA4_1 <= '&')) || ((LA4_1 >= '(') && (LA4_1 <= 0xFFFF))) )
++ {
++ alt4=7;
++ }
++ else
++ {
++ alt4=1; }
++ }
++ }
++ break;
++ case '(':
++ {
++ alt4=2;
++ }
++ break;
++ case ')':
++ {
++ alt4=3;
++ }
++ break;
++ case ' ':
++ case '+':
++ {
++ alt4=4;
++ }
++ break;
++ case ',':
++ {
++ alt4=5;
++ }
++ break;
++ case '\n':
++ case '\r':
++ {
++ alt4=6;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto ruleTokensEx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // DAAP.g:1:10: QUOTE
++ {
++ /* 1:10: QUOTE */
++ mQUOTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 2:
++ // DAAP.g:1:16: LPAR
++ {
++ /* 1:16: LPAR */
++ mLPAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 3:
++ // DAAP.g:1:21: RPAR
++ {
++ /* 1:21: RPAR */
++ mRPAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 4:
++ // DAAP.g:1:26: OPAND
++ {
++ /* 1:26: OPAND */
++ mOPAND(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 5:
++ // DAAP.g:1:32: OPOR
++ {
++ /* 1:32: OPOR */
++ mOPOR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 6:
++ // DAAP.g:1:37: NEWLINE
++ {
++ /* 1:37: NEWLINE */
++ mNEWLINE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 7:
++ // DAAP.g:1:45: STR
++ {
++ /* 1:45: STR */
++ mSTR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++
++
++ goto ruleTokensEx; /* Prevent compiler warnings */
++ruleTokensEx: ;
++}
++
++/* =========================================================================
++ * Lexer matching rules end.
++ * =========================================================================
++ */
++/* End of Lexer code
++ * ================================================
++ * ================================================
++ */
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/DAAPLexer.h b/src/pregen/DAAPLexer.h
+new file mode 100644
+index 0000000..ba8f58b
+--- /dev/null
++++ b/src/pregen/DAAPLexer.h
+@@ -0,0 +1,188 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : DAAP.g
++ * - On : 2014-09-30 21:42:40
++ * - for the lexer : DAAPLexerLexer *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The lexer DAAPLexer has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pDAAPLexer, which is returned from a call to DAAPLexerNew().
++ *
++ * As this is a generated lexer, it is unlikely you will call it 'manually'. However
++ * the methods are provided anyway.
++ * * The methods in pDAAPLexer are as follows:
++ *
++ * - void pDAAPLexer->QUOTE(pDAAPLexer)
++ * - void pDAAPLexer->LPAR(pDAAPLexer)
++ * - void pDAAPLexer->RPAR(pDAAPLexer)
++ * - void pDAAPLexer->OPAND(pDAAPLexer)
++ * - void pDAAPLexer->OPOR(pDAAPLexer)
++ * - void pDAAPLexer->NEWLINE(pDAAPLexer)
++ * - void pDAAPLexer->STR(pDAAPLexer)
++ * - void pDAAPLexer->ESCAPED(pDAAPLexer)
++ * - void pDAAPLexer->Tokens(pDAAPLexer)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _DAAPLexer_H
++#define _DAAPLexer_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct DAAPLexer_Ctx_struct DAAPLexer, * pDAAPLexer;
++
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++
++/** Context tracking structure for DAAPLexer
++ */
++struct DAAPLexer_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_LEXER pLexer;
++
++
++ void (*mQUOTE) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mLPAR) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mRPAR) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mOPAND) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mOPOR) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mNEWLINE) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mSTR) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mESCAPED) (struct DAAPLexer_Ctx_struct * ctx);
++ void (*mTokens) (struct DAAPLexer_Ctx_struct * ctx); const char * (*getGrammarFileName)();
++ void (*free) (struct DAAPLexer_Ctx_struct * ctx);
++
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pDAAPLexer DAAPLexerNew (pANTLR3_INPUT_STREAM instream);
++ANTLR3_API pDAAPLexer DAAPLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the lexer will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define STR 9
++#define QUOTE 10
++#define NEWLINE 4
++#define LPAR 7
++#define OPOR 5
++#define RPAR 8
++#define ESCAPED 11
++#define OPAND 6
++#define EOF -1
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for DAAPLexer
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/DAAPParser.c b/src/pregen/DAAPParser.c
+new file mode 100644
+index 0000000..6d0239d
+--- /dev/null
++++ b/src/pregen/DAAPParser.c
+@@ -0,0 +1,1014 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : DAAP.g
++ * - On : 2014-09-30 21:42:39
++ * - for the parser : DAAPParserParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "DAAPParser.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pDAAPParser_##scope##_SCOPE
++#define SCOPE_STACK(scope) pDAAPParser_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pDAAPParser_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pDAAPParser_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++/* Macros for accessing things in the parser
++ */
++
++#undef PARSER
++#undef RECOGNIZER
++#undef HAVEPARSEDRULE
++#undef MEMOIZE
++#undef INPUT
++#undef STRSTREAM
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef MATCHT
++#undef MATCHANYT
++#undef FOLLOWSTACK
++#undef FOLLOWPUSH
++#undef FOLLOWPOP
++#undef PRECOVER
++#undef PREPORTERROR
++#undef LA
++#undef LT
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef PERRORRECOVERY
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef RECOVERFROMMISMATCHEDSET
++#undef RECOVERFROMMISMATCHEDELEMENT
++#undef INDEX
++#undef ADAPTOR
++#undef SEEK
++#undef RULEMEMO
++#undef DBG
++
++#define PARSER ctx->pParser
++#define RECOGNIZER PARSER->rec
++#define PSRSTATE RECOGNIZER->state
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
++#define INPUT PARSER->tstream
++#define STRSTREAM INPUT
++#define ISTREAM INPUT->istream
++#define INDEX() ISTREAM->index(INPUT->istream)
++#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION PSRSTATE->exception
++#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
++#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
++#define FOLLOWSTACK PSRSTATE->following
++#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
++#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
++#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
++#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
++#define LA(n) INPUT->istream->_LA(ISTREAM, n)
++#define LT(n) INPUT->_LT(INPUT, n)
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define CONSUME() ISTREAM->consume(ISTREAM)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define PERRORRECOVERY PSRSTATE->errorRecovery
++#define FAILEDFLAG PSRSTATE->failed
++#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
++#define BACKTRACKING PSRSTATE->backtracking
++#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
++#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
++#define ADAPTOR ctx->adaptor
++#define RULEMEMO PSRSTATE->ruleMemo
++#define DBG RECOGNIZER->debugger
++
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++
++/** \brief Table of all token names in symbolic order, mainly used for
++ * error reporting.
++ */
++pANTLR3_UINT8 DAAPParserTokenNames[8+4]
++ = {
++ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
++ (pANTLR3_UINT8) "<EOR>",
++ (pANTLR3_UINT8) "<DOWN>",
++ (pANTLR3_UINT8) "<UP>",
++ (pANTLR3_UINT8) "NEWLINE",
++ (pANTLR3_UINT8) "OPOR",
++ (pANTLR3_UINT8) "OPAND",
++ (pANTLR3_UINT8) "LPAR",
++ (pANTLR3_UINT8) "RPAR",
++ (pANTLR3_UINT8) "STR",
++ (pANTLR3_UINT8) "QUOTE",
++ (pANTLR3_UINT8) "ESCAPED"
++ };
++
++
++
++// Forward declare the locally static matching functions we have generated.
++//
++static DAAPParser_query_return query (pDAAPParser ctx);
++static DAAPParser_expr_return expr (pDAAPParser ctx);
++static DAAPParser_aexpr_return aexpr (pDAAPParser ctx);
++static DAAPParser_crit_return crit (pDAAPParser ctx);
++static void DAAPParserFree(pDAAPParser ctx);
++/* For use in tree output where we are accumulating rule labels via label += ruleRef
++ * we need a function that knows how to free a return scope when the list is destroyed.
++ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
++ */
++static void ANTLR3_CDECL freeScope(void * scope)
++{
++ ANTLR3_FREE(scope);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "DAAP.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++/** \brief Create a new DAAPParser parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pDAAPParser
++DAAPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
++{
++ // See if we can create a new parser with the standard constructor
++ //
++ return DAAPParserNewSSD(instream, NULL);
++}
++
++/** \brief Create a new DAAPParser parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pDAAPParser
++DAAPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pDAAPParser ctx; /* Context structure we will build and return */
++
++ ctx = (pDAAPParser) ANTLR3_CALLOC(1, sizeof(DAAPParser));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for parser context
++ //
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * the base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 parser function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in DAAPParser.h here, in order that you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base parser/recognizer, using the supplied token stream
++ */
++ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
++ /* Install the implementation of our DAAPParser interface
++ */
++ ctx->query = query;
++ ctx->expr = expr;
++ ctx->aexpr = aexpr;
++ ctx->crit = crit;
++ ctx->free = DAAPParserFree;
++ ctx->getGrammarFileName = getGrammarFileName;
++
++ /* Install the scope pushing methods.
++ */
++ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
++ ctx->vectors = antlr3VectorFactoryNew(0);
++
++
++
++ /* Install the token table
++ */
++ PSRSTATE->tokenNames = DAAPParserTokenNames;
++
++
++ /* Return the newly built parser to the caller
++ */
++ return ctx;
++}
++
++/** Free the parser resources
++ */
++ static void
++ DAAPParserFree(pDAAPParser ctx)
++ {
++ /* Free any scope memory
++ */
++
++ ctx->vectors->close(ctx->vectors);
++ /* We created the adaptor so we must free it
++ */
++ ADAPTOR->free(ADAPTOR);
++ // Free this parser
++ //
++ ctx->pParser->free(ctx->pParser);
++ ANTLR3_FREE(ctx);
++
++ /* Everything is released, so we can return
++ */
++ return;
++ }
++
++/** Return token names used by this parser
++ *
++ * The returned pointer is used as an index into the token names table (using the token
++ * number as the index).
++ *
++ * \return Pointer to first char * in the table.
++ */
++static pANTLR3_UINT8 *getTokenNames()
++{
++ return DAAPParserTokenNames;
++}
++
++
++/* Declare the bitsets
++ */
++
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query42 */
++static ANTLR3_BITWORD FOLLOW_expr_in_query42_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_query42 = { FOLLOW_expr_in_query42_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_query44 */
++static ANTLR3_BITWORD FOLLOW_NEWLINE_in_query44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) };
++static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_query44 = { FOLLOW_NEWLINE_in_query44_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_query47 */
++static ANTLR3_BITWORD FOLLOW_EOF_in_query47_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_EOF_in_query47 = { FOLLOW_EOF_in_query47_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr62 */
++static ANTLR3_BITWORD FOLLOW_aexpr_in_expr62_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
++static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr62 = { FOLLOW_aexpr_in_expr62_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPOR_in_expr65 */
++static ANTLR3_BITWORD FOLLOW_OPOR_in_expr65_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
++static ANTLR3_BITSET_LIST FOLLOW_OPOR_in_expr65 = { FOLLOW_OPOR_in_expr65_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr68 */
++static ANTLR3_BITWORD FOLLOW_aexpr_in_expr68_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
++static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr68 = { FOLLOW_aexpr_in_expr68_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr80 */
++static ANTLR3_BITWORD FOLLOW_crit_in_aexpr80_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
++static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr80 = { FOLLOW_crit_in_aexpr80_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OPAND_in_aexpr83 */
++static ANTLR3_BITWORD FOLLOW_OPAND_in_aexpr83_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
++static ANTLR3_BITSET_LIST FOLLOW_OPAND_in_aexpr83 = { FOLLOW_OPAND_in_aexpr83_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr86 */
++static ANTLR3_BITWORD FOLLOW_crit_in_aexpr86_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
++static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr86 = { FOLLOW_crit_in_aexpr86_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit98 */
++static ANTLR3_BITWORD FOLLOW_LPAR_in_crit98_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
++static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit98 = { FOLLOW_LPAR_in_crit98_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_crit100 */
++static ANTLR3_BITWORD FOLLOW_expr_in_crit100_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000100) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_crit100 = { FOLLOW_expr_in_crit100_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit102 */
++static ANTLR3_BITWORD FOLLOW_RPAR_in_crit102_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit102 = { FOLLOW_RPAR_in_crit102_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_crit112 */
++static ANTLR3_BITWORD FOLLOW_STR_in_crit112_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_crit112 = { FOLLOW_STR_in_crit112_bits, 1 };
++
++
++
++
++/* ==============================================
++ * Parsing rules
++ */
++/**
++ * $ANTLR start query
++ * DAAP.g:27:1: query : expr ( NEWLINE )? EOF -> expr ;
++ */
++static DAAPParser_query_return
++query(pDAAPParser ctx)
++{
++ DAAPParser_query_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN NEWLINE2;
++ pANTLR3_COMMON_TOKEN EOF3;
++ DAAPParser_expr_return expr1;
++ #undef RETURN_TYPE_expr1
++ #define RETURN_TYPE_expr1 DAAPParser_expr_return
++
++ pANTLR3_BASE_TREE NEWLINE2_tree;
++ pANTLR3_BASE_TREE EOF3_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NEWLINE;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_EOF;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ NEWLINE2 = NULL;
++ EOF3 = NULL;
++ expr1.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ NEWLINE2_tree = NULL;
++ EOF3_tree = NULL;
++
++ stream_NEWLINE = NULL;
++ #define CREATE_stream_NEWLINE if (stream_NEWLINE == NULL) {stream_NEWLINE = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NEWLINE"); }
++ stream_EOF = NULL;
++ #define CREATE_stream_EOF if (stream_EOF == NULL) {stream_EOF = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token EOF"); }
++ stream_expr = NULL;
++ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
++
++ retval.tree = NULL;
++ {
++ // DAAP.g:27:7: ( expr ( NEWLINE )? EOF -> expr )
++ // DAAP.g:27:9: expr ( NEWLINE )? EOF
++ {
++ FOLLOWPUSH(FOLLOW_expr_in_query42);
++ expr1=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ CREATE_stream_expr; stream_expr->add(stream_expr, expr1.tree, NULL);
++
++ // DAAP.g:27:14: ( NEWLINE )?
++ {
++ int alt1=2;
++ switch ( LA(1) )
++ {
++ case NEWLINE:
++ {
++ alt1=1;
++ }
++ break;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // DAAP.g:27:14: NEWLINE
++ {
++ NEWLINE2 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_query44);
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ CREATE_stream_NEWLINE; stream_NEWLINE->add(stream_NEWLINE, NEWLINE2, NULL);
++
++
++ }
++ break;
++
++ }
++ }
++ EOF3 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_query47);
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ CREATE_stream_EOF; stream_EOF->add(stream_EOF, EOF3, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : expr
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 27:27: -> expr
++ {
++ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulequeryEx; /* Prevent compiler warnings */
++ rulequeryEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_NEWLINE != NULL) stream_NEWLINE->free(stream_NEWLINE);
++ if (stream_EOF != NULL) stream_EOF->free(stream_EOF);
++ if (stream_expr != NULL) stream_expr->free(stream_expr);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end query */
++
++/**
++ * $ANTLR start expr
++ * DAAP.g:30:1: expr : aexpr ( OPOR aexpr )* ;
++ */
++static DAAPParser_expr_return
++expr(pDAAPParser ctx)
++{
++ DAAPParser_expr_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN OPOR5;
++ DAAPParser_aexpr_return aexpr4;
++ #undef RETURN_TYPE_aexpr4
++ #define RETURN_TYPE_aexpr4 DAAPParser_aexpr_return
++
++ DAAPParser_aexpr_return aexpr6;
++ #undef RETURN_TYPE_aexpr6
++ #define RETURN_TYPE_aexpr6 DAAPParser_aexpr_return
++
++ pANTLR3_BASE_TREE OPOR5_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ OPOR5 = NULL;
++ aexpr4.tree = NULL;
++
++ aexpr6.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ OPOR5_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // DAAP.g:30:6: ( aexpr ( OPOR aexpr )* )
++ // DAAP.g:30:8: aexpr ( OPOR aexpr )*
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_aexpr_in_expr62);
++ aexpr4=aexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, aexpr4.tree);
++
++ // DAAP.g:30:14: ( OPOR aexpr )*
++
++ for (;;)
++ {
++ int alt2=2;
++ switch ( LA(1) )
++ {
++ case OPOR:
++ {
++ alt2=1;
++ }
++ break;
++
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // DAAP.g:30:15: OPOR aexpr
++ {
++ OPOR5 = (pANTLR3_COMMON_TOKEN) MATCHT(OPOR, &FOLLOW_OPOR_in_expr65);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ OPOR5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OPOR5));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OPOR5_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_aexpr_in_expr68);
++ aexpr6=aexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree);
++
++ }
++ break;
++
++ default:
++ goto loop2; /* break out of the loop */
++ break;
++ }
++ }
++ loop2: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleexprEx; /* Prevent compiler warnings */
++ ruleexprEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end expr */
++
++/**
++ * $ANTLR start aexpr
++ * DAAP.g:33:1: aexpr : crit ( OPAND crit )* ;
++ */
++static DAAPParser_aexpr_return
++aexpr(pDAAPParser ctx)
++{
++ DAAPParser_aexpr_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN OPAND8;
++ DAAPParser_crit_return crit7;
++ #undef RETURN_TYPE_crit7
++ #define RETURN_TYPE_crit7 DAAPParser_crit_return
++
++ DAAPParser_crit_return crit9;
++ #undef RETURN_TYPE_crit9
++ #define RETURN_TYPE_crit9 DAAPParser_crit_return
++
++ pANTLR3_BASE_TREE OPAND8_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ OPAND8 = NULL;
++ crit7.tree = NULL;
++
++ crit9.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ OPAND8_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // DAAP.g:33:7: ( crit ( OPAND crit )* )
++ // DAAP.g:33:9: crit ( OPAND crit )*
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_crit_in_aexpr80);
++ crit7=crit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, crit7.tree);
++
++ // DAAP.g:33:14: ( OPAND crit )*
++
++ for (;;)
++ {
++ int alt3=2;
++ switch ( LA(1) )
++ {
++ case OPAND:
++ {
++ alt3=1;
++ }
++ break;
++
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // DAAP.g:33:15: OPAND crit
++ {
++ OPAND8 = (pANTLR3_COMMON_TOKEN) MATCHT(OPAND, &FOLLOW_OPAND_in_aexpr83);
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ OPAND8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OPAND8));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OPAND8_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_crit_in_aexpr86);
++ crit9=crit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, crit9.tree);
++
++ }
++ break;
++
++ default:
++ goto loop3; /* break out of the loop */
++ break;
++ }
++ }
++ loop3: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleaexprEx; /* Prevent compiler warnings */
++ ruleaexprEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end aexpr */
++
++/**
++ * $ANTLR start crit
++ * DAAP.g:36:1: crit : ( LPAR expr RPAR -> expr | STR );
++ */
++static DAAPParser_crit_return
++crit(pDAAPParser ctx)
++{
++ DAAPParser_crit_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN LPAR10;
++ pANTLR3_COMMON_TOKEN RPAR12;
++ pANTLR3_COMMON_TOKEN STR13;
++ DAAPParser_expr_return expr11;
++ #undef RETURN_TYPE_expr11
++ #define RETURN_TYPE_expr11 DAAPParser_expr_return
++
++ pANTLR3_BASE_TREE LPAR10_tree;
++ pANTLR3_BASE_TREE RPAR12_tree;
++ pANTLR3_BASE_TREE STR13_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ LPAR10 = NULL;
++ RPAR12 = NULL;
++ STR13 = NULL;
++ expr11.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ LPAR10_tree = NULL;
++ RPAR12_tree = NULL;
++ STR13_tree = NULL;
++
++ stream_RPAR = NULL;
++ #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); }
++ stream_LPAR = NULL;
++ #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); }
++ stream_expr = NULL;
++ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
++
++ retval.tree = NULL;
++ {
++ {
++ // DAAP.g:36:6: ( LPAR expr RPAR -> expr | STR )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=2;
++
++ switch ( LA(1) )
++ {
++ case LPAR:
++ {
++ alt4=1;
++ }
++ break;
++ case STR:
++ {
++ alt4=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto rulecritEx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // DAAP.g:36:8: LPAR expr RPAR
++ {
++ LPAR10 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit98);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR10, NULL);
++
++ FOLLOWPUSH(FOLLOW_expr_in_crit100);
++ expr11=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_expr; stream_expr->add(stream_expr, expr11.tree, NULL);
++ RPAR12 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit102);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR12, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : expr
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 36:24: -> expr
++ {
++ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++ case 2:
++ // DAAP.g:37:4: STR
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ STR13 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_crit112);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ STR13_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STR13));
++ ADAPTOR->addChild(ADAPTOR, root_0, STR13_tree);
++
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulecritEx; /* Prevent compiler warnings */
++ rulecritEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR);
++ if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR);
++ if (stream_expr != NULL) stream_expr->free(stream_expr);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end crit */
++/* End of parsing rules
++ * ==============================================
++ */
++
++/* ==============================================
++ * Syntactic predicates
++ */
++/* End of syntactic predicates
++ * ==============================================
++ */
++
++
++
++
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/DAAPParser.h b/src/pregen/DAAPParser.h
+new file mode 100644
+index 0000000..dcc664f
+--- /dev/null
++++ b/src/pregen/DAAPParser.h
+@@ -0,0 +1,226 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : DAAP.g
++ * - On : 2014-09-30 21:42:39
++ * - for the parser : DAAPParserParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The parser DAAPParser has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pDAAPParser, which is returned from a call to DAAPParserNew().
++ *
++ * The methods in pDAAPParser are as follows:
++ *
++ * - DAAPParser_query_return pDAAPParser->query(pDAAPParser)
++ * - DAAPParser_expr_return pDAAPParser->expr(pDAAPParser)
++ * - DAAPParser_aexpr_return pDAAPParser->aexpr(pDAAPParser)
++ * - DAAPParser_crit_return pDAAPParser->crit(pDAAPParser)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _DAAPParser_H
++#define _DAAPParser_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct DAAPParser_Ctx_struct DAAPParser, * pDAAPParser;
++
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++typedef struct DAAPParser_query_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ DAAPParser_query_return;
++
++typedef struct DAAPParser_expr_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ DAAPParser_expr_return;
++
++typedef struct DAAPParser_aexpr_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ DAAPParser_aexpr_return;
++
++typedef struct DAAPParser_crit_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ DAAPParser_crit_return;
++
++
++
++/** Context tracking structure for DAAPParser
++ */
++struct DAAPParser_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_PARSER pParser;
++
++
++ DAAPParser_query_return (*query) (struct DAAPParser_Ctx_struct * ctx);
++ DAAPParser_expr_return (*expr) (struct DAAPParser_Ctx_struct * ctx);
++ DAAPParser_aexpr_return (*aexpr) (struct DAAPParser_Ctx_struct * ctx);
++ DAAPParser_crit_return (*crit) (struct DAAPParser_Ctx_struct * ctx);
++ // Delegated rules
++ const char * (*getGrammarFileName)();
++ void (*free) (struct DAAPParser_Ctx_struct * ctx);
++ /* @headerFile.members() */
++ pANTLR3_BASE_TREE_ADAPTOR adaptor;
++ pANTLR3_VECTOR_FACTORY vectors;
++ /* End @headerFile.members() */
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pDAAPParser DAAPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream);
++ANTLR3_API pDAAPParser DAAPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the parser will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define STR 9
++#define QUOTE 10
++#define LPAR 7
++#define NEWLINE 4
++#define OPOR 5
++#define RPAR 8
++#define ESCAPED 11
++#define OPAND 6
++#define EOF -1
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for DAAPParser
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/RSP.u b/src/pregen/RSP.u
+new file mode 100644
+index 0000000..89256ff
+--- /dev/null
++++ b/src/pregen/RSP.u
+@@ -0,0 +1,6 @@
++RSPParser.c : RSP.g
++./RSP.tokens : RSP.g
++RSPParser.h : RSP.g
++RSPLexer.c : RSP.g
++RSPLexer.h : RSP.g
++ANTLR_PRODUCTS += RSPParser.c ./RSP.tokens RSPParser.h RSPLexer.c RSPLexer.h
+\ No newline at end of file
+diff --git a/src/pregen/RSP2SQL.c b/src/pregen/RSP2SQL.c
+new file mode 100644
+index 0000000..b5c9550
+--- /dev/null
++++ b/src/pregen/RSP2SQL.c
+@@ -0,0 +1,2546 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : RSP2SQL.g
++ * - On : 2014-09-30 21:42:42
++ * - for the tree parser : RSP2SQLTreeParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++
++/* =============================================================================
++ * This is what the grammar programmer asked us to put at the top of every file.
++ */
++
++ /* Needs #define _GNU_SOURCE for strptime() */
++
++ #include <stdio.h>
++ #include <string.h>
++ #include <time.h>
++ #include <stdint.h>
++
++ #include "logger.h"
++ #include "db.h"
++ #include "misc.h"
++ #include "rsp_query.h"
++
++/* End of Header action.
++ * =============================================================================
++ */
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "RSP2SQL.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pRSP2SQL_##scope##_SCOPE
++#define SCOPE_STACK(scope) pRSP2SQL_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pRSP2SQL_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pRSP2SQL_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++/* Macros for accessing things in the parser
++ */
++
++#undef PARSER
++#undef RECOGNIZER
++#undef HAVEPARSEDRULE
++#undef INPUT
++#undef STRSTREAM
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef MATCHT
++#undef MATCHANYT
++#undef FOLLOWSTACK
++#undef FOLLOWPUSH
++#undef FOLLOWPOP
++#undef PRECOVER
++#undef PREPORTERROR
++#undef LA
++#undef LT
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef PERRORRECOVERY
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef RECOVERFROMMISMATCHEDSET
++#undef RECOVERFROMMISMATCHEDELEMENT
++#undef BACKTRACKING
++#undef ADAPTOR
++#undef RULEMEMO
++#undef SEEK
++#undef INDEX
++#undef DBG
++
++#define PARSER ctx->pTreeParser
++#define RECOGNIZER PARSER->rec
++#define PSRSTATE RECOGNIZER->state
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define INPUT PARSER->ctnstream
++#define ISTREAM INPUT->tnstream->istream
++#define STRSTREAM INPUT->tnstream
++#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION PSRSTATE->exception
++#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
++#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
++#define FOLLOWSTACK PSRSTATE->following
++#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
++#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
++#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
++#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
++#define LA(n) ISTREAM->_LA(ISTREAM, n)
++#define LT(n) INPUT->tnstream->_LT(INPUT->tnstream, n)
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define CONSUME() ISTREAM->consume(ISTREAM)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define PERRORRECOVERY PSRSTATE->errorRecovery
++#define FAILEDFLAG PSRSTATE->failed
++#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
++#define BACKTRACKING PSRSTATE->backtracking
++#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
++#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
++#define ADAPTOR INPUT->adaptor
++#define RULEMEMO PSRSTATE->ruleMemo
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define INDEX() ISTREAM->index(ISTREAM)
++#define DBG RECOGNIZER->debugger
++
++
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++
++/** \brief Table of all token names in symbolic order, mainly used for
++ * error reporting.
++ */
++pANTLR3_UINT8 RSP2SQLTokenNames[30+4]
++ = {
++ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
++ (pANTLR3_UINT8) "<EOR>",
++ (pANTLR3_UINT8) "<DOWN>",
++ (pANTLR3_UINT8) "<UP>",
++ (pANTLR3_UINT8) "NEWLINE",
++ (pANTLR3_UINT8) "OR",
++ (pANTLR3_UINT8) "AND",
++ (pANTLR3_UINT8) "LPAR",
++ (pANTLR3_UINT8) "RPAR",
++ (pANTLR3_UINT8) "FIELD",
++ (pANTLR3_UINT8) "STR",
++ (pANTLR3_UINT8) "NOT",
++ (pANTLR3_UINT8) "EQUAL",
++ (pANTLR3_UINT8) "INCLUDES",
++ (pANTLR3_UINT8) "STARTSW",
++ (pANTLR3_UINT8) "ENDSW",
++ (pANTLR3_UINT8) "INT",
++ (pANTLR3_UINT8) "LESS",
++ (pANTLR3_UINT8) "GREATER",
++ (pANTLR3_UINT8) "LTE",
++ (pANTLR3_UINT8) "GTE",
++ (pANTLR3_UINT8) "BEFORE",
++ (pANTLR3_UINT8) "AFTER",
++ (pANTLR3_UINT8) "DATE",
++ (pANTLR3_UINT8) "TODAY",
++ (pANTLR3_UINT8) "DAY",
++ (pANTLR3_UINT8) "WEEK",
++ (pANTLR3_UINT8) "MONTH",
++ (pANTLR3_UINT8) "YEAR",
++ (pANTLR3_UINT8) "QUOTE",
++ (pANTLR3_UINT8) "WS",
++ (pANTLR3_UINT8) "DIGIT19",
++ (pANTLR3_UINT8) "DIGIT09",
++ (pANTLR3_UINT8) "ESCAPED"
++ };
++
++
++
++// Forward declare the locally static matching functions we have generated.
++//
++static pANTLR3_STRING query (pRSP2SQL ctx);
++static RSP2SQL_expr_return expr (pRSP2SQL ctx);
++static RSP2SQL_strcrit_return strcrit (pRSP2SQL ctx);
++static pANTLR3_COMMON_TOKEN strop (pRSP2SQL ctx);
++static RSP2SQL_intcrit_return intcrit (pRSP2SQL ctx);
++static pANTLR3_COMMON_TOKEN intop (pRSP2SQL ctx);
++static RSP2SQL_datecrit_return datecrit (pRSP2SQL ctx);
++static pANTLR3_COMMON_TOKEN dateop (pRSP2SQL ctx);
++static RSP2SQL_datespec_return datespec (pRSP2SQL ctx);
++static RSP2SQL_dateref_return dateref (pRSP2SQL ctx);
++static RSP2SQL_dateintval_return dateintval (pRSP2SQL ctx);
++static void RSP2SQLFree(pRSP2SQL ctx);
++/* For use in tree output where we are accumulating rule labels via label += ruleRef
++ * we need a function that knows how to free a return scope when the list is destroyed.
++ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
++ */
++static void ANTLR3_CDECL freeScope(void * scope)
++{
++ ANTLR3_FREE(scope);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "RSP2SQL.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++/** \brief Create a new RSP2SQL parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pRSP2SQL
++RSP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream)
++{
++ // See if we can create a new parser with the standard constructor
++ //
++ return RSP2SQLNewSSD(instream, NULL);
++}
++
++/** \brief Create a new RSP2SQL parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pRSP2SQL
++RSP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pRSP2SQL ctx; /* Context structure we will build and return */
++
++ ctx = (pRSP2SQL) ANTLR3_CALLOC(1, sizeof(RSP2SQL));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for parser context
++ //
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * the base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 parser function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in RSP2SQL.h here, in order that you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base Tree parser/recognizer, using the supplied tree node stream
++ */
++ ctx->pTreeParser = antlr3TreeParserNewStream(ANTLR3_SIZE_HINT, instream, state);
++ /* Install the implementation of our RSP2SQL interface
++ */
++ ctx->query = query;
++ ctx->expr = expr;
++ ctx->strcrit = strcrit;
++ ctx->strop = strop;
++ ctx->intcrit = intcrit;
++ ctx->intop = intop;
++ ctx->datecrit = datecrit;
++ ctx->dateop = dateop;
++ ctx->datespec = datespec;
++ ctx->dateref = dateref;
++ ctx->dateintval = dateintval;
++ ctx->free = RSP2SQLFree;
++ ctx->getGrammarFileName = getGrammarFileName;
++
++ /* Install the scope pushing methods.
++ */
++
++
++
++
++
++ /* Install the token table
++ */
++ PSRSTATE->tokenNames = RSP2SQLTokenNames;
++
++
++ /* Return the newly built parser to the caller
++ */
++ return ctx;
++}
++
++/** Free the parser resources
++ */
++ static void
++ RSP2SQLFree(pRSP2SQL ctx)
++ {
++ /* Free any scope memory
++ */
++
++
++ // Free this parser
++ //
++ ctx->pTreeParser->free(ctx->pTreeParser);
++ ANTLR3_FREE(ctx);
++
++ /* Everything is released, so we can return
++ */
++ return;
++ }
++
++/** Return token names used by this tree parser
++ *
++ * The returned pointer is used as an index into the token names table (using the token
++ * number as the index).
++ *
++ * \return Pointer to first char * in the table.
++ */
++static pANTLR3_UINT8 *getTokenNames()
++{
++ return RSP2SQLTokenNames;
++}
++
++
++ #define RSP_TYPE_STRING 0
++ #define RSP_TYPE_INT 1
++ #define RSP_TYPE_DATE 2
++
++ struct rsp_query_field_map {
++ char *rsp_field;
++ int field_type;
++ /* RSP fields are named after the DB columns - or vice versa */
++ };
++
++ /* gperf static hash, rsp_query.gperf */
++ #include "rsp_query_hash.c"
++
++
++/* Declare the bitsets
++ */
++
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query70 */
++static ANTLR3_BITWORD FOLLOW_expr_in_query70_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_query70 = { FOLLOW_expr_in_query70_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_expr95 */
++static ANTLR3_BITWORD FOLLOW_AND_in_expr95_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_AND_in_expr95 = { FOLLOW_AND_in_expr95_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr101 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr101_bits[] = { ANTLR3_UINT64_LIT(0x00000000007EF860) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr101 = { FOLLOW_expr_in_expr101_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr107 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr107 = { FOLLOW_expr_in_expr107_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expr118 */
++static ANTLR3_BITWORD FOLLOW_OR_in_expr118_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_OR_in_expr118 = { FOLLOW_OR_in_expr118_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr124 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr124_bits[] = { ANTLR3_UINT64_LIT(0x00000000007EF860) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr124 = { FOLLOW_expr_in_expr124_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr130 */
++static ANTLR3_BITWORD FOLLOW_expr_in_expr130_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr130 = { FOLLOW_expr_in_expr130_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_expr144 */
++static ANTLR3_BITWORD FOLLOW_strcrit_in_expr144_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_expr144 = { FOLLOW_strcrit_in_expr144_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_expr154 */
++static ANTLR3_BITWORD FOLLOW_NOT_in_expr154_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_NOT_in_expr154 = { FOLLOW_NOT_in_expr154_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_expr160 */
++static ANTLR3_BITWORD FOLLOW_strcrit_in_expr160_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_expr160 = { FOLLOW_strcrit_in_expr160_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_expr174 */
++static ANTLR3_BITWORD FOLLOW_intcrit_in_expr174_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_expr174 = { FOLLOW_intcrit_in_expr174_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_expr184 */
++static ANTLR3_BITWORD FOLLOW_NOT_in_expr184_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_NOT_in_expr184 = { FOLLOW_NOT_in_expr184_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_expr190 */
++static ANTLR3_BITWORD FOLLOW_intcrit_in_expr190_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_expr190 = { FOLLOW_intcrit_in_expr190_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_datecrit_in_expr204 */
++static ANTLR3_BITWORD FOLLOW_datecrit_in_expr204_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_datecrit_in_expr204 = { FOLLOW_datecrit_in_expr204_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit233 */
++static ANTLR3_BITWORD FOLLOW_strop_in_strcrit233_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit233 = { FOLLOW_strop_in_strcrit233_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit239 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit239_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit239 = { FOLLOW_FIELD_in_strcrit239_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit245 */
++static ANTLR3_BITWORD FOLLOW_STR_in_strcrit245_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit245 = { FOLLOW_STR_in_strcrit245_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_strop274 */
++static ANTLR3_BITWORD FOLLOW_EQUAL_in_strop274_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_strop274 = { FOLLOW_EQUAL_in_strop274_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INCLUDES_in_strop287 */
++static ANTLR3_BITWORD FOLLOW_INCLUDES_in_strop287_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_INCLUDES_in_strop287 = { FOLLOW_INCLUDES_in_strop287_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STARTSW_in_strop300 */
++static ANTLR3_BITWORD FOLLOW_STARTSW_in_strop300_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STARTSW_in_strop300 = { FOLLOW_STARTSW_in_strop300_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_ENDSW_in_strop313 */
++static ANTLR3_BITWORD FOLLOW_ENDSW_in_strop313_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_ENDSW_in_strop313 = { FOLLOW_ENDSW_in_strop313_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit342 */
++static ANTLR3_BITWORD FOLLOW_intop_in_intcrit342_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit342 = { FOLLOW_intop_in_intcrit342_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit348 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit348_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit348 = { FOLLOW_FIELD_in_intcrit348_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit354 */
++static ANTLR3_BITWORD FOLLOW_INT_in_intcrit354_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit354 = { FOLLOW_INT_in_intcrit354_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUAL_in_intop383 */
++static ANTLR3_BITWORD FOLLOW_EQUAL_in_intop383_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_EQUAL_in_intop383 = { FOLLOW_EQUAL_in_intop383_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LESS_in_intop396 */
++static ANTLR3_BITWORD FOLLOW_LESS_in_intop396_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_LESS_in_intop396 = { FOLLOW_LESS_in_intop396_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_in_intop409 */
++static ANTLR3_BITWORD FOLLOW_GREATER_in_intop409_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_GREATER_in_intop409 = { FOLLOW_GREATER_in_intop409_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LTE_in_intop422 */
++static ANTLR3_BITWORD FOLLOW_LTE_in_intop422_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_LTE_in_intop422 = { FOLLOW_LTE_in_intop422_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_GTE_in_intop435 */
++static ANTLR3_BITWORD FOLLOW_GTE_in_intop435_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_GTE_in_intop435 = { FOLLOW_GTE_in_intop435_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit464 */
++static ANTLR3_BITWORD FOLLOW_dateop_in_datecrit464_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit464 = { FOLLOW_dateop_in_datecrit464_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit470 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit470_bits[] = { ANTLR3_UINT64_LIT(0x0000000001FEF860) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit470 = { FOLLOW_FIELD_in_datecrit470_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit476 */
++static ANTLR3_BITWORD FOLLOW_datespec_in_datecrit476_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit476 = { FOLLOW_datespec_in_datecrit476_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_BEFORE_in_dateop505 */
++static ANTLR3_BITWORD FOLLOW_BEFORE_in_dateop505_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_BEFORE_in_dateop505 = { FOLLOW_BEFORE_in_dateop505_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AFTER_in_dateop518 */
++static ANTLR3_BITWORD FOLLOW_AFTER_in_dateop518_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_AFTER_in_dateop518 = { FOLLOW_AFTER_in_dateop518_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec546 */
++static ANTLR3_BITWORD FOLLOW_dateref_in_datespec546_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec546 = { FOLLOW_dateref_in_datespec546_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec560 */
++static ANTLR3_BITWORD FOLLOW_dateop_in_datespec560_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000004) };
++static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec560 = { FOLLOW_dateop_in_datespec560_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec566 */
++static ANTLR3_BITWORD FOLLOW_dateref_in_datespec566_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
++static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec566 = { FOLLOW_dateref_in_datespec566_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec572 */
++static ANTLR3_BITWORD FOLLOW_INT_in_datespec572_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec572 = { FOLLOW_INT_in_datespec572_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec578 */
++static ANTLR3_BITWORD FOLLOW_dateintval_in_datespec578_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000008) };
++static ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec578 = { FOLLOW_dateintval_in_datespec578_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DATE_in_dateref607 */
++static ANTLR3_BITWORD FOLLOW_DATE_in_dateref607_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DATE_in_dateref607 = { FOLLOW_DATE_in_dateref607_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_TODAY_in_dateref616 */
++static ANTLR3_BITWORD FOLLOW_TODAY_in_dateref616_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_TODAY_in_dateref616 = { FOLLOW_TODAY_in_dateref616_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_DAY_in_dateintval640 */
++static ANTLR3_BITWORD FOLLOW_DAY_in_dateintval640_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_DAY_in_dateintval640 = { FOLLOW_DAY_in_dateintval640_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_WEEK_in_dateintval649 */
++static ANTLR3_BITWORD FOLLOW_WEEK_in_dateintval649_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_WEEK_in_dateintval649 = { FOLLOW_WEEK_in_dateintval649_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_MONTH_in_dateintval658 */
++static ANTLR3_BITWORD FOLLOW_MONTH_in_dateintval658_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_MONTH_in_dateintval658 = { FOLLOW_MONTH_in_dateintval658_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_YEAR_in_dateintval667 */
++static ANTLR3_BITWORD FOLLOW_YEAR_in_dateintval667_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_YEAR_in_dateintval667 = { FOLLOW_YEAR_in_dateintval667_bits, 1 };
++
++
++
++
++/* ==============================================
++ * Parsing rules
++ */
++/**
++ * $ANTLR start query
++ * RSP2SQL.g:56:1: query returns [ pANTLR3_STRING result ] : e= expr ;
++ */
++static pANTLR3_STRING
++query(pRSP2SQL ctx)
++{
++ pANTLR3_STRING result = NULL;
++
++ RSP2SQL_expr_return e;
++ #undef RETURN_TYPE_e
++ #define RETURN_TYPE_e RSP2SQL_expr_return
++
++ /* Initialize rule variables
++ */
++
++
++ result= NULL;
++ {
++ // RSP2SQL.g:58:2: (e= expr )
++ // RSP2SQL.g:58:4: e= expr
++ {
++ FOLLOWPUSH(FOLLOW_expr_in_query70);
++ e=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ {
++
++ if (!e.valid)
++ {
++ result= NULL;
++ }
++ else
++ {
++ result= e.result->factory->newRaw(e.result->factory);
++ result->append8(result, "(");
++ result->appendS(result, e.result);
++ result->append8(result, ")");
++ }
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulequeryEx; /* Prevent compiler warnings */
++ rulequeryEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return result;
++}
++/* $ANTLR end query */
++
++/**
++ * $ANTLR start expr
++ * RSP2SQL.g:74:1: expr returns [ pANTLR3_STRING result, int valid ] : ( ^( AND a= expr b= expr ) | ^( OR a= expr b= expr ) | c= strcrit | ^( NOT c= strcrit ) | i= intcrit | ^( NOT i= intcrit ) | d= datecrit );
++ */
++static RSP2SQL_expr_return
++expr(pRSP2SQL ctx)
++{
++ RSP2SQL_expr_return retval;
++
++ RSP2SQL_expr_return a;
++ #undef RETURN_TYPE_a
++ #define RETURN_TYPE_a RSP2SQL_expr_return
++
++ RSP2SQL_expr_return b;
++ #undef RETURN_TYPE_b
++ #define RETURN_TYPE_b RSP2SQL_expr_return
++
++ RSP2SQL_strcrit_return c;
++ #undef RETURN_TYPE_c
++ #define RETURN_TYPE_c RSP2SQL_strcrit_return
++
++ RSP2SQL_intcrit_return i;
++ #undef RETURN_TYPE_i
++ #define RETURN_TYPE_i RSP2SQL_intcrit_return
++
++ RSP2SQL_datecrit_return d;
++ #undef RETURN_TYPE_d
++ #define RETURN_TYPE_d RSP2SQL_datecrit_return
++
++ /* Initialize rule variables
++ */
++
++
++ retval.result= NULL; retval.valid= 1;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ {
++ // RSP2SQL.g:76:2: ( ^( AND a= expr b= expr ) | ^( OR a= expr b= expr ) | c= strcrit | ^( NOT c= strcrit ) | i= intcrit | ^( NOT i= intcrit ) | d= datecrit )
++
++ ANTLR3_UINT32 alt1;
++
++ alt1=7;
++
++ switch ( LA(1) )
++ {
++ case AND:
++ {
++ alt1=1;
++ }
++ break;
++ case OR:
++ {
++ alt1=2;
++ }
++ break;
++ case EQUAL:
++ {
++ switch ( LA(2) )
++ {
++ case DOWN:
++ {
++ switch ( LA(3) )
++ {
++ case FIELD:
++ {
++ switch ( LA(4) )
++ {
++ case INT:
++ {
++ alt1=5;
++ }
++ break;
++ case STR:
++ {
++ alt1=3;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 10;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 8;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 3;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++ case INCLUDES:
++ case STARTSW:
++ case ENDSW:
++ {
++ alt1=3;
++ }
++ break;
++ case NOT:
++ {
++ switch ( LA(2) )
++ {
++ case DOWN:
++ {
++ switch ( LA(3) )
++ {
++ case EQUAL:
++ {
++ switch ( LA(4) )
++ {
++ case DOWN:
++ {
++ switch ( LA(5) )
++ {
++ case FIELD:
++ {
++ switch ( LA(6) )
++ {
++ case STR:
++ {
++ alt1=4;
++ }
++ break;
++ case INT:
++ {
++ alt1=6;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 15;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 14;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 11;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++ case LESS:
++ case GREATER:
++ case LTE:
++ case GTE:
++ {
++ alt1=6;
++ }
++ break;
++ case INCLUDES:
++ case STARTSW:
++ case ENDSW:
++ {
++ alt1=4;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 9;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 5;
++
++
++ goto ruleexprEx;
++ }
++
++ }
++ break;
++ case LESS:
++ case GREATER:
++ case LTE:
++ case GTE:
++ {
++ alt1=5;
++ }
++ break;
++ case BEFORE:
++ case AFTER:
++ {
++ alt1=7;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 0;
++
++
++ goto ruleexprEx;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // RSP2SQL.g:76:4: ^( AND a= expr b= expr )
++ {
++ MATCHT(AND, &FOLLOW_AND_in_expr95);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr101);
++ a=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr107);
++ b=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ if (!a.valid || !b.valid)
++ {
++ retval.valid= 0;
++ }
++ else
++ {
++ retval.result= a.result->factory->newRaw(a.result->factory);
++ retval.result->append8(retval.result, "(");
++ retval.result->appendS(retval.result, a.result);
++ retval.result->append8(retval.result, " AND ");
++ retval.result->appendS(retval.result, b.result);
++ retval.result->append8(retval.result, ")");
++ }
++
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:92:4: ^( OR a= expr b= expr )
++ {
++ MATCHT(OR, &FOLLOW_OR_in_expr118);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr124);
++ a=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_expr_in_expr130);
++ b=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ if (!a.valid || !b.valid)
++ {
++ retval.valid= 0;
++ }
++ else
++ {
++ retval.result= a.result->factory->newRaw(a.result->factory);
++ retval.result->append8(retval.result, "(");
++ retval.result->appendS(retval.result, a.result);
++ retval.result->append8(retval.result, " OR ");
++ retval.result->appendS(retval.result, b.result);
++ retval.result->append8(retval.result, ")");
++ }
++
++ }
++
++ }
++ break;
++ case 3:
++ // RSP2SQL.g:108:4: c= strcrit
++ {
++ FOLLOWPUSH(FOLLOW_strcrit_in_expr144);
++ c=strcrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ retval.valid= c.valid;
++ retval.result= c.result;
++
++ }
++
++ }
++ break;
++ case 4:
++ // RSP2SQL.g:113:4: ^( NOT c= strcrit )
++ {
++ MATCHT(NOT, &FOLLOW_NOT_in_expr154);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_strcrit_in_expr160);
++ c=strcrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ if (!c.valid)
++ {
++ retval.valid= 0;
++ }
++ else
++ {
++ retval.result= c.result->factory->newRaw(c.result->factory);
++ retval.result->append8(retval.result, "(NOT ");
++ retval.result->appendS(retval.result, c.result);
++ retval.result->append8(retval.result, ")");
++ }
++
++ }
++
++ }
++ break;
++ case 5:
++ // RSP2SQL.g:127:4: i= intcrit
++ {
++ FOLLOWPUSH(FOLLOW_intcrit_in_expr174);
++ i=intcrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ retval.valid= i.valid;
++ retval.result= i.result;
++
++ }
++
++ }
++ break;
++ case 6:
++ // RSP2SQL.g:132:4: ^( NOT i= intcrit )
++ {
++ MATCHT(NOT, &FOLLOW_NOT_in_expr184);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_intcrit_in_expr190);
++ i=intcrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ if (!i.valid)
++ {
++ retval.valid= 0;
++ }
++ else
++ {
++ retval.result= i.result->factory->newRaw(i.result->factory);
++ retval.result->append8(retval.result, "(NOT ");
++ retval.result->appendS(retval.result, i.result);
++ retval.result->append8(retval.result, ")");
++ }
++
++ }
++
++ }
++ break;
++ case 7:
++ // RSP2SQL.g:146:4: d= datecrit
++ {
++ FOLLOWPUSH(FOLLOW_datecrit_in_expr204);
++ d=datecrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ {
++
++ retval.valid= d.valid;
++ retval.result= d.result;
++
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleexprEx; /* Prevent compiler warnings */
++ ruleexprEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end expr */
++
++/**
++ * $ANTLR start strcrit
++ * RSP2SQL.g:153:1: strcrit returns [ pANTLR3_STRING result, int valid ] : ^(o= strop f= FIELD s= STR ) ;
++ */
++static RSP2SQL_strcrit_return
++strcrit(pRSP2SQL ctx)
++{
++ RSP2SQL_strcrit_return retval;
++
++ pANTLR3_BASE_TREE f;
++ pANTLR3_BASE_TREE s;
++ pANTLR3_COMMON_TOKEN o;
++ #undef RETURN_TYPE_o
++ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
++
++ /* Initialize rule variables
++ */
++
++
++ retval.result= NULL; retval.valid= 1;
++ f = NULL;
++ s = NULL;
++ o = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ // RSP2SQL.g:155:2: ( ^(o= strop f= FIELD s= STR ) )
++ // RSP2SQL.g:155:4: ^(o= strop f= FIELD s= STR )
++ {
++ FOLLOWPUSH(FOLLOW_strop_in_strcrit233);
++ o=strop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ f = (pANTLR3_BASE_TREE) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit239);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ s = (pANTLR3_BASE_TREE) MATCHT(STR, &FOLLOW_STR_in_strcrit245);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ {
++
++ char *op;
++ const struct rsp_query_field_map *rqfp;
++ pANTLR3_STRING field;
++ char *escaped;
++ ANTLR3_UINT32 optok;
++
++ escaped = NULL;
++
++ op = NULL;
++ optok = o->getType(o);
++ switch (optok)
++ {
++ case EQUAL:
++ op = " = ";
++ break;
++
++ case INCLUDES:
++ case STARTSW:
++ case ENDSW:
++ op = " LIKE ";
++ break;
++ }
++
++ field = f->getText(f);
++
++ /* Field lookup */
++ rqfp = rsp_query_field_lookup((char *)field->chars, strlen((char *)field->chars));
++ if (!rqfp)
++ {
++ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a valid field in queries\n", field->chars);
++ retval.valid= 0;
++ goto strcrit_valid_0; /* ABORT */
++ }
++
++ /* Check field type */
++ if (rqfp->field_type != RSP_TYPE_STRING)
++ {
++ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a string field\n", field->chars);
++ retval.valid= 0;
++ goto strcrit_valid_0; /* ABORT */
++ }
++
++ escaped = db_escape_string((char *)s->getText(s)->chars);
++ if (!escaped)
++ {
++ DPRINTF(E_LOG, L_RSP, "Could not escape value\n");
++ retval.valid= 0;
++ goto strcrit_valid_0; /* ABORT */
++ }
++
++ retval.result= field->factory->newRaw(field->factory);
++ retval.result->append8(retval.result, "f.");
++ retval.result->appendS(retval.result, field);
++ retval.result->append8(retval.result, op);
++ retval.result->append8(retval.result, "'");
++ if ((optok == INCLUDES) || (optok == STARTSW))
++ retval.result->append8(retval.result, "%");
++
++ retval.result->append8(retval.result, escaped);
++
++ if ((optok == INCLUDES) || (optok == ENDSW))
++ retval.result->append8(retval.result, "%");
++ retval.result->append8(retval.result, "'");
++
++ strcrit_valid_0:
++ ;
++
++ if (escaped)
++ free(escaped);
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulestrcritEx; /* Prevent compiler warnings */
++ rulestrcritEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end strcrit */
++
++/**
++ * $ANTLR start strop
++ * RSP2SQL.g:229:1: strop returns [ pANTLR3_COMMON_TOKEN op ] : (n= EQUAL | n= INCLUDES | n= STARTSW | n= ENDSW );
++ */
++static pANTLR3_COMMON_TOKEN
++strop(pRSP2SQL ctx)
++{
++ pANTLR3_COMMON_TOKEN op = NULL;
++
++ pANTLR3_BASE_TREE n;
++
++ /* Initialize rule variables
++ */
++
++
++ op= NULL;
++ n = NULL;
++
++ {
++ {
++ // RSP2SQL.g:231:2: (n= EQUAL | n= INCLUDES | n= STARTSW | n= ENDSW )
++
++ ANTLR3_UINT32 alt2;
++
++ alt2=4;
++
++ switch ( LA(1) )
++ {
++ case EQUAL:
++ {
++ alt2=1;
++ }
++ break;
++ case INCLUDES:
++ {
++ alt2=2;
++ }
++ break;
++ case STARTSW:
++ {
++ alt2=3;
++ }
++ break;
++ case ENDSW:
++ {
++ alt2=4;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 0;
++
++
++ goto rulestropEx;
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // RSP2SQL.g:231:4: n= EQUAL
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(EQUAL, &FOLLOW_EQUAL_in_strop274);
++ if (HASEXCEPTION())
++ {
++ goto rulestropEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:233:4: n= INCLUDES
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(INCLUDES, &FOLLOW_INCLUDES_in_strop287);
++ if (HASEXCEPTION())
++ {
++ goto rulestropEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 3:
++ // RSP2SQL.g:235:4: n= STARTSW
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(STARTSW, &FOLLOW_STARTSW_in_strop300);
++ if (HASEXCEPTION())
++ {
++ goto rulestropEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 4:
++ // RSP2SQL.g:237:4: n= ENDSW
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(ENDSW, &FOLLOW_ENDSW_in_strop313);
++ if (HASEXCEPTION())
++ {
++ goto rulestropEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulestropEx; /* Prevent compiler warnings */
++ rulestropEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return op;
++}
++/* $ANTLR end strop */
++
++/**
++ * $ANTLR start intcrit
++ * RSP2SQL.g:241:1: intcrit returns [ pANTLR3_STRING result, int valid ] : ^(o= intop f= FIELD i= INT ) ;
++ */
++static RSP2SQL_intcrit_return
++intcrit(pRSP2SQL ctx)
++{
++ RSP2SQL_intcrit_return retval;
++
++ pANTLR3_BASE_TREE f;
++ pANTLR3_BASE_TREE i;
++ pANTLR3_COMMON_TOKEN o;
++ #undef RETURN_TYPE_o
++ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
++
++ /* Initialize rule variables
++ */
++
++
++ retval.result= NULL; retval.valid= 1;
++ f = NULL;
++ i = NULL;
++ o = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ // RSP2SQL.g:243:2: ( ^(o= intop f= FIELD i= INT ) )
++ // RSP2SQL.g:243:4: ^(o= intop f= FIELD i= INT )
++ {
++ FOLLOWPUSH(FOLLOW_intop_in_intcrit342);
++ o=intop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ f = (pANTLR3_BASE_TREE) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit348);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ i = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_intcrit354);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ {
++
++ char *op;
++ const struct rsp_query_field_map *rqfp;
++ pANTLR3_STRING field;
++
++ op = NULL;
++ switch (o->getType(o))
++ {
++ case EQUAL:
++ op = " = ";
++ break;
++
++ case LESS:
++ op = " < ";
++ break;
++
++ case GREATER:
++ op = " > ";
++ break;
++
++ case LTE:
++ op = " <= ";
++ break;
++
++ case GTE:
++ op = " >= ";
++ break;
++ }
++
++ field = f->getText(f);
++
++ /* Field lookup */
++ rqfp = rsp_query_field_lookup((char *)field->chars, strlen((char *)field->chars));
++ if (!rqfp)
++ {
++ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a valid field in queries\n", field->chars);
++ retval.valid= 0;
++ goto intcrit_valid_0; /* ABORT */
++ }
++
++ /* Check field type */
++ if (rqfp->field_type != RSP_TYPE_INT)
++ {
++ DPRINTF(E_LOG, L_RSP, "Field '%s' is not an integer field\n", field->chars);
++ retval.valid= 0;
++ goto intcrit_valid_0; /* ABORT */
++ }
++
++ retval.result= field->factory->newRaw(field->factory);
++ retval.result->append8(retval.result, "f.");
++ retval.result->appendS(retval.result, field);
++ retval.result->append8(retval.result, op);
++ retval.result->appendS(retval.result, i->getText(i));
++
++ intcrit_valid_0:
++ ;
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleintcritEx; /* Prevent compiler warnings */
++ ruleintcritEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end intcrit */
++
++/**
++ * $ANTLR start intop
++ * RSP2SQL.g:303:1: intop returns [ pANTLR3_COMMON_TOKEN op ] : (n= EQUAL | n= LESS | n= GREATER | n= LTE | n= GTE );
++ */
++static pANTLR3_COMMON_TOKEN
++intop(pRSP2SQL ctx)
++{
++ pANTLR3_COMMON_TOKEN op = NULL;
++
++ pANTLR3_BASE_TREE n;
++
++ /* Initialize rule variables
++ */
++
++
++ op= NULL;
++ n = NULL;
++
++ {
++ {
++ // RSP2SQL.g:305:2: (n= EQUAL | n= LESS | n= GREATER | n= LTE | n= GTE )
++
++ ANTLR3_UINT32 alt3;
++
++ alt3=5;
++
++ switch ( LA(1) )
++ {
++ case EQUAL:
++ {
++ alt3=1;
++ }
++ break;
++ case LESS:
++ {
++ alt3=2;
++ }
++ break;
++ case GREATER:
++ {
++ alt3=3;
++ }
++ break;
++ case LTE:
++ {
++ alt3=4;
++ }
++ break;
++ case GTE:
++ {
++ alt3=5;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 0;
++
++
++ goto ruleintopEx;
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // RSP2SQL.g:305:4: n= EQUAL
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(EQUAL, &FOLLOW_EQUAL_in_intop383);
++ if (HASEXCEPTION())
++ {
++ goto ruleintopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:307:4: n= LESS
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(LESS, &FOLLOW_LESS_in_intop396);
++ if (HASEXCEPTION())
++ {
++ goto ruleintopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 3:
++ // RSP2SQL.g:309:4: n= GREATER
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(GREATER, &FOLLOW_GREATER_in_intop409);
++ if (HASEXCEPTION())
++ {
++ goto ruleintopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 4:
++ // RSP2SQL.g:311:4: n= LTE
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(LTE, &FOLLOW_LTE_in_intop422);
++ if (HASEXCEPTION())
++ {
++ goto ruleintopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 5:
++ // RSP2SQL.g:313:4: n= GTE
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(GTE, &FOLLOW_GTE_in_intop435);
++ if (HASEXCEPTION())
++ {
++ goto ruleintopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleintopEx; /* Prevent compiler warnings */
++ ruleintopEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return op;
++}
++/* $ANTLR end intop */
++
++/**
++ * $ANTLR start datecrit
++ * RSP2SQL.g:317:1: datecrit returns [ pANTLR3_STRING result, int valid ] : ^(o= dateop f= FIELD d= datespec ) ;
++ */
++static RSP2SQL_datecrit_return
++datecrit(pRSP2SQL ctx)
++{
++ RSP2SQL_datecrit_return retval;
++
++ pANTLR3_BASE_TREE f;
++ pANTLR3_COMMON_TOKEN o;
++ #undef RETURN_TYPE_o
++ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
++
++ RSP2SQL_datespec_return d;
++ #undef RETURN_TYPE_d
++ #define RETURN_TYPE_d RSP2SQL_datespec_return
++
++ /* Initialize rule variables
++ */
++
++
++ retval.result= NULL; retval.valid= 1;
++ f = NULL;
++ o = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ // RSP2SQL.g:319:2: ( ^(o= dateop f= FIELD d= datespec ) )
++ // RSP2SQL.g:319:4: ^(o= dateop f= FIELD d= datespec )
++ {
++ FOLLOWPUSH(FOLLOW_dateop_in_datecrit464);
++ o=dateop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++ f = (pANTLR3_BASE_TREE) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit470);
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_datespec_in_datecrit476);
++ d=datespec(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++ {
++
++ char *op;
++ const struct rsp_query_field_map *rqfp;
++ pANTLR3_STRING field;
++ char buf[32];
++ int ret;
++
++ op = NULL;
++ switch (o->getType(o))
++ {
++ case BEFORE:
++ op = " < ";
++ break;
++
++ case AFTER:
++ op = " > ";
++ break;
++ }
++
++ field = f->getText(f);
++
++ /* Field lookup */
++ rqfp = rsp_query_field_lookup((char *)field->chars, strlen((char *)field->chars));
++ if (!rqfp)
++ {
++ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a valid field in queries\n", field->chars);
++ retval.valid= 0;
++ goto datecrit_valid_0; /* ABORT */
++ }
++
++ /* Check field type */
++ if (rqfp->field_type != RSP_TYPE_DATE)
++ {
++ DPRINTF(E_LOG, L_RSP, "Field '%s' is not a date field\n", field->chars);
++ retval.valid= 0;
++ goto datecrit_valid_0; /* ABORT */
++ }
++
++ ret = snprintf(buf, sizeof(buf), "%ld", d.date);
++ if ((ret < 0) || (ret >= sizeof(buf)))
++ {
++ DPRINTF(E_LOG, L_RSP, "Date %ld too large for buffer, oops!\n", d.date);
++ retval.valid= 0;
++ goto datecrit_valid_0; /* ABORT */
++ }
++
++ retval.result= field->factory->newRaw(field->factory);
++ retval.result->append8(retval.result, "f.");
++ retval.result->appendS(retval.result, field);
++ retval.result->append8(retval.result, op);
++ retval.result->append8(retval.result, buf);
++
++ datecrit_valid_0:
++ ;
++
++ }
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledatecritEx; /* Prevent compiler warnings */
++ ruledatecritEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end datecrit */
++
++/**
++ * $ANTLR start dateop
++ * RSP2SQL.g:377:1: dateop returns [ pANTLR3_COMMON_TOKEN op ] : (n= BEFORE | n= AFTER );
++ */
++static pANTLR3_COMMON_TOKEN
++dateop(pRSP2SQL ctx)
++{
++ pANTLR3_COMMON_TOKEN op = NULL;
++
++ pANTLR3_BASE_TREE n;
++
++ /* Initialize rule variables
++ */
++
++
++ op= NULL;
++ n = NULL;
++
++ {
++ {
++ // RSP2SQL.g:379:2: (n= BEFORE | n= AFTER )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=2;
++
++ switch ( LA(1) )
++ {
++ case BEFORE:
++ {
++ alt4=1;
++ }
++ break;
++ case AFTER:
++ {
++ alt4=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto ruledateopEx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // RSP2SQL.g:379:4: n= BEFORE
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(BEFORE, &FOLLOW_BEFORE_in_dateop505);
++ if (HASEXCEPTION())
++ {
++ goto ruledateopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:381:4: n= AFTER
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(AFTER, &FOLLOW_AFTER_in_dateop518);
++ if (HASEXCEPTION())
++ {
++ goto ruledateopEx;
++ }
++
++ {
++ op= n->getToken(n);
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledateopEx; /* Prevent compiler warnings */
++ ruledateopEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return op;
++}
++/* $ANTLR end dateop */
++
++/**
++ * $ANTLR start datespec
++ * RSP2SQL.g:385:1: datespec returns [ time_t date, int valid ] : (r= dateref | ^(o= dateop r= dateref m= INT i= dateintval ) );
++ */
++static RSP2SQL_datespec_return
++datespec(pRSP2SQL ctx)
++{
++ RSP2SQL_datespec_return retval;
++
++ pANTLR3_BASE_TREE m;
++ RSP2SQL_dateref_return r;
++ #undef RETURN_TYPE_r
++ #define RETURN_TYPE_r RSP2SQL_dateref_return
++
++ pANTLR3_COMMON_TOKEN o;
++ #undef RETURN_TYPE_o
++ #define RETURN_TYPE_o pANTLR3_COMMON_TOKEN
++
++ RSP2SQL_dateintval_return i;
++ #undef RETURN_TYPE_i
++ #define RETURN_TYPE_i RSP2SQL_dateintval_return
++
++ /* Initialize rule variables
++ */
++
++
++ retval.date= 0; retval.valid= 1;
++ m = NULL;
++ o = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ {
++ // RSP2SQL.g:387:2: (r= dateref | ^(o= dateop r= dateref m= INT i= dateintval ) )
++
++ ANTLR3_UINT32 alt5;
++
++ alt5=2;
++
++ switch ( LA(1) )
++ {
++ case DATE:
++ case TODAY:
++ {
++ alt5=1;
++ }
++ break;
++ case BEFORE:
++ case AFTER:
++ {
++ alt5=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 0;
++
++
++ goto ruledatespecEx;
++ }
++
++ switch (alt5)
++ {
++ case 1:
++ // RSP2SQL.g:387:4: r= dateref
++ {
++ FOLLOWPUSH(FOLLOW_dateref_in_datespec546);
++ r=dateref(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ {
++
++ if (!r.valid)
++ retval.valid= 0;
++ else
++ retval.date= r.date;
++
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:394:4: ^(o= dateop r= dateref m= INT i= dateintval )
++ {
++ FOLLOWPUSH(FOLLOW_dateop_in_datespec560);
++ o=dateop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_DOWN, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_dateref_in_datespec566);
++ r=dateref(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ m = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_datespec572);
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ FOLLOWPUSH(FOLLOW_dateintval_in_datespec578);
++ i=dateintval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++
++ MATCHT(ANTLR3_TOKEN_UP, NULL);
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ {
++
++ int32_t val;
++ int ret;
++
++ if (!r.valid || !i.valid)
++ {
++ retval.valid= 0;
++ goto datespec_valid_0; /* ABORT */
++ }
++
++ ret = safe_atoi32((char *)m->getText(m)->chars, &val);
++ if (ret < 0)
++ {
++ DPRINTF(E_LOG, L_RSP, "Could not convert '%s' to integer\n", (char *)m->getText(m));
++ retval.valid= 0;
++ goto datespec_valid_0; /* ABORT */
++ }
++
++ switch (o->getType(o))
++ {
++ case BEFORE:
++ retval.date= r.date - (val * i.period);
++ break;
++
++ case AFTER:
++ retval.date= r.date + (val * i.period);
++ break;
++ }
++
++ datespec_valid_0:
++ ;
++
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledatespecEx; /* Prevent compiler warnings */
++ ruledatespecEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end datespec */
++
++/**
++ * $ANTLR start dateref
++ * RSP2SQL.g:429:1: dateref returns [ time_t date, int valid ] : (n= DATE | TODAY );
++ */
++static RSP2SQL_dateref_return
++dateref(pRSP2SQL ctx)
++{
++ RSP2SQL_dateref_return retval;
++
++ pANTLR3_BASE_TREE n;
++
++ /* Initialize rule variables
++ */
++
++
++ retval.date= 0; retval.valid= 1;
++ n = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ {
++ // RSP2SQL.g:431:2: (n= DATE | TODAY )
++
++ ANTLR3_UINT32 alt6;
++
++ alt6=2;
++
++ switch ( LA(1) )
++ {
++ case DATE:
++ {
++ alt6=1;
++ }
++ break;
++ case TODAY:
++ {
++ alt6=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 6;
++ EXCEPTION->state = 0;
++
++
++ goto ruledaterefEx;
++ }
++
++ switch (alt6)
++ {
++ case 1:
++ // RSP2SQL.g:431:4: n= DATE
++ {
++ n = (pANTLR3_BASE_TREE) MATCHT(DATE, &FOLLOW_DATE_in_dateref607);
++ if (HASEXCEPTION())
++ {
++ goto ruledaterefEx;
++ }
++
++ {
++
++ struct tm tm;
++ char *ret;
++
++ ret = strptime((char *)n->getText(n), "%Y-%m-%d", &tm);
++ if (!ret)
++ {
++ DPRINTF(E_LOG, L_RSP, "Date '%s' could not be interpreted\n", (char *)n->getText(n));
++ retval.valid= 0;
++ goto dateref_valid_0; /* ABORT */
++ }
++ else
++ {
++ if (*ret != '\0')
++ DPRINTF(E_LOG, L_RSP, "Garbage at end of date '%s' ?!\n", (char *)n->getText(n));
++
++ retval.date= mktime(&tm);
++ if (retval.date == (time_t) -1)
++ {
++ DPRINTF(E_LOG, L_RSP, "Date '%s' could not be converted to an epoch\n", (char *)n->getText(n));
++ retval.valid= 0;
++ goto dateref_valid_0; /* ABORT */
++ }
++ }
++
++ dateref_valid_0:
++ ;
++
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:460:4: TODAY
++ {
++ MATCHT(TODAY, &FOLLOW_TODAY_in_dateref616);
++ if (HASEXCEPTION())
++ {
++ goto ruledaterefEx;
++ }
++
++ {
++ retval.date= time(NULL);
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledaterefEx; /* Prevent compiler warnings */
++ ruledaterefEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end dateref */
++
++/**
++ * $ANTLR start dateintval
++ * RSP2SQL.g:464:1: dateintval returns [ time_t period, int valid ] : ( DAY | WEEK | MONTH | YEAR );
++ */
++static RSP2SQL_dateintval_return
++dateintval(pRSP2SQL ctx)
++{
++ RSP2SQL_dateintval_return retval;
++
++ /* Initialize rule variables
++ */
++
++
++ retval.period= 0; retval.valid= 1;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ {
++ {
++ // RSP2SQL.g:466:2: ( DAY | WEEK | MONTH | YEAR )
++
++ ANTLR3_UINT32 alt7;
++
++ alt7=4;
++
++ switch ( LA(1) )
++ {
++ case DAY:
++ {
++ alt7=1;
++ }
++ break;
++ case WEEK:
++ {
++ alt7=2;
++ }
++ break;
++ case MONTH:
++ {
++ alt7=3;
++ }
++ break;
++ case YEAR:
++ {
++ alt7=4;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 7;
++ EXCEPTION->state = 0;
++
++
++ goto ruledateintvalEx;
++ }
++
++ switch (alt7)
++ {
++ case 1:
++ // RSP2SQL.g:466:4: DAY
++ {
++ MATCHT(DAY, &FOLLOW_DAY_in_dateintval640);
++ if (HASEXCEPTION())
++ {
++ goto ruledateintvalEx;
++ }
++
++ {
++ retval.period= 24 * 60 * 60;
++ }
++
++ }
++ break;
++ case 2:
++ // RSP2SQL.g:468:4: WEEK
++ {
++ MATCHT(WEEK, &FOLLOW_WEEK_in_dateintval649);
++ if (HASEXCEPTION())
++ {
++ goto ruledateintvalEx;
++ }
++
++ {
++ retval.period= 7 * 24 * 60 * 60;
++ }
++
++ }
++ break;
++ case 3:
++ // RSP2SQL.g:470:4: MONTH
++ {
++ MATCHT(MONTH, &FOLLOW_MONTH_in_dateintval658);
++ if (HASEXCEPTION())
++ {
++ goto ruledateintvalEx;
++ }
++
++ {
++ retval.period= 30 * 24 * 60 * 60;
++ }
++
++ }
++ break;
++ case 4:
++ // RSP2SQL.g:472:4: YEAR
++ {
++ MATCHT(YEAR, &FOLLOW_YEAR_in_dateintval667);
++ if (HASEXCEPTION())
++ {
++ goto ruledateintvalEx;
++ }
++
++ {
++ retval.period= 365 * 24 * 60 * 60;
++ }
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledateintvalEx; /* Prevent compiler warnings */
++ ruledateintvalEx: ;
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ }
++
++
++ return retval;
++}
++/* $ANTLR end dateintval */
++/* End of parsing rules
++ * ==============================================
++ */
++
++/* ==============================================
++ * Syntactic predicates
++ */
++/* End of syntactic predicates
++ * ==============================================
++ */
++
++
++
++
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/RSP2SQL.h b/src/pregen/RSP2SQL.h
+new file mode 100644
+index 0000000..2789fc7
+--- /dev/null
++++ b/src/pregen/RSP2SQL.h
+@@ -0,0 +1,291 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : RSP2SQL.g
++ * - On : 2014-09-30 21:42:42
++ * - for the tree parser : RSP2SQLTreeParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The tree parser RSP2SQL has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pRSP2SQL, which is returned from a call to RSP2SQLNew().
++ *
++ * The methods in pRSP2SQL are as follows:
++ *
++ * - pANTLR3_STRING pRSP2SQL->query(pRSP2SQL)
++ * - RSP2SQL_expr_return pRSP2SQL->expr(pRSP2SQL)
++ * - RSP2SQL_strcrit_return pRSP2SQL->strcrit(pRSP2SQL)
++ * - pANTLR3_COMMON_TOKEN pRSP2SQL->strop(pRSP2SQL)
++ * - RSP2SQL_intcrit_return pRSP2SQL->intcrit(pRSP2SQL)
++ * - pANTLR3_COMMON_TOKEN pRSP2SQL->intop(pRSP2SQL)
++ * - RSP2SQL_datecrit_return pRSP2SQL->datecrit(pRSP2SQL)
++ * - pANTLR3_COMMON_TOKEN pRSP2SQL->dateop(pRSP2SQL)
++ * - RSP2SQL_datespec_return pRSP2SQL->datespec(pRSP2SQL)
++ * - RSP2SQL_dateref_return pRSP2SQL->dateref(pRSP2SQL)
++ * - RSP2SQL_dateintval_return pRSP2SQL->dateintval(pRSP2SQL)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _RSP2SQL_H
++#define _RSP2SQL_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct RSP2SQL_Ctx_struct RSP2SQL, * pRSP2SQL;
++
++
++
++ /* Needs #define _GNU_SOURCE for strptime() */
++
++ #include <stdio.h>
++ #include <string.h>
++ #include <time.h>
++ #include <stdint.h>
++
++ #include "logger.h"
++ #include "db.h"
++ #include "misc.h"
++ #include "rsp_query.h"
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++typedef struct RSP2SQL_expr_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ pANTLR3_STRING result;
++ int valid;
++}
++ RSP2SQL_expr_return;
++
++typedef struct RSP2SQL_strcrit_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ pANTLR3_STRING result;
++ int valid;
++}
++ RSP2SQL_strcrit_return;
++
++typedef struct RSP2SQL_intcrit_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ pANTLR3_STRING result;
++ int valid;
++}
++ RSP2SQL_intcrit_return;
++
++typedef struct RSP2SQL_datecrit_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ pANTLR3_STRING result;
++ int valid;
++}
++ RSP2SQL_datecrit_return;
++
++typedef struct RSP2SQL_datespec_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ time_t date;
++ int valid;
++}
++ RSP2SQL_datespec_return;
++
++typedef struct RSP2SQL_dateref_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ time_t date;
++ int valid;
++}
++ RSP2SQL_dateref_return;
++
++typedef struct RSP2SQL_dateintval_return_struct
++{
++ pANTLR3_BASE_TREE start;
++ pANTLR3_BASE_TREE stop;
++ time_t period;
++ int valid;
++}
++ RSP2SQL_dateintval_return;
++
++
++
++/** Context tracking structure for RSP2SQL
++ */
++struct RSP2SQL_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_TREE_PARSER pTreeParser;
++
++
++ pANTLR3_STRING (*query) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_expr_return (*expr) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_strcrit_return (*strcrit) (struct RSP2SQL_Ctx_struct * ctx);
++ pANTLR3_COMMON_TOKEN (*strop) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_intcrit_return (*intcrit) (struct RSP2SQL_Ctx_struct * ctx);
++ pANTLR3_COMMON_TOKEN (*intop) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_datecrit_return (*datecrit) (struct RSP2SQL_Ctx_struct * ctx);
++ pANTLR3_COMMON_TOKEN (*dateop) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_datespec_return (*datespec) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_dateref_return (*dateref) (struct RSP2SQL_Ctx_struct * ctx);
++ RSP2SQL_dateintval_return (*dateintval) (struct RSP2SQL_Ctx_struct * ctx);
++ // Delegated rules
++ const char * (*getGrammarFileName)();
++ void (*free) (struct RSP2SQL_Ctx_struct * ctx);
++
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pRSP2SQL RSP2SQLNew (pANTLR3_COMMON_TREE_NODE_STREAM instream);
++ANTLR3_API pRSP2SQL RSP2SQLNewSSD (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the tree parser will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define STARTSW 14
++#define WEEK 26
++#define TODAY 24
++#define YEAR 28
++#define ENDSW 15
++#define GTE 20
++#define BEFORE 21
++#define DAY 25
++#define INT 16
++#define NOT 11
++#define AFTER 22
++#define AND 6
++#define EOF -1
++#define LTE 19
++#define MONTH 27
++#define DIGIT19 31
++#define INCLUDES 13
++#define STR 10
++#define QUOTE 29
++#define GREATER 18
++#define WS 30
++#define LPAR 7
++#define NEWLINE 4
++#define EQUAL 12
++#define OR 5
++#define LESS 17
++#define FIELD 9
++#define RPAR 8
++#define ESCAPED 33
++#define DATE 23
++#define DIGIT09 32
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for RSP2SQL
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/RSP2SQL.u b/src/pregen/RSP2SQL.u
+new file mode 100644
+index 0000000..53d8cda
+--- /dev/null
++++ b/src/pregen/RSP2SQL.u
+@@ -0,0 +1,5 @@
++RSP2SQL.g: RSP.tokens
++RSP2SQL.c : RSP2SQL.g
++./RSP2SQL.tokens : RSP2SQL.g
++RSP2SQL.h : RSP2SQL.g
++ANTLR_PRODUCTS += RSP2SQL.c ./RSP2SQL.tokens RSP2SQL.h
+\ No newline at end of file
+diff --git a/src/pregen/RSPLexer.c b/src/pregen/RSPLexer.c
+new file mode 100644
+index 0000000..ee23c08
+--- /dev/null
++++ b/src/pregen/RSPLexer.c
+@@ -0,0 +1,4867 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : RSP.g
++ * - On : 2014-09-30 21:42:41
++ * - for the lexer : RSPLexerLexer *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "RSPLexer.h"
++/* ----------------------------------------- */
++
++
++/** String literals used by RSPLexer that we must do things like MATCHS() with.
++ * C will normally just lay down 8 bit characters, and you can use L"xxx" to
++ * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
++ * we perform this little trick of defining the literals as arrays of UINT32
++ * and passing in the address of these.
++ */
++static ANTLR3_UCHAR lit_1[] = { 0x61, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_2[] = { 0x6F, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_3[] = { 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_4[] = { 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x77, 0x69, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_5[] = { 0x65, 0x6E, 0x64, 0x73, 0x77, 0x69, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_6[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_7[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_8[] = { 0x62, 0x65, 0x66, 0x6F, 0x72, 0x65, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_9[] = { 0x61, 0x66, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_10[] = { 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_11[] = { 0x64, 0x61, 0x79, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_12[] = { 0x77, 0x65, 0x65, 0x6B, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_13[] = { 0x77, 0x65, 0x65, 0x6B, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_14[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_15[] = { 0x6D, 0x6F, 0x6E, 0x74, 0x68, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_16[] = { 0x79, 0x65, 0x61, 0x72, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_17[] = { 0x79, 0x65, 0x61, 0x72, 0x73, ANTLR3_STRING_TERMINATOR};
++static ANTLR3_UCHAR lit_18[] = { 0x74, 0x6F, 0x64, 0x61, 0x79, ANTLR3_STRING_TERMINATOR};
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pRSPLexer_##scope##_SCOPE
++#define SCOPE_STACK(scope) pRSPLexer_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pRSPLexer_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pRSPLexer_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++
++/* Macros for accessing things in a lexer
++ */
++#undef LEXER
++#undef RECOGNIZER
++#undef RULEMEMO
++#undef GETCHARINDEX
++#undef GETLINE
++#undef GETCHARPOSITIONINLINE
++#undef EMIT
++#undef EMITNEW
++#undef MATCHC
++#undef MATCHS
++#undef MATCHRANGE
++#undef LTOKEN
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef INPUT
++#undef STRSTREAM
++#undef LA
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef LRECOVER
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef BACKTRACKING
++#undef MATCHANY
++#undef MEMOIZE
++#undef HAVEPARSEDRULE
++#undef GETTEXT
++#undef INDEX
++#undef SEEK
++#undef PUSHSTREAM
++#undef POPSTREAM
++#undef SETTEXT
++#undef SETTEXT8
++
++#define LEXER ctx->pLexer
++#define RECOGNIZER LEXER->rec
++#define LEXSTATE RECOGNIZER->state
++#define TOKSOURCE LEXSTATE->tokSource
++#define GETCHARINDEX() LEXER->getCharIndex(LEXER)
++#define GETLINE() LEXER->getLine(LEXER)
++#define GETTEXT() LEXER->getText(LEXER)
++#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
++#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER)
++#define EMITNEW(t) LEXER->emitNew(LEXER, t)
++#define MATCHC(c) LEXER->matchc(LEXER, c)
++#define MATCHS(s) LEXER->matchs(LEXER, s)
++#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2)
++#define MATCHANY() LEXER->matchAny(LEXER)
++#define LTOKEN LEXSTATE->token
++#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE)
++#define BACKTRACKING LEXSTATE->backtracking
++#define FAILEDFLAG LEXSTATE->failed
++#define INPUT LEXER->input
++#define STRSTREAM INPUT
++#define ISTREAM INPUT->istream
++#define INDEX() ISTREAM->index(ISTREAM)
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken)
++#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION LEXSTATE->exception
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define LRECOVER() LEXER->recover(LEXER)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str)
++#define POPSTREAM() LEXER->popCharStream(LEXER)
++#define SETTEXT(str) LEXSTATE->text = str
++#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken)
++#define USER1 LEXSTATE->user1
++#define USER2 LEXSTATE->user2
++#define USER3 LEXSTATE->user3
++#define CUSTOM LEXSTATE->custom
++#define RULEMEMO LEXSTATE->ruleMemo
++#define DBG RECOGNIZER->debugger
++
++/* If we have been told we can rely on the standard 8 bit or 16 bit input
++ * stream, then we can define our macros to use the direct pointers
++ * in the input object, which is much faster than indirect calls. This
++ * is really only significant to lexers with a lot of fragment rules (which
++ * do not place LA(1) in a temporary at the moment) and even then
++ * only if there is a lot of input (order of say 1M or so).
++ */
++#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
++
++# ifdef ANTLR3_INLINE_INPUT_ASCII
++
++/* 8 bit "ASCII" (actually any 8 bit character set) */
++
++# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar))
++# define DATAP ((pANTLR3_UINT8)(INPUT->data))
++
++# else
++
++# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar))
++# define DATAP ((pANTLR3_UINT16)(INPUT->data))
++
++# endif
++
++# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
++# define CONSUME() \
++{ \
++ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \
++ { \
++ INPUT->charPositionInLine++; \
++ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \
++ { \
++ INPUT->line++; \
++ INPUT->charPositionInLine = 0; \
++ INPUT->currentLine = (void *)(NEXTCHAR + 1); \
++ } \
++ INPUT->nextChar = (void *)(NEXTCHAR + 1); \
++ } \
++}
++
++#else
++
++// Pick up the input character by calling the input stream implementation.
++//
++#define CONSUME() INPUT->istream->consume(INPUT->istream)
++#define LA(n) INPUT->istream->_LA(INPUT->istream, n)
++
++#endif
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++/* Forward declare the locally static matching functions we have generated and any predicate functions.
++ */
++static ANTLR3_INLINE void mQUOTE (pRSPLexer ctx);
++static ANTLR3_INLINE void mLPAR (pRSPLexer ctx);
++static ANTLR3_INLINE void mRPAR (pRSPLexer ctx);
++static ANTLR3_INLINE void mAND (pRSPLexer ctx);
++static ANTLR3_INLINE void mOR (pRSPLexer ctx);
++static ANTLR3_INLINE void mNOT (pRSPLexer ctx);
++static ANTLR3_INLINE void mEQUAL (pRSPLexer ctx);
++static ANTLR3_INLINE void mINCLUDES (pRSPLexer ctx);
++static ANTLR3_INLINE void mSTARTSW (pRSPLexer ctx);
++static ANTLR3_INLINE void mENDSW (pRSPLexer ctx);
++static ANTLR3_INLINE void mGREATER (pRSPLexer ctx);
++static ANTLR3_INLINE void mLESS (pRSPLexer ctx);
++static ANTLR3_INLINE void mGTE (pRSPLexer ctx);
++static ANTLR3_INLINE void mLTE (pRSPLexer ctx);
++static ANTLR3_INLINE void mBEFORE (pRSPLexer ctx);
++static ANTLR3_INLINE void mAFTER (pRSPLexer ctx);
++static ANTLR3_INLINE void mDAY (pRSPLexer ctx);
++static ANTLR3_INLINE void mWEEK (pRSPLexer ctx);
++static ANTLR3_INLINE void mMONTH (pRSPLexer ctx);
++static ANTLR3_INLINE void mYEAR (pRSPLexer ctx);
++static ANTLR3_INLINE void mTODAY (pRSPLexer ctx);
++static ANTLR3_INLINE void mNEWLINE (pRSPLexer ctx);
++static ANTLR3_INLINE void mWS (pRSPLexer ctx);
++static ANTLR3_INLINE void mFIELD (pRSPLexer ctx);
++static ANTLR3_INLINE void mINT (pRSPLexer ctx);
++static ANTLR3_INLINE void mDATE (pRSPLexer ctx);
++static ANTLR3_INLINE void mSTR (pRSPLexer ctx);
++static ANTLR3_INLINE void mESCAPED (pRSPLexer ctx);
++static ANTLR3_INLINE void mDIGIT09 (pRSPLexer ctx);
++static ANTLR3_INLINE void mDIGIT19 (pRSPLexer ctx);
++static ANTLR3_INLINE void mTokens (pRSPLexer ctx);
++static void RSPLexerFree(pRSPLexer ctx);
++
++/* =========================================================================
++ * Lexer matching rules end.
++ * =========================================================================
++ */
++
++
++
++static void
++RSPLexerFree (pRSPLexer ctx)
++{
++ LEXER->free(LEXER);
++
++ ANTLR3_FREE(ctx);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "RSP.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++
++/** \brief Create a new lexer called RSPLexer
++ *
++ * \param[in] instream Pointer to an initialized input stream
++ * \return
++ * - Success pRSPLexer initialized for the lex start
++ * - Fail NULL
++ */
++ANTLR3_API pRSPLexer RSPLexerNew
++(pANTLR3_INPUT_STREAM instream)
++{
++ // See if we can create a new lexer with the standard constructor
++ //
++ return RSPLexerNewSSD(instream, NULL);
++}
++
++/** \brief Create a new lexer called RSPLexer
++ *
++ * \param[in] instream Pointer to an initialized input stream
++ * \param[state] state Previously created shared recognizer stat
++ * \return
++ * - Success pRSPLexer initialized for the lex start
++ * - Fail NULL
++ */
++ANTLR3_API pRSPLexer RSPLexerNewSSD
++(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pRSPLexer ctx; // Context structure we will build and return
++
++ ctx = (pRSPLexer) ANTLR3_CALLOC(1, sizeof(RSPLexer));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for lexer context
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * in base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 lexer function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in RSPLexer.h here so you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base lexer, using the supplied input stream
++ */
++ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
++
++ /* Check that we allocated the memory correctly
++ */
++ if (ctx->pLexer == NULL)
++ {
++ ANTLR3_FREE(ctx);
++ return NULL;
++ }
++ /* Install the implementation of our RSPLexer interface
++ */
++ ctx->mQUOTE = mQUOTE;
++ ctx->mLPAR = mLPAR;
++ ctx->mRPAR = mRPAR;
++ ctx->mAND = mAND;
++ ctx->mOR = mOR;
++ ctx->mNOT = mNOT;
++ ctx->mEQUAL = mEQUAL;
++ ctx->mINCLUDES = mINCLUDES;
++ ctx->mSTARTSW = mSTARTSW;
++ ctx->mENDSW = mENDSW;
++ ctx->mGREATER = mGREATER;
++ ctx->mLESS = mLESS;
++ ctx->mGTE = mGTE;
++ ctx->mLTE = mLTE;
++ ctx->mBEFORE = mBEFORE;
++ ctx->mAFTER = mAFTER;
++ ctx->mDAY = mDAY;
++ ctx->mWEEK = mWEEK;
++ ctx->mMONTH = mMONTH;
++ ctx->mYEAR = mYEAR;
++ ctx->mTODAY = mTODAY;
++ ctx->mNEWLINE = mNEWLINE;
++ ctx->mWS = mWS;
++ ctx->mFIELD = mFIELD;
++ ctx->mINT = mINT;
++ ctx->mDATE = mDATE;
++ ctx->mSTR = mSTR;
++ ctx->mESCAPED = mESCAPED;
++ ctx->mDIGIT09 = mDIGIT09;
++ ctx->mDIGIT19 = mDIGIT19;
++ ctx->mTokens = mTokens;
++
++ /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
++ * it will call mTokens() in this generated code, and will pass it the ctx
++ * pointer of this lexer, not the context of the base lexer, so store that now.
++ */
++ ctx->pLexer->ctx = ctx;
++
++ /**Install the token matching function
++ */
++ ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
++
++ ctx->getGrammarFileName = getGrammarFileName;
++ ctx->free = RSPLexerFree;
++
++
++
++
++
++ /* Return the newly built lexer to the caller
++ */
++ return ctx;
++}
++
++
++/* =========================================================================
++ * Functions to match the lexer grammar defined tokens from the input stream
++ */
++
++// Comes from: 85:7: ( '\"' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start QUOTE
++ *
++ * Looks to match the characters the constitute the token QUOTE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mQUOTE(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = QUOTE;
++
++
++ // RSP.g:85:7: ( '\"' )
++ // RSP.g:85:9: '\"'
++ {
++ MATCHC('"');
++ if (HASEXCEPTION())
++ {
++ goto ruleQUOTEEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleQUOTEEx; /* Prevent compiler warnings */
++ ruleQUOTEEx: ;
++
++}
++// $ANTLR end QUOTE
++
++// Comes from: 86:6: ( '(' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LPAR
++ *
++ * Looks to match the characters the constitute the token LPAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLPAR(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = LPAR;
++
++
++ // RSP.g:86:6: ( '(' )
++ // RSP.g:86:8: '('
++ {
++ MATCHC('(');
++ if (HASEXCEPTION())
++ {
++ goto ruleLPAREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLPAREx; /* Prevent compiler warnings */
++ ruleLPAREx: ;
++
++}
++// $ANTLR end LPAR
++
++// Comes from: 87:6: ( ')' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start RPAR
++ *
++ * Looks to match the characters the constitute the token RPAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mRPAR(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = RPAR;
++
++
++ // RSP.g:87:6: ( ')' )
++ // RSP.g:87:8: ')'
++ {
++ MATCHC(')');
++ if (HASEXCEPTION())
++ {
++ goto ruleRPAREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleRPAREx; /* Prevent compiler warnings */
++ ruleRPAREx: ;
++
++}
++// $ANTLR end RPAR
++
++// Comes from: 89:5: ( 'and' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start AND
++ *
++ * Looks to match the characters the constitute the token AND
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mAND(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = AND;
++
++
++ // RSP.g:89:5: ( 'and' )
++ // RSP.g:89:7: 'and'
++ {
++ MATCHS(lit_1);
++ if (HASEXCEPTION())
++ {
++ goto ruleANDEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleANDEx; /* Prevent compiler warnings */
++ ruleANDEx: ;
++
++}
++// $ANTLR end AND
++
++// Comes from: 90:4: ( 'or' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start OR
++ *
++ * Looks to match the characters the constitute the token OR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mOR(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = OR;
++
++
++ // RSP.g:90:4: ( 'or' )
++ // RSP.g:90:6: 'or'
++ {
++ MATCHS(lit_2);
++ if (HASEXCEPTION())
++ {
++ goto ruleOREx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleOREx; /* Prevent compiler warnings */
++ ruleOREx: ;
++
++}
++// $ANTLR end OR
++
++// Comes from: 91:5: ( '!' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start NOT
++ *
++ * Looks to match the characters the constitute the token NOT
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mNOT(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = NOT;
++
++
++ // RSP.g:91:5: ( '!' )
++ // RSP.g:91:7: '!'
++ {
++ MATCHC('!');
++ if (HASEXCEPTION())
++ {
++ goto ruleNOTEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleNOTEx; /* Prevent compiler warnings */
++ ruleNOTEx: ;
++
++}
++// $ANTLR end NOT
++
++// Comes from: 94:7: ( '=' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start EQUAL
++ *
++ * Looks to match the characters the constitute the token EQUAL
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mEQUAL(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = EQUAL;
++
++
++ // RSP.g:94:7: ( '=' )
++ // RSP.g:94:9: '='
++ {
++ MATCHC('=');
++ if (HASEXCEPTION())
++ {
++ goto ruleEQUALEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleEQUALEx; /* Prevent compiler warnings */
++ ruleEQUALEx: ;
++
++}
++// $ANTLR end EQUAL
++
++// Comes from: 97:9: ( 'includes' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start INCLUDES
++ *
++ * Looks to match the characters the constitute the token INCLUDES
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mINCLUDES(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = INCLUDES;
++
++
++ // RSP.g:97:9: ( 'includes' )
++ // RSP.g:97:11: 'includes'
++ {
++ MATCHS(lit_3);
++ if (HASEXCEPTION())
++ {
++ goto ruleINCLUDESEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleINCLUDESEx; /* Prevent compiler warnings */
++ ruleINCLUDESEx: ;
++
++}
++// $ANTLR end INCLUDES
++
++// Comes from: 98:9: ( 'startswith' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start STARTSW
++ *
++ * Looks to match the characters the constitute the token STARTSW
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mSTARTSW(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = STARTSW;
++
++
++ // RSP.g:98:9: ( 'startswith' )
++ // RSP.g:98:11: 'startswith'
++ {
++ MATCHS(lit_4);
++ if (HASEXCEPTION())
++ {
++ goto ruleSTARTSWEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleSTARTSWEx; /* Prevent compiler warnings */
++ ruleSTARTSWEx: ;
++
++}
++// $ANTLR end STARTSW
++
++// Comes from: 99:7: ( 'endswith' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start ENDSW
++ *
++ * Looks to match the characters the constitute the token ENDSW
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mENDSW(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = ENDSW;
++
++
++ // RSP.g:99:7: ( 'endswith' )
++ // RSP.g:99:9: 'endswith'
++ {
++ MATCHS(lit_5);
++ if (HASEXCEPTION())
++ {
++ goto ruleENDSWEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleENDSWEx; /* Prevent compiler warnings */
++ ruleENDSWEx: ;
++
++}
++// $ANTLR end ENDSW
++
++// Comes from: 102:9: ( '>' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start GREATER
++ *
++ * Looks to match the characters the constitute the token GREATER
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mGREATER(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = GREATER;
++
++
++ // RSP.g:102:9: ( '>' )
++ // RSP.g:102:11: '>'
++ {
++ MATCHC('>');
++ if (HASEXCEPTION())
++ {
++ goto ruleGREATEREx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleGREATEREx; /* Prevent compiler warnings */
++ ruleGREATEREx: ;
++
++}
++// $ANTLR end GREATER
++
++// Comes from: 103:6: ( '<' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LESS
++ *
++ * Looks to match the characters the constitute the token LESS
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLESS(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = LESS;
++
++
++ // RSP.g:103:6: ( '<' )
++ // RSP.g:103:8: '<'
++ {
++ MATCHC('<');
++ if (HASEXCEPTION())
++ {
++ goto ruleLESSEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLESSEx; /* Prevent compiler warnings */
++ ruleLESSEx: ;
++
++}
++// $ANTLR end LESS
++
++// Comes from: 104:5: ( '>=' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start GTE
++ *
++ * Looks to match the characters the constitute the token GTE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mGTE(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = GTE;
++
++
++ // RSP.g:104:5: ( '>=' )
++ // RSP.g:104:7: '>='
++ {
++ MATCHS(lit_6);
++ if (HASEXCEPTION())
++ {
++ goto ruleGTEEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleGTEEx; /* Prevent compiler warnings */
++ ruleGTEEx: ;
++
++}
++// $ANTLR end GTE
++
++// Comes from: 105:5: ( '<=' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start LTE
++ *
++ * Looks to match the characters the constitute the token LTE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mLTE(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = LTE;
++
++
++ // RSP.g:105:5: ( '<=' )
++ // RSP.g:105:7: '<='
++ {
++ MATCHS(lit_7);
++ if (HASEXCEPTION())
++ {
++ goto ruleLTEEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleLTEEx; /* Prevent compiler warnings */
++ ruleLTEEx: ;
++
++}
++// $ANTLR end LTE
++
++// Comes from: 108:8: ( 'before' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start BEFORE
++ *
++ * Looks to match the characters the constitute the token BEFORE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mBEFORE(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = BEFORE;
++
++
++ // RSP.g:108:8: ( 'before' )
++ // RSP.g:108:10: 'before'
++ {
++ MATCHS(lit_8);
++ if (HASEXCEPTION())
++ {
++ goto ruleBEFOREEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleBEFOREEx; /* Prevent compiler warnings */
++ ruleBEFOREEx: ;
++
++}
++// $ANTLR end BEFORE
++
++// Comes from: 109:7: ( 'after' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start AFTER
++ *
++ * Looks to match the characters the constitute the token AFTER
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mAFTER(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = AFTER;
++
++
++ // RSP.g:109:7: ( 'after' )
++ // RSP.g:109:9: 'after'
++ {
++ MATCHS(lit_9);
++ if (HASEXCEPTION())
++ {
++ goto ruleAFTEREx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleAFTEREx; /* Prevent compiler warnings */
++ ruleAFTEREx: ;
++
++}
++// $ANTLR end AFTER
++
++// Comes from: 110:5: ( 'day' | 'days' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DAY
++ *
++ * Looks to match the characters the constitute the token DAY
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDAY(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = DAY;
++
++
++ {
++ // RSP.g:110:5: ( 'day' | 'days' )
++
++ ANTLR3_UINT32 alt1;
++
++ alt1=2;
++
++ switch ( LA(1) )
++ {
++ case 'd':
++ {
++ switch ( LA(2) )
++ {
++ case 'a':
++ {
++ switch ( LA(3) )
++ {
++ case 'y':
++ {
++ switch ( LA(4) )
++ {
++ case 's':
++ {
++ alt1=2;
++ }
++ break;
++
++ default:
++ alt1=1;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 2;
++
++
++ goto ruleDAYEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 1;
++
++
++ goto ruleDAYEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 1;
++ EXCEPTION->state = 0;
++
++
++ goto ruleDAYEx;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // RSP.g:110:7: 'day'
++ {
++ MATCHS(lit_10);
++ if (HASEXCEPTION())
++ {
++ goto ruleDAYEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:110:15: 'days'
++ {
++ MATCHS(lit_11);
++ if (HASEXCEPTION())
++ {
++ goto ruleDAYEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDAYEx; /* Prevent compiler warnings */
++ ruleDAYEx: ;
++
++}
++// $ANTLR end DAY
++
++// Comes from: 111:6: ( 'week' | 'weeks' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start WEEK
++ *
++ * Looks to match the characters the constitute the token WEEK
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mWEEK(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = WEEK;
++
++
++ {
++ // RSP.g:111:6: ( 'week' | 'weeks' )
++
++ ANTLR3_UINT32 alt2;
++
++ alt2=2;
++
++ switch ( LA(1) )
++ {
++ case 'w':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ switch ( LA(3) )
++ {
++ case 'e':
++ {
++ switch ( LA(4) )
++ {
++ case 'k':
++ {
++ switch ( LA(5) )
++ {
++ case 's':
++ {
++ alt2=2;
++ }
++ break;
++
++ default:
++ alt2=1;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 3;
++
++
++ goto ruleWEEKEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 2;
++
++
++ goto ruleWEEKEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 1;
++
++
++ goto ruleWEEKEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 2;
++ EXCEPTION->state = 0;
++
++
++ goto ruleWEEKEx;
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // RSP.g:111:8: 'week'
++ {
++ MATCHS(lit_12);
++ if (HASEXCEPTION())
++ {
++ goto ruleWEEKEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:111:17: 'weeks'
++ {
++ MATCHS(lit_13);
++ if (HASEXCEPTION())
++ {
++ goto ruleWEEKEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleWEEKEx; /* Prevent compiler warnings */
++ ruleWEEKEx: ;
++
++}
++// $ANTLR end WEEK
++
++// Comes from: 112:7: ( 'month' | 'months' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start MONTH
++ *
++ * Looks to match the characters the constitute the token MONTH
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mMONTH(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = MONTH;
++
++
++ {
++ // RSP.g:112:7: ( 'month' | 'months' )
++
++ ANTLR3_UINT32 alt3;
++
++ alt3=2;
++
++ switch ( LA(1) )
++ {
++ case 'm':
++ {
++ switch ( LA(2) )
++ {
++ case 'o':
++ {
++ switch ( LA(3) )
++ {
++ case 'n':
++ {
++ switch ( LA(4) )
++ {
++ case 't':
++ {
++ switch ( LA(5) )
++ {
++ case 'h':
++ {
++ switch ( LA(6) )
++ {
++ case 's':
++ {
++ alt3=2;
++ }
++ break;
++
++ default:
++ alt3=1;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 4;
++
++
++ goto ruleMONTHEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 3;
++
++
++ goto ruleMONTHEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 2;
++
++
++ goto ruleMONTHEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 1;
++
++
++ goto ruleMONTHEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 3;
++ EXCEPTION->state = 0;
++
++
++ goto ruleMONTHEx;
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // RSP.g:112:9: 'month'
++ {
++ MATCHS(lit_14);
++ if (HASEXCEPTION())
++ {
++ goto ruleMONTHEx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:112:19: 'months'
++ {
++ MATCHS(lit_15);
++ if (HASEXCEPTION())
++ {
++ goto ruleMONTHEx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleMONTHEx; /* Prevent compiler warnings */
++ ruleMONTHEx: ;
++
++}
++// $ANTLR end MONTH
++
++// Comes from: 113:6: ( 'year' | 'years' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start YEAR
++ *
++ * Looks to match the characters the constitute the token YEAR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mYEAR(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = YEAR;
++
++
++ {
++ // RSP.g:113:6: ( 'year' | 'years' )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=2;
++
++ switch ( LA(1) )
++ {
++ case 'y':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ switch ( LA(3) )
++ {
++ case 'a':
++ {
++ switch ( LA(4) )
++ {
++ case 'r':
++ {
++ switch ( LA(5) )
++ {
++ case 's':
++ {
++ alt4=2;
++ }
++ break;
++
++ default:
++ alt4=1;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 3;
++
++
++ goto ruleYEAREx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 2;
++
++
++ goto ruleYEAREx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 1;
++
++
++ goto ruleYEAREx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto ruleYEAREx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // RSP.g:113:8: 'year'
++ {
++ MATCHS(lit_16);
++ if (HASEXCEPTION())
++ {
++ goto ruleYEAREx;
++ }
++
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:113:17: 'years'
++ {
++ MATCHS(lit_17);
++ if (HASEXCEPTION())
++ {
++ goto ruleYEAREx;
++ }
++
++
++
++ }
++ break;
++
++ }
++ }
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleYEAREx; /* Prevent compiler warnings */
++ ruleYEAREx: ;
++
++}
++// $ANTLR end YEAR
++
++// Comes from: 114:7: ( 'today' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start TODAY
++ *
++ * Looks to match the characters the constitute the token TODAY
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mTODAY(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = TODAY;
++
++
++ // RSP.g:114:7: ( 'today' )
++ // RSP.g:114:9: 'today'
++ {
++ MATCHS(lit_18);
++ if (HASEXCEPTION())
++ {
++ goto ruleTODAYEx;
++ }
++
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleTODAYEx; /* Prevent compiler warnings */
++ ruleTODAYEx: ;
++
++}
++// $ANTLR end TODAY
++
++// Comes from: 116:9: ( ( '\\r' )? '\\n' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start NEWLINE
++ *
++ * Looks to match the characters the constitute the token NEWLINE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mNEWLINE(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = NEWLINE;
++
++
++ // RSP.g:116:9: ( ( '\\r' )? '\\n' )
++ // RSP.g:116:11: ( '\\r' )? '\\n'
++ {
++
++ // RSP.g:116:11: ( '\\r' )?
++ {
++ int alt5=2;
++ switch ( LA(1) )
++ {
++ case '\r':
++ {
++ alt5=1;
++ }
++ break;
++ }
++
++ switch (alt5)
++ {
++ case 1:
++ // RSP.g:116:11: '\\r'
++ {
++ MATCHC('\r');
++ if (HASEXCEPTION())
++ {
++ goto ruleNEWLINEEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++ MATCHC('\n');
++ if (HASEXCEPTION())
++ {
++ goto ruleNEWLINEEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleNEWLINEEx; /* Prevent compiler warnings */
++ ruleNEWLINEEx: ;
++
++}
++// $ANTLR end NEWLINE
++
++// Comes from: 118:4: ( ( ' ' | '\\t' ) )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start WS
++ *
++ * Looks to match the characters the constitute the token WS
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mWS(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = WS;
++
++
++ // RSP.g:118:4: ( ( ' ' | '\\t' ) )
++ // RSP.g:118:6: ( ' ' | '\\t' )
++ {
++ if ( LA(1) == '\t' || LA(1) == ' ' )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleWSEx;
++ }
++
++ {
++ LEXSTATE->channel = HIDDEN;
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleWSEx; /* Prevent compiler warnings */
++ ruleWSEx: ;
++
++}
++// $ANTLR end WS
++
++// Comes from: 120:7: ( 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start FIELD
++ *
++ * Looks to match the characters the constitute the token FIELD
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mFIELD(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = FIELD;
++
++
++ // RSP.g:120:7: ( 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z' )
++ // RSP.g:120:9: 'a' .. 'z' ( 'a' .. 'z' | '_' )* 'a' .. 'z'
++ {
++ MATCHRANGE('a', 'z');
++ if (HASEXCEPTION())
++ {
++ goto ruleFIELDEx;
++ }
++
++
++ // RSP.g:120:18: ( 'a' .. 'z' | '_' )*
++
++ for (;;)
++ {
++ int alt6=2;
++ switch ( LA(1) )
++ {
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ switch ( LA(2) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt6=1;
++ }
++ break;
++
++ }
++
++ }
++ break;
++ case '_':
++ {
++ alt6=1;
++ }
++ break;
++
++ }
++
++ switch (alt6)
++ {
++ case 1:
++ // RSP.g:
++ {
++ if ( LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleFIELDEx;
++ }
++
++
++ }
++ break;
++
++ default:
++ goto loop6; /* break out of the loop */
++ break;
++ }
++ }
++ loop6: ; /* Jump out to here if this rule does not match */
++
++ MATCHRANGE('a', 'z');
++ if (HASEXCEPTION())
++ {
++ goto ruleFIELDEx;
++ }
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleFIELDEx; /* Prevent compiler warnings */
++ ruleFIELDEx: ;
++
++}
++// $ANTLR end FIELD
++
++// Comes from: 122:5: ( DIGIT19 ( DIGIT09 )* )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start INT
++ *
++ * Looks to match the characters the constitute the token INT
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mINT(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = INT;
++
++
++ // RSP.g:122:5: ( DIGIT19 ( DIGIT09 )* )
++ // RSP.g:122:7: DIGIT19 ( DIGIT09 )*
++ {
++ /* 122:7: DIGIT19 ( DIGIT09 )* */
++ mDIGIT19(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTEx;
++ }
++
++
++ // RSP.g:122:15: ( DIGIT09 )*
++
++ for (;;)
++ {
++ int alt7=2;
++ switch ( LA(1) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ alt7=1;
++ }
++ break;
++
++ }
++
++ switch (alt7)
++ {
++ case 1:
++ // RSP.g:122:15: DIGIT09
++ {
++ /* 122:15: DIGIT09 */
++ mDIGIT09(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleINTEx;
++ }
++
++
++ }
++ break;
++
++ default:
++ goto loop7; /* break out of the loop */
++ break;
++ }
++ }
++ loop7: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleINTEx; /* Prevent compiler warnings */
++ ruleINTEx: ;
++
++}
++// $ANTLR end INT
++
++// Comes from: 125:6: ( DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DATE
++ *
++ * Looks to match the characters the constitute the token DATE
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDATE(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++ _type = DATE;
++
++
++ // RSP.g:125:6: ( DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) )
++ // RSP.g:125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' )
++ {
++ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
++ mDIGIT19(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
++ mDIGIT09(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
++ mDIGIT09(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ /* 125:8: DIGIT19 DIGIT09 DIGIT09 DIGIT09 '-' ( '0' DIGIT19 | '1' '0' .. '2' ) '-' ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' ) */
++ mDIGIT09(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ MATCHC('-');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ // RSP.g:125:44: ( '0' DIGIT19 | '1' '0' .. '2' )
++ {
++ int alt8=2;
++ switch ( LA(1) )
++ {
++ case '0':
++ {
++ alt8=1;
++ }
++ break;
++ case '1':
++ {
++ alt8=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 8;
++ EXCEPTION->state = 0;
++
++
++ goto ruleDATEEx;
++ }
++
++ switch (alt8)
++ {
++ case 1:
++ // RSP.g:125:45: '0' DIGIT19
++ {
++ MATCHC('0');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ /* 125:45: '0' DIGIT19 */
++ mDIGIT19(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:125:59: '1' '0' .. '2'
++ {
++ MATCHC('1');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ MATCHRANGE('0', '2');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++ MATCHC('-');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ // RSP.g:125:77: ( '0' DIGIT19 | '1' .. '2' DIGIT09 | '3' '0' .. '1' )
++ {
++ int alt9=3;
++ switch ( LA(1) )
++ {
++ case '0':
++ {
++ alt9=1;
++ }
++ break;
++ case '1':
++ case '2':
++ {
++ alt9=2;
++ }
++ break;
++ case '3':
++ {
++ alt9=3;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 9;
++ EXCEPTION->state = 0;
++
++
++ goto ruleDATEEx;
++ }
++
++ switch (alt9)
++ {
++ case 1:
++ // RSP.g:125:78: '0' DIGIT19
++ {
++ MATCHC('0');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ /* 125:78: '0' DIGIT19 */
++ mDIGIT19(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:125:92: '1' .. '2' DIGIT09
++ {
++ MATCHRANGE('1', '2');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ /* 125:92: '1' .. '2' DIGIT09 */
++ mDIGIT09(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++ break;
++ case 3:
++ // RSP.g:125:111: '3' '0' .. '1'
++ {
++ MATCHC('3');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++ MATCHRANGE('0', '1');
++ if (HASEXCEPTION())
++ {
++ goto ruleDATEEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDATEEx; /* Prevent compiler warnings */
++ ruleDATEEx: ;
++
++}
++// $ANTLR end DATE
++
++// Comes from: 133:2: ( QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start STR
++ *
++ * Looks to match the characters the constitute the token STR
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mSTR(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++ pANTLR3_COMMON_TOKEN esc;
++ ANTLR3_UINT32 reg;
++
++
++ esc = NULL;
++
++ _type = STR;
++
++ pANTLR3_STRING unesc = GETTEXT()->factory->newRaw(GETTEXT()->factory);
++
++ // RSP.g:133:2: ( QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE )
++ // RSP.g:133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE
++ {
++ /* 133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE */
++ mQUOTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ // RSP.g:133:10: (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+
++ {
++ int cnt10=0;
++
++ for (;;)
++ {
++ int alt10=3;
++ {
++ /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
++ */
++ int LA10_0 = LA(1);
++ if ( (((LA10_0 >= 0x0000) && (LA10_0 <= '!')) || ((LA10_0 >= '#') && (LA10_0 <= '[')) || ((LA10_0 >= ']') && (LA10_0 <= 0xFFFF))) )
++ {
++ alt10=1;
++ }
++ else if ( (LA10_0 == '\\') )
++ {
++ alt10=2;
++ }
++
++ }
++ switch (alt10)
++ {
++ case 1:
++ // RSP.g:133:12: reg=~ ( '\\\\' | '\"' )
++ {
++ reg= LA(1);
++ if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) )
++ {
++ CONSUME();
++
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++
++ LRECOVER(); goto ruleSTREx;
++ }
++
++ {
++ unesc->addc(unesc, reg);
++ }
++
++ }
++ break;
++ case 2:
++ // RSP.g:134:6: esc= ESCAPED
++ {
++ /* 134:6: esc= ESCAPED */
++ {
++ ANTLR3_MARKER escStart381 = GETCHARINDEX();
++ mESCAPED(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ esc = LEXSTATE->tokFactory->newToken(LEXSTATE->tokFactory);
++ esc->setType(esc, ANTLR3_TOKEN_INVALID);
++ esc->setStartIndex(esc, escStart381);
++ esc->setStopIndex(esc, GETCHARINDEX()-1);
++ esc->input = INPUT;
++ }
++ {
++ unesc->appendS(unesc, GETTEXT());
++ }
++
++ }
++ break;
++
++ default:
++
++ if ( cnt10 >= 1 )
++ {
++ goto loop10;
++ }
++ /* mismatchedSetEx()
++ */
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
++
++
++ goto ruleSTREx;
++ }
++ cnt10++;
++ }
++ loop10: ; /* Jump to here if this rule does not match */
++ }
++ /* 133:4: QUOTE (reg=~ ( '\\\\' | '\"' ) | esc= ESCAPED )+ QUOTE */
++ mQUOTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleSTREx;
++ }
++
++ {
++ SETTEXT(unesc);
++ }
++
++ }
++
++ LEXSTATE->type = _type;
++
++ // This is where rules clean up and exit
++ //
++ goto ruleSTREx; /* Prevent compiler warnings */
++ ruleSTREx: ;
++
++ esc = NULL;
++
++}
++// $ANTLR end STR
++
++// Comes from: 138:9: ( '\\\\' ( '\\\\' | '\"' ) )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start ESCAPED
++ *
++ * Looks to match the characters the constitute the token ESCAPED
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mESCAPED(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // RSP.g:138:9: ( '\\\\' ( '\\\\' | '\"' ) )
++ // RSP.g:138:11: '\\\\' ( '\\\\' | '\"' )
++ {
++ MATCHC('\\');
++ if (HASEXCEPTION())
++ {
++ goto ruleESCAPEDEx;
++ }
++
++
++ // RSP.g:139:3: ( '\\\\' | '\"' )
++ {
++ int alt11=2;
++ switch ( LA(1) )
++ {
++ case '\\':
++ {
++ alt11=1;
++ }
++ break;
++ case '"':
++ {
++ alt11=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 11;
++ EXCEPTION->state = 0;
++
++
++ goto ruleESCAPEDEx;
++ }
++
++ switch (alt11)
++ {
++ case 1:
++ // RSP.g:139:5: '\\\\'
++ {
++ MATCHC('\\');
++ if (HASEXCEPTION())
++ {
++ goto ruleESCAPEDEx;
++ }
++
++ {
++ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\\"));
++ }
++
++ }
++ break;
++ case 2:
++ // RSP.g:140:5: '\"'
++ {
++ MATCHC('"');
++ if (HASEXCEPTION())
++ {
++ goto ruleESCAPEDEx;
++ }
++
++ {
++ SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\""));
++ }
++
++ }
++ break;
++
++ }
++ }
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleESCAPEDEx; /* Prevent compiler warnings */
++ ruleESCAPEDEx: ;
++
++}
++// $ANTLR end ESCAPED
++
++// Comes from: 145:9: ( '0' .. '9' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DIGIT09
++ *
++ * Looks to match the characters the constitute the token DIGIT09
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDIGIT09(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // RSP.g:145:9: ( '0' .. '9' )
++ // RSP.g:145:11: '0' .. '9'
++ {
++ MATCHRANGE('0', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDIGIT09Ex;
++ }
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDIGIT09Ex; /* Prevent compiler warnings */
++ ruleDIGIT09Ex: ;
++
++}
++// $ANTLR end DIGIT09
++
++// Comes from: 148:9: ( '1' .. '9' )
++/** \brief Lexer rule generated by ANTLR3
++ *
++ * $ANTLR start DIGIT19
++ *
++ * Looks to match the characters the constitute the token DIGIT19
++ * from the attached input stream.
++ *
++ *
++ * \remark
++ * - lexer->error == ANTLR3_TRUE if an exception was thrown.
++ */
++static ANTLR3_INLINE
++void mDIGIT19(pRSPLexer ctx)
++{
++ ANTLR3_UINT32 _type;
++
++
++ // RSP.g:148:9: ( '1' .. '9' )
++ // RSP.g:148:11: '1' .. '9'
++ {
++ MATCHRANGE('1', '9');
++ if (HASEXCEPTION())
++ {
++ goto ruleDIGIT19Ex;
++ }
++
++
++ }
++
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleDIGIT19Ex; /* Prevent compiler warnings */
++ ruleDIGIT19Ex: ;
++
++}
++// $ANTLR end DIGIT19
++
++/** This is the entry point in to the lexer from an object that
++ * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
++ */
++static void
++mTokens(pRSPLexer ctx)
++{
++ {
++ // RSP.g:1:8: ( QUOTE | LPAR | RPAR | AND | OR | NOT | EQUAL | INCLUDES | STARTSW | ENDSW | GREATER | LESS | GTE | LTE | BEFORE | AFTER | DAY | WEEK | MONTH | YEAR | TODAY | NEWLINE | WS | FIELD | INT | DATE | STR )
++
++ ANTLR3_UINT32 alt12;
++
++ alt12=27;
++
++ switch ( LA(1) )
++ {
++ case '"':
++ {
++
++ {
++ int LA12_1 = LA(2);
++ if ( (((LA12_1 >= 0x0000) && (LA12_1 <= '!')) || ((LA12_1 >= '#') && (LA12_1 <= 0xFFFF))) )
++ {
++ alt12=27;
++ }
++ else
++ {
++ alt12=1; }
++ }
++ }
++ break;
++ case '(':
++ {
++ alt12=2;
++ }
++ break;
++ case ')':
++ {
++ alt12=3;
++ }
++ break;
++ case 'a':
++ {
++ switch ( LA(2) )
++ {
++ case 'n':
++ {
++ switch ( LA(3) )
++ {
++ case 'd':
++ {
++ switch ( LA(4) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=4;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case 'f':
++ {
++ switch ( LA(3) )
++ {
++ case 't':
++ {
++ switch ( LA(4) )
++ {
++ case 'e':
++ {
++ switch ( LA(5) )
++ {
++ case 'r':
++ {
++ switch ( LA(6) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=16;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 4;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'o':
++ {
++ switch ( LA(2) )
++ {
++ case 'r':
++ {
++ switch ( LA(3) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=5;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 5;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case '!':
++ {
++ alt12=6;
++ }
++ break;
++ case '=':
++ {
++ alt12=7;
++ }
++ break;
++ case 'i':
++ {
++ switch ( LA(2) )
++ {
++ case 'n':
++ {
++ switch ( LA(3) )
++ {
++ case 'c':
++ {
++ switch ( LA(4) )
++ {
++ case 'l':
++ {
++ switch ( LA(5) )
++ {
++ case 'u':
++ {
++ switch ( LA(6) )
++ {
++ case 'd':
++ {
++ switch ( LA(7) )
++ {
++ case 'e':
++ {
++ switch ( LA(8) )
++ {
++ case 's':
++ {
++ switch ( LA(9) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=8;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 8;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 's':
++ {
++ switch ( LA(2) )
++ {
++ case 't':
++ {
++ switch ( LA(3) )
++ {
++ case 'a':
++ {
++ switch ( LA(4) )
++ {
++ case 'r':
++ {
++ switch ( LA(5) )
++ {
++ case 't':
++ {
++ switch ( LA(6) )
++ {
++ case 's':
++ {
++ switch ( LA(7) )
++ {
++ case 'w':
++ {
++ switch ( LA(8) )
++ {
++ case 'i':
++ {
++ switch ( LA(9) )
++ {
++ case 't':
++ {
++ switch ( LA(10) )
++ {
++ case 'h':
++ {
++ switch ( LA(11) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=9;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 9;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'e':
++ {
++ switch ( LA(2) )
++ {
++ case 'n':
++ {
++ switch ( LA(3) )
++ {
++ case 'd':
++ {
++ switch ( LA(4) )
++ {
++ case 's':
++ {
++ switch ( LA(5) )
++ {
++ case 'w':
++ {
++ switch ( LA(6) )
++ {
++ case 'i':
++ {
++ switch ( LA(7) )
++ {
++ case 't':
++ {
++ switch ( LA(8) )
++ {
++ case 'h':
++ {
++ switch ( LA(9) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=10;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 10;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case '>':
++ {
++ switch ( LA(2) )
++ {
++ case '=':
++ {
++ alt12=13;
++ }
++ break;
++
++ default:
++ alt12=11;}
++
++ }
++ break;
++ case '<':
++ {
++ switch ( LA(2) )
++ {
++ case '=':
++ {
++ alt12=14;
++ }
++ break;
++
++ default:
++ alt12=12;}
++
++ }
++ break;
++ case 'b':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ switch ( LA(3) )
++ {
++ case 'f':
++ {
++ switch ( LA(4) )
++ {
++ case 'o':
++ {
++ switch ( LA(5) )
++ {
++ case 'r':
++ {
++ switch ( LA(6) )
++ {
++ case 'e':
++ {
++ switch ( LA(7) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=15;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 13;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'd':
++ {
++ switch ( LA(2) )
++ {
++ case 'a':
++ {
++ switch ( LA(3) )
++ {
++ case 'y':
++ {
++ switch ( LA(4) )
++ {
++ case 's':
++ {
++ switch ( LA(5) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=17;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=17;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 14;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'w':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ switch ( LA(3) )
++ {
++ case 'e':
++ {
++ switch ( LA(4) )
++ {
++ case 'k':
++ {
++ switch ( LA(5) )
++ {
++ case 's':
++ {
++ switch ( LA(6) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=18;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=18;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 15;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'm':
++ {
++ switch ( LA(2) )
++ {
++ case 'o':
++ {
++ switch ( LA(3) )
++ {
++ case 'n':
++ {
++ switch ( LA(4) )
++ {
++ case 't':
++ {
++ switch ( LA(5) )
++ {
++ case 'h':
++ {
++ switch ( LA(6) )
++ {
++ case 's':
++ {
++ switch ( LA(7) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=19;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=19;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 16;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 'y':
++ {
++ switch ( LA(2) )
++ {
++ case 'e':
++ {
++ switch ( LA(3) )
++ {
++ case 'a':
++ {
++ switch ( LA(4) )
++ {
++ case 'r':
++ {
++ switch ( LA(5) )
++ {
++ case 's':
++ {
++ switch ( LA(6) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=20;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=20;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 17;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case 't':
++ {
++ switch ( LA(2) )
++ {
++ case 'o':
++ {
++ switch ( LA(3) )
++ {
++ case 'd':
++ {
++ switch ( LA(4) )
++ {
++ case 'a':
++ {
++ switch ( LA(5) )
++ {
++ case 'y':
++ {
++ switch ( LA(6) )
++ {
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'o':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ alt12=21;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++
++ default:
++ alt12=24;}
++
++ }
++ break;
++ case '_':
++ case 'a':
++ case 'b':
++ case 'c':
++ case 'd':
++ case 'e':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'i':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'm':
++ case 'n':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 's':
++ case 't':
++ case 'u':
++ case 'v':
++ case 'w':
++ case 'x':
++ case 'y':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 18;
++
++
++ goto ruleTokensEx;
++ }
++
++ }
++ break;
++ case '\n':
++ case '\r':
++ {
++ alt12=22;
++ }
++ break;
++ case '\t':
++ case ' ':
++ {
++ alt12=23;
++ }
++ break;
++ case 'c':
++ case 'f':
++ case 'g':
++ case 'h':
++ case 'j':
++ case 'k':
++ case 'l':
++ case 'n':
++ case 'p':
++ case 'q':
++ case 'r':
++ case 'u':
++ case 'v':
++ case 'x':
++ case 'z':
++ {
++ alt12=24;
++ }
++ break;
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(2) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(3) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(4) )
++ {
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ {
++ switch ( LA(5) )
++ {
++ case '-':
++ {
++ alt12=26;
++ }
++ break;
++
++ default:
++ alt12=25;}
++
++ }
++ break;
++
++ default:
++ alt12=25;}
++
++ }
++ break;
++
++ default:
++ alt12=25;}
++
++ }
++ break;
++
++ default:
++ alt12=25;}
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 12;
++ EXCEPTION->state = 0;
++
++
++ goto ruleTokensEx;
++ }
++
++ switch (alt12)
++ {
++ case 1:
++ // RSP.g:1:10: QUOTE
++ {
++ /* 1:10: QUOTE */
++ mQUOTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 2:
++ // RSP.g:1:16: LPAR
++ {
++ /* 1:16: LPAR */
++ mLPAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 3:
++ // RSP.g:1:21: RPAR
++ {
++ /* 1:21: RPAR */
++ mRPAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 4:
++ // RSP.g:1:26: AND
++ {
++ /* 1:26: AND */
++ mAND(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 5:
++ // RSP.g:1:30: OR
++ {
++ /* 1:30: OR */
++ mOR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 6:
++ // RSP.g:1:33: NOT
++ {
++ /* 1:33: NOT */
++ mNOT(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 7:
++ // RSP.g:1:37: EQUAL
++ {
++ /* 1:37: EQUAL */
++ mEQUAL(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 8:
++ // RSP.g:1:43: INCLUDES
++ {
++ /* 1:43: INCLUDES */
++ mINCLUDES(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 9:
++ // RSP.g:1:52: STARTSW
++ {
++ /* 1:52: STARTSW */
++ mSTARTSW(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 10:
++ // RSP.g:1:60: ENDSW
++ {
++ /* 1:60: ENDSW */
++ mENDSW(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 11:
++ // RSP.g:1:66: GREATER
++ {
++ /* 1:66: GREATER */
++ mGREATER(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 12:
++ // RSP.g:1:74: LESS
++ {
++ /* 1:74: LESS */
++ mLESS(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 13:
++ // RSP.g:1:79: GTE
++ {
++ /* 1:79: GTE */
++ mGTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 14:
++ // RSP.g:1:83: LTE
++ {
++ /* 1:83: LTE */
++ mLTE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 15:
++ // RSP.g:1:87: BEFORE
++ {
++ /* 1:87: BEFORE */
++ mBEFORE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 16:
++ // RSP.g:1:94: AFTER
++ {
++ /* 1:94: AFTER */
++ mAFTER(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 17:
++ // RSP.g:1:100: DAY
++ {
++ /* 1:100: DAY */
++ mDAY(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 18:
++ // RSP.g:1:104: WEEK
++ {
++ /* 1:104: WEEK */
++ mWEEK(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 19:
++ // RSP.g:1:109: MONTH
++ {
++ /* 1:109: MONTH */
++ mMONTH(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 20:
++ // RSP.g:1:115: YEAR
++ {
++ /* 1:115: YEAR */
++ mYEAR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 21:
++ // RSP.g:1:120: TODAY
++ {
++ /* 1:120: TODAY */
++ mTODAY(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 22:
++ // RSP.g:1:126: NEWLINE
++ {
++ /* 1:126: NEWLINE */
++ mNEWLINE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 23:
++ // RSP.g:1:134: WS
++ {
++ /* 1:134: WS */
++ mWS(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 24:
++ // RSP.g:1:137: FIELD
++ {
++ /* 1:137: FIELD */
++ mFIELD(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 25:
++ // RSP.g:1:143: INT
++ {
++ /* 1:143: INT */
++ mINT(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 26:
++ // RSP.g:1:147: DATE
++ {
++ /* 1:147: DATE */
++ mDATE(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++ case 27:
++ // RSP.g:1:152: STR
++ {
++ /* 1:152: STR */
++ mSTR(ctx );
++ if (HASEXCEPTION())
++ {
++ goto ruleTokensEx;
++ }
++
++
++ }
++ break;
++
++ }
++ }
++
++
++ goto ruleTokensEx; /* Prevent compiler warnings */
++ruleTokensEx: ;
++}
++
++/* =========================================================================
++ * Lexer matching rules end.
++ * =========================================================================
++ */
++/* End of Lexer code
++ * ================================================
++ * ================================================
++ */
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/RSPLexer.h b/src/pregen/RSPLexer.h
+new file mode 100644
+index 0000000..4f4d06b
+--- /dev/null
++++ b/src/pregen/RSPLexer.h
+@@ -0,0 +1,254 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : RSP.g
++ * - On : 2014-09-30 21:42:41
++ * - for the lexer : RSPLexerLexer *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The lexer RSPLexer has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pRSPLexer, which is returned from a call to RSPLexerNew().
++ *
++ * As this is a generated lexer, it is unlikely you will call it 'manually'. However
++ * the methods are provided anyway.
++ * * The methods in pRSPLexer are as follows:
++ *
++ * - void pRSPLexer->QUOTE(pRSPLexer)
++ * - void pRSPLexer->LPAR(pRSPLexer)
++ * - void pRSPLexer->RPAR(pRSPLexer)
++ * - void pRSPLexer->AND(pRSPLexer)
++ * - void pRSPLexer->OR(pRSPLexer)
++ * - void pRSPLexer->NOT(pRSPLexer)
++ * - void pRSPLexer->EQUAL(pRSPLexer)
++ * - void pRSPLexer->INCLUDES(pRSPLexer)
++ * - void pRSPLexer->STARTSW(pRSPLexer)
++ * - void pRSPLexer->ENDSW(pRSPLexer)
++ * - void pRSPLexer->GREATER(pRSPLexer)
++ * - void pRSPLexer->LESS(pRSPLexer)
++ * - void pRSPLexer->GTE(pRSPLexer)
++ * - void pRSPLexer->LTE(pRSPLexer)
++ * - void pRSPLexer->BEFORE(pRSPLexer)
++ * - void pRSPLexer->AFTER(pRSPLexer)
++ * - void pRSPLexer->DAY(pRSPLexer)
++ * - void pRSPLexer->WEEK(pRSPLexer)
++ * - void pRSPLexer->MONTH(pRSPLexer)
++ * - void pRSPLexer->YEAR(pRSPLexer)
++ * - void pRSPLexer->TODAY(pRSPLexer)
++ * - void pRSPLexer->NEWLINE(pRSPLexer)
++ * - void pRSPLexer->WS(pRSPLexer)
++ * - void pRSPLexer->FIELD(pRSPLexer)
++ * - void pRSPLexer->INT(pRSPLexer)
++ * - void pRSPLexer->DATE(pRSPLexer)
++ * - void pRSPLexer->STR(pRSPLexer)
++ * - void pRSPLexer->ESCAPED(pRSPLexer)
++ * - void pRSPLexer->DIGIT09(pRSPLexer)
++ * - void pRSPLexer->DIGIT19(pRSPLexer)
++ * - void pRSPLexer->Tokens(pRSPLexer)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _RSPLexer_H
++#define _RSPLexer_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct RSPLexer_Ctx_struct RSPLexer, * pRSPLexer;
++
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++
++/** Context tracking structure for RSPLexer
++ */
++struct RSPLexer_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_LEXER pLexer;
++
++
++ void (*mQUOTE) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mLPAR) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mRPAR) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mAND) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mOR) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mNOT) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mEQUAL) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mINCLUDES) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mSTARTSW) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mENDSW) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mGREATER) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mLESS) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mGTE) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mLTE) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mBEFORE) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mAFTER) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mDAY) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mWEEK) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mMONTH) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mYEAR) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mTODAY) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mNEWLINE) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mWS) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mFIELD) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mINT) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mDATE) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mSTR) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mESCAPED) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mDIGIT09) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mDIGIT19) (struct RSPLexer_Ctx_struct * ctx);
++ void (*mTokens) (struct RSPLexer_Ctx_struct * ctx); const char * (*getGrammarFileName)();
++ void (*free) (struct RSPLexer_Ctx_struct * ctx);
++
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pRSPLexer RSPLexerNew (pANTLR3_INPUT_STREAM instream);
++ANTLR3_API pRSPLexer RSPLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the lexer will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define STARTSW 14
++#define WEEK 26
++#define TODAY 24
++#define YEAR 28
++#define ENDSW 15
++#define GTE 20
++#define BEFORE 21
++#define DAY 25
++#define INT 16
++#define NOT 11
++#define AFTER 22
++#define AND 6
++#define EOF -1
++#define LTE 19
++#define MONTH 27
++#define DIGIT19 31
++#define INCLUDES 13
++#define STR 10
++#define QUOTE 29
++#define GREATER 18
++#define WS 30
++#define LPAR 7
++#define NEWLINE 4
++#define EQUAL 12
++#define OR 5
++#define LESS 17
++#define FIELD 9
++#define RPAR 8
++#define ESCAPED 33
++#define DATE 23
++#define DIGIT09 32
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for RSPLexer
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */
+diff --git a/src/pregen/RSPParser.c b/src/pregen/RSPParser.c
+new file mode 100644
+index 0000000..c538e49
+--- /dev/null
++++ b/src/pregen/RSPParser.c
+@@ -0,0 +1,2684 @@
++/** \file
++ * This C source file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : RSP.g
++ * - On : 2014-09-30 21:42:40
++ * - for the parser : RSPParserParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++*/
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++/* -----------------------------------------
++ * Include the ANTLR3 generated header file.
++ */
++#include "RSPParser.h"
++/* ----------------------------------------- */
++
++
++
++
++
++/* MACROS that hide the C interface implementations from the
++ * generated code, which makes it a little more understandable to the human eye.
++ * I am very much against using C pre-processor macros for function calls and bits
++ * of code as you cannot see what is happening when single stepping in debuggers
++ * and so on. The exception (in my book at least) is for generated code, where you are
++ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
++ * hides some indirect calls, but is always referring to the input stream. This is
++ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
++ * the runtime interfaces without changing the generated code too often, without
++ * confusing the reader of the generated output, who may not wish to know the gory
++ * details of the interface inheritance.
++ */
++
++#define CTX ctx
++
++/* Aids in accessing scopes for grammar programmers
++ */
++#undef SCOPE_TYPE
++#undef SCOPE_STACK
++#undef SCOPE_TOP
++#define SCOPE_TYPE(scope) pRSPParser_##scope##_SCOPE
++#define SCOPE_STACK(scope) pRSPParser_##scope##Stack
++#define SCOPE_TOP(scope) ctx->pRSPParser_##scope##Top
++#define SCOPE_SIZE(scope) ctx->pRSPParser_##scope##Stack_limit
++#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
++
++/* Macros for accessing things in the parser
++ */
++
++#undef PARSER
++#undef RECOGNIZER
++#undef HAVEPARSEDRULE
++#undef MEMOIZE
++#undef INPUT
++#undef STRSTREAM
++#undef HASEXCEPTION
++#undef EXCEPTION
++#undef MATCHT
++#undef MATCHANYT
++#undef FOLLOWSTACK
++#undef FOLLOWPUSH
++#undef FOLLOWPOP
++#undef PRECOVER
++#undef PREPORTERROR
++#undef LA
++#undef LT
++#undef CONSTRUCTEX
++#undef CONSUME
++#undef MARK
++#undef REWIND
++#undef REWINDLAST
++#undef PERRORRECOVERY
++#undef HASFAILED
++#undef FAILEDFLAG
++#undef RECOVERFROMMISMATCHEDSET
++#undef RECOVERFROMMISMATCHEDELEMENT
++#undef INDEX
++#undef ADAPTOR
++#undef SEEK
++#undef RULEMEMO
++#undef DBG
++
++#define PARSER ctx->pParser
++#define RECOGNIZER PARSER->rec
++#define PSRSTATE RECOGNIZER->state
++#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
++#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
++#define INPUT PARSER->tstream
++#define STRSTREAM INPUT
++#define ISTREAM INPUT->istream
++#define INDEX() ISTREAM->index(INPUT->istream)
++#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
++#define EXCEPTION PSRSTATE->exception
++#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
++#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
++#define FOLLOWSTACK PSRSTATE->following
++#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
++#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
++#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
++#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
++#define LA(n) INPUT->istream->_LA(ISTREAM, n)
++#define LT(n) INPUT->_LT(INPUT, n)
++#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
++#define CONSUME() ISTREAM->consume(ISTREAM)
++#define MARK() ISTREAM->mark(ISTREAM)
++#define REWIND(m) ISTREAM->rewind(ISTREAM, m)
++#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
++#define SEEK(n) ISTREAM->seek(ISTREAM, n)
++#define PERRORRECOVERY PSRSTATE->errorRecovery
++#define FAILEDFLAG PSRSTATE->failed
++#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
++#define BACKTRACKING PSRSTATE->backtracking
++#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
++#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
++#define ADAPTOR ctx->adaptor
++#define RULEMEMO PSRSTATE->ruleMemo
++#define DBG RECOGNIZER->debugger
++
++#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
++
++/* The 4 tokens defined below may well clash with your own #defines or token types. If so
++ * then for the present you must use different names for your defines as these are hard coded
++ * in the code generator. It would be better not to use such names internally, and maybe
++ * we can change this in a forthcoming release. I deliberately do not #undef these
++ * here as this will at least give you a redefined error somewhere if they clash.
++ */
++#define UP ANTLR3_TOKEN_UP
++#define DOWN ANTLR3_TOKEN_DOWN
++#define EOR ANTLR3_TOKEN_EOR
++#define INVALID ANTLR3_TOKEN_INVALID
++
++
++/* =============================================================================
++ * Functions to create and destroy scopes. First come the rule scopes, followed
++ * by the global declared scopes.
++ */
++
++
++
++/* ============================================================================= */
++
++/* =============================================================================
++ * Start of recognizer
++ */
++
++
++
++/** \brief Table of all token names in symbolic order, mainly used for
++ * error reporting.
++ */
++pANTLR3_UINT8 RSPParserTokenNames[30+4]
++ = {
++ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
++ (pANTLR3_UINT8) "<EOR>",
++ (pANTLR3_UINT8) "<DOWN>",
++ (pANTLR3_UINT8) "<UP>",
++ (pANTLR3_UINT8) "NEWLINE",
++ (pANTLR3_UINT8) "OR",
++ (pANTLR3_UINT8) "AND",
++ (pANTLR3_UINT8) "LPAR",
++ (pANTLR3_UINT8) "RPAR",
++ (pANTLR3_UINT8) "FIELD",
++ (pANTLR3_UINT8) "STR",
++ (pANTLR3_UINT8) "NOT",
++ (pANTLR3_UINT8) "EQUAL",
++ (pANTLR3_UINT8) "INCLUDES",
++ (pANTLR3_UINT8) "STARTSW",
++ (pANTLR3_UINT8) "ENDSW",
++ (pANTLR3_UINT8) "INT",
++ (pANTLR3_UINT8) "LESS",
++ (pANTLR3_UINT8) "GREATER",
++ (pANTLR3_UINT8) "LTE",
++ (pANTLR3_UINT8) "GTE",
++ (pANTLR3_UINT8) "BEFORE",
++ (pANTLR3_UINT8) "AFTER",
++ (pANTLR3_UINT8) "DATE",
++ (pANTLR3_UINT8) "TODAY",
++ (pANTLR3_UINT8) "DAY",
++ (pANTLR3_UINT8) "WEEK",
++ (pANTLR3_UINT8) "MONTH",
++ (pANTLR3_UINT8) "YEAR",
++ (pANTLR3_UINT8) "QUOTE",
++ (pANTLR3_UINT8) "WS",
++ (pANTLR3_UINT8) "DIGIT19",
++ (pANTLR3_UINT8) "DIGIT09",
++ (pANTLR3_UINT8) "ESCAPED"
++ };
++
++
++
++// Forward declare the locally static matching functions we have generated.
++//
++static RSPParser_query_return query (pRSPParser ctx);
++static RSPParser_expr_return expr (pRSPParser ctx);
++static RSPParser_aexpr_return aexpr (pRSPParser ctx);
++static RSPParser_crit_return crit (pRSPParser ctx);
++static RSPParser_strcrit_return strcrit (pRSPParser ctx);
++static RSPParser_strop_return strop (pRSPParser ctx);
++static RSPParser_intcrit_return intcrit (pRSPParser ctx);
++static RSPParser_intop_return intop (pRSPParser ctx);
++static RSPParser_datecrit_return datecrit (pRSPParser ctx);
++static RSPParser_dateop_return dateop (pRSPParser ctx);
++static RSPParser_datespec_return datespec (pRSPParser ctx);
++static RSPParser_dateref_return dateref (pRSPParser ctx);
++static RSPParser_dateintval_return dateintval (pRSPParser ctx);
++static void RSPParserFree(pRSPParser ctx);
++/* For use in tree output where we are accumulating rule labels via label += ruleRef
++ * we need a function that knows how to free a return scope when the list is destroyed.
++ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
++ */
++static void ANTLR3_CDECL freeScope(void * scope)
++{
++ ANTLR3_FREE(scope);
++}
++
++/** \brief Name of the grammar file that generated this code
++ */
++static const char fileName[] = "RSP.g";
++
++/** \brief Return the name of the grammar file that generated this code.
++ */
++static const char * getGrammarFileName()
++{
++ return fileName;
++}
++/** \brief Create a new RSPParser parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pRSPParser
++RSPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
++{
++ // See if we can create a new parser with the standard constructor
++ //
++ return RSPParserNewSSD(instream, NULL);
++}
++
++/** \brief Create a new RSPParser parser and return a context for it.
++ *
++ * \param[in] instream Pointer to an input stream interface.
++ *
++ * \return Pointer to new parser context upon success.
++ */
++ANTLR3_API pRSPParser
++RSPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
++{
++ pRSPParser ctx; /* Context structure we will build and return */
++
++ ctx = (pRSPParser) ANTLR3_CALLOC(1, sizeof(RSPParser));
++
++ if (ctx == NULL)
++ {
++ // Failed to allocate memory for parser context
++ //
++ return NULL;
++ }
++
++ /* -------------------------------------------------------------------
++ * Memory for basic structure is allocated, now to fill in
++ * the base ANTLR3 structures. We initialize the function pointers
++ * for the standard ANTLR3 parser function set, but upon return
++ * from here, the programmer may set the pointers to provide custom
++ * implementations of each function.
++ *
++ * We don't use the macros defined in RSPParser.h here, in order that you can get a sense
++ * of what goes where.
++ */
++
++ /* Create a base parser/recognizer, using the supplied token stream
++ */
++ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
++ /* Install the implementation of our RSPParser interface
++ */
++ ctx->query = query;
++ ctx->expr = expr;
++ ctx->aexpr = aexpr;
++ ctx->crit = crit;
++ ctx->strcrit = strcrit;
++ ctx->strop = strop;
++ ctx->intcrit = intcrit;
++ ctx->intop = intop;
++ ctx->datecrit = datecrit;
++ ctx->dateop = dateop;
++ ctx->datespec = datespec;
++ ctx->dateref = dateref;
++ ctx->dateintval = dateintval;
++ ctx->free = RSPParserFree;
++ ctx->getGrammarFileName = getGrammarFileName;
++
++ /* Install the scope pushing methods.
++ */
++ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
++ ctx->vectors = antlr3VectorFactoryNew(0);
++
++
++
++ /* Install the token table
++ */
++ PSRSTATE->tokenNames = RSPParserTokenNames;
++
++
++ /* Return the newly built parser to the caller
++ */
++ return ctx;
++}
++
++/** Free the parser resources
++ */
++ static void
++ RSPParserFree(pRSPParser ctx)
++ {
++ /* Free any scope memory
++ */
++
++ ctx->vectors->close(ctx->vectors);
++ /* We created the adaptor so we must free it
++ */
++ ADAPTOR->free(ADAPTOR);
++ // Free this parser
++ //
++ ctx->pParser->free(ctx->pParser);
++ ANTLR3_FREE(ctx);
++
++ /* Everything is released, so we can return
++ */
++ return;
++ }
++
++/** Return token names used by this parser
++ *
++ * The returned pointer is used as an index into the token names table (using the token
++ * number as the index).
++ *
++ * \return Pointer to first char * in the table.
++ */
++static pANTLR3_UINT8 *getTokenNames()
++{
++ return RSPParserTokenNames;
++}
++
++
++/* Declare the bitsets
++ */
++
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_query42 */
++static ANTLR3_BITWORD FOLLOW_expr_in_query42_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000010) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_query42 = { FOLLOW_expr_in_query42_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_query44 */
++static ANTLR3_BITWORD FOLLOW_NEWLINE_in_query44_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000000) };
++static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_query44 = { FOLLOW_NEWLINE_in_query44_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_query47 */
++static ANTLR3_BITWORD FOLLOW_EOF_in_query47_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_EOF_in_query47 = { FOLLOW_EOF_in_query47_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr63 */
++static ANTLR3_BITWORD FOLLOW_aexpr_in_expr63_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
++static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr63 = { FOLLOW_aexpr_in_expr63_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_expr66 */
++static ANTLR3_BITWORD FOLLOW_OR_in_expr66_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
++static ANTLR3_BITSET_LIST FOLLOW_OR_in_expr66 = { FOLLOW_OR_in_expr66_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_aexpr_in_expr69 */
++static ANTLR3_BITWORD FOLLOW_aexpr_in_expr69_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000022) };
++static ANTLR3_BITSET_LIST FOLLOW_aexpr_in_expr69 = { FOLLOW_aexpr_in_expr69_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr81 */
++static ANTLR3_BITWORD FOLLOW_crit_in_aexpr81_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
++static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr81 = { FOLLOW_crit_in_aexpr81_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_aexpr84 */
++static ANTLR3_BITWORD FOLLOW_AND_in_aexpr84_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
++static ANTLR3_BITSET_LIST FOLLOW_AND_in_aexpr84 = { FOLLOW_AND_in_aexpr84_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_crit_in_aexpr87 */
++static ANTLR3_BITWORD FOLLOW_crit_in_aexpr87_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000042) };
++static ANTLR3_BITSET_LIST FOLLOW_crit_in_aexpr87 = { FOLLOW_crit_in_aexpr87_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_LPAR_in_crit99 */
++static ANTLR3_BITWORD FOLLOW_LPAR_in_crit99_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000280) };
++static ANTLR3_BITSET_LIST FOLLOW_LPAR_in_crit99 = { FOLLOW_LPAR_in_crit99_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_crit101 */
++static ANTLR3_BITWORD FOLLOW_expr_in_crit101_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000100) };
++static ANTLR3_BITSET_LIST FOLLOW_expr_in_crit101 = { FOLLOW_expr_in_crit101_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_RPAR_in_crit103 */
++static ANTLR3_BITWORD FOLLOW_RPAR_in_crit103_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_RPAR_in_crit103 = { FOLLOW_RPAR_in_crit103_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_strcrit_in_crit114 */
++static ANTLR3_BITWORD FOLLOW_strcrit_in_crit114_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_strcrit_in_crit114 = { FOLLOW_strcrit_in_crit114_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intcrit_in_crit119 */
++static ANTLR3_BITWORD FOLLOW_intcrit_in_crit119_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_intcrit_in_crit119 = { FOLLOW_intcrit_in_crit119_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_datecrit_in_crit124 */
++static ANTLR3_BITWORD FOLLOW_datecrit_in_crit124_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_datecrit_in_crit124 = { FOLLOW_datecrit_in_crit124_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit134 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit134_bits[] = { ANTLR3_UINT64_LIT(0x000000000000F000) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit134 = { FOLLOW_FIELD_in_strcrit134_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit136 */
++static ANTLR3_BITWORD FOLLOW_strop_in_strcrit136_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
++static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit136 = { FOLLOW_strop_in_strcrit136_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit138 */
++static ANTLR3_BITWORD FOLLOW_STR_in_strcrit138_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit138 = { FOLLOW_STR_in_strcrit138_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_strcrit155 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_strcrit155_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_strcrit155 = { FOLLOW_FIELD_in_strcrit155_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_strcrit157 */
++static ANTLR3_BITWORD FOLLOW_NOT_in_strcrit157_bits[] = { ANTLR3_UINT64_LIT(0x000000000000F000) };
++static ANTLR3_BITSET_LIST FOLLOW_NOT_in_strcrit157 = { FOLLOW_NOT_in_strcrit157_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_strop_in_strcrit159 */
++static ANTLR3_BITWORD FOLLOW_strop_in_strcrit159_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
++static ANTLR3_BITSET_LIST FOLLOW_strop_in_strcrit159 = { FOLLOW_strop_in_strcrit159_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_STR_in_strcrit161 */
++static ANTLR3_BITWORD FOLLOW_STR_in_strcrit161_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_STR_in_strcrit161 = { FOLLOW_STR_in_strcrit161_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_strop0 */
++static ANTLR3_BITWORD FOLLOW_set_in_strop0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_strop0 = { FOLLOW_set_in_strop0_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit211 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit211_bits[] = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit211 = { FOLLOW_FIELD_in_intcrit211_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit213 */
++static ANTLR3_BITWORD FOLLOW_intop_in_intcrit213_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
++static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit213 = { FOLLOW_intop_in_intcrit213_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit215 */
++static ANTLR3_BITWORD FOLLOW_INT_in_intcrit215_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit215 = { FOLLOW_INT_in_intcrit215_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_intcrit232 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_intcrit232_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000800) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_intcrit232 = { FOLLOW_FIELD_in_intcrit232_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_intcrit234 */
++static ANTLR3_BITWORD FOLLOW_NOT_in_intcrit234_bits[] = { ANTLR3_UINT64_LIT(0x00000000001E1000) };
++static ANTLR3_BITSET_LIST FOLLOW_NOT_in_intcrit234 = { FOLLOW_NOT_in_intcrit234_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_intop_in_intcrit236 */
++static ANTLR3_BITWORD FOLLOW_intop_in_intcrit236_bits[] = { ANTLR3_UINT64_LIT(0x0000000000010000) };
++static ANTLR3_BITSET_LIST FOLLOW_intop_in_intcrit236 = { FOLLOW_intop_in_intcrit236_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_intcrit238 */
++static ANTLR3_BITWORD FOLLOW_INT_in_intcrit238_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_intcrit238 = { FOLLOW_INT_in_intcrit238_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_intop0 */
++static ANTLR3_BITWORD FOLLOW_set_in_intop0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_intop0 = { FOLLOW_set_in_intop0_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_FIELD_in_datecrit292 */
++static ANTLR3_BITWORD FOLLOW_FIELD_in_datecrit292_bits[] = { ANTLR3_UINT64_LIT(0x0000000000600000) };
++static ANTLR3_BITSET_LIST FOLLOW_FIELD_in_datecrit292 = { FOLLOW_FIELD_in_datecrit292_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datecrit294 */
++static ANTLR3_BITWORD FOLLOW_dateop_in_datecrit294_bits[] = { ANTLR3_UINT64_LIT(0x0000000001810000) };
++static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datecrit294 = { FOLLOW_dateop_in_datecrit294_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_datespec_in_datecrit296 */
++static ANTLR3_BITWORD FOLLOW_datespec_in_datecrit296_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_datespec_in_datecrit296 = { FOLLOW_datespec_in_datecrit296_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateop0 */
++static ANTLR3_BITWORD FOLLOW_set_in_dateop0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_dateop0 = { FOLLOW_set_in_dateop0_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec331 */
++static ANTLR3_BITWORD FOLLOW_dateref_in_datespec331_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec331 = { FOLLOW_dateref_in_datespec331_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_datespec336 */
++static ANTLR3_BITWORD FOLLOW_INT_in_datespec336_bits[] = { ANTLR3_UINT64_LIT(0x000000001E000000) };
++static ANTLR3_BITSET_LIST FOLLOW_INT_in_datespec336 = { FOLLOW_INT_in_datespec336_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateintval_in_datespec338 */
++static ANTLR3_BITWORD FOLLOW_dateintval_in_datespec338_bits[] = { ANTLR3_UINT64_LIT(0x0000000000600000) };
++static ANTLR3_BITSET_LIST FOLLOW_dateintval_in_datespec338 = { FOLLOW_dateintval_in_datespec338_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateop_in_datespec340 */
++static ANTLR3_BITWORD FOLLOW_dateop_in_datespec340_bits[] = { ANTLR3_UINT64_LIT(0x0000000001800000) };
++static ANTLR3_BITSET_LIST FOLLOW_dateop_in_datespec340 = { FOLLOW_dateop_in_datespec340_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_dateref_in_datespec342 */
++static ANTLR3_BITWORD FOLLOW_dateref_in_datespec342_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_dateref_in_datespec342 = { FOLLOW_dateref_in_datespec342_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateref0 */
++static ANTLR3_BITWORD FOLLOW_set_in_dateref0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_dateref0 = { FOLLOW_set_in_dateref0_bits, 1 };
++/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_dateintval0 */
++static ANTLR3_BITWORD FOLLOW_set_in_dateintval0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
++static ANTLR3_BITSET_LIST FOLLOW_set_in_dateintval0 = { FOLLOW_set_in_dateintval0_bits, 1 };
++
++
++
++
++/* ==============================================
++ * Parsing rules
++ */
++/**
++ * $ANTLR start query
++ * RSP.g:27:1: query : expr ( NEWLINE )? EOF -> expr ;
++ */
++static RSPParser_query_return
++query(pRSPParser ctx)
++{
++ RSPParser_query_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN NEWLINE2;
++ pANTLR3_COMMON_TOKEN EOF3;
++ RSPParser_expr_return expr1;
++ #undef RETURN_TYPE_expr1
++ #define RETURN_TYPE_expr1 RSPParser_expr_return
++
++ pANTLR3_BASE_TREE NEWLINE2_tree;
++ pANTLR3_BASE_TREE EOF3_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NEWLINE;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_EOF;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ NEWLINE2 = NULL;
++ EOF3 = NULL;
++ expr1.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ NEWLINE2_tree = NULL;
++ EOF3_tree = NULL;
++
++ stream_NEWLINE = NULL;
++ #define CREATE_stream_NEWLINE if (stream_NEWLINE == NULL) {stream_NEWLINE = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NEWLINE"); }
++ stream_EOF = NULL;
++ #define CREATE_stream_EOF if (stream_EOF == NULL) {stream_EOF = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token EOF"); }
++ stream_expr = NULL;
++ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
++
++ retval.tree = NULL;
++ {
++ // RSP.g:27:7: ( expr ( NEWLINE )? EOF -> expr )
++ // RSP.g:27:9: expr ( NEWLINE )? EOF
++ {
++ FOLLOWPUSH(FOLLOW_expr_in_query42);
++ expr1=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ CREATE_stream_expr; stream_expr->add(stream_expr, expr1.tree, NULL);
++
++ // RSP.g:27:14: ( NEWLINE )?
++ {
++ int alt1=2;
++ switch ( LA(1) )
++ {
++ case NEWLINE:
++ {
++ alt1=1;
++ }
++ break;
++ }
++
++ switch (alt1)
++ {
++ case 1:
++ // RSP.g:27:14: NEWLINE
++ {
++ NEWLINE2 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_query44);
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ CREATE_stream_NEWLINE; stream_NEWLINE->add(stream_NEWLINE, NEWLINE2, NULL);
++
++
++ }
++ break;
++
++ }
++ }
++ EOF3 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_query47);
++ if (HASEXCEPTION())
++ {
++ goto rulequeryEx;
++ }
++
++ CREATE_stream_EOF; stream_EOF->add(stream_EOF, EOF3, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : expr
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 27:28: -> expr
++ {
++ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulequeryEx; /* Prevent compiler warnings */
++ rulequeryEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_NEWLINE != NULL) stream_NEWLINE->free(stream_NEWLINE);
++ if (stream_EOF != NULL) stream_EOF->free(stream_EOF);
++ if (stream_expr != NULL) stream_expr->free(stream_expr);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end query */
++
++/**
++ * $ANTLR start expr
++ * RSP.g:30:1: expr : aexpr ( OR aexpr )* ;
++ */
++static RSPParser_expr_return
++expr(pRSPParser ctx)
++{
++ RSPParser_expr_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN OR5;
++ RSPParser_aexpr_return aexpr4;
++ #undef RETURN_TYPE_aexpr4
++ #define RETURN_TYPE_aexpr4 RSPParser_aexpr_return
++
++ RSPParser_aexpr_return aexpr6;
++ #undef RETURN_TYPE_aexpr6
++ #define RETURN_TYPE_aexpr6 RSPParser_aexpr_return
++
++ pANTLR3_BASE_TREE OR5_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ OR5 = NULL;
++ aexpr4.tree = NULL;
++
++ aexpr6.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ OR5_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:30:6: ( aexpr ( OR aexpr )* )
++ // RSP.g:30:8: aexpr ( OR aexpr )*
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_aexpr_in_expr63);
++ aexpr4=aexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, aexpr4.tree);
++
++ // RSP.g:30:14: ( OR aexpr )*
++
++ for (;;)
++ {
++ int alt2=2;
++ switch ( LA(1) )
++ {
++ case OR:
++ {
++ alt2=1;
++ }
++ break;
++
++ }
++
++ switch (alt2)
++ {
++ case 1:
++ // RSP.g:30:15: OR aexpr
++ {
++ OR5 = (pANTLR3_COMMON_TOKEN) MATCHT(OR, &FOLLOW_OR_in_expr66);
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ OR5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, OR5));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, OR5_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_aexpr_in_expr69);
++ aexpr6=aexpr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, aexpr6.tree);
++
++ }
++ break;
++
++ default:
++ goto loop2; /* break out of the loop */
++ break;
++ }
++ }
++ loop2: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleexprEx; /* Prevent compiler warnings */
++ ruleexprEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end expr */
++
++/**
++ * $ANTLR start aexpr
++ * RSP.g:33:1: aexpr : crit ( AND crit )* ;
++ */
++static RSPParser_aexpr_return
++aexpr(pRSPParser ctx)
++{
++ RSPParser_aexpr_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN AND8;
++ RSPParser_crit_return crit7;
++ #undef RETURN_TYPE_crit7
++ #define RETURN_TYPE_crit7 RSPParser_crit_return
++
++ RSPParser_crit_return crit9;
++ #undef RETURN_TYPE_crit9
++ #define RETURN_TYPE_crit9 RSPParser_crit_return
++
++ pANTLR3_BASE_TREE AND8_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ AND8 = NULL;
++ crit7.tree = NULL;
++
++ crit9.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ AND8_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:33:7: ( crit ( AND crit )* )
++ // RSP.g:33:9: crit ( AND crit )*
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_crit_in_aexpr81);
++ crit7=crit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, crit7.tree);
++
++ // RSP.g:33:14: ( AND crit )*
++
++ for (;;)
++ {
++ int alt3=2;
++ switch ( LA(1) )
++ {
++ case AND:
++ {
++ alt3=1;
++ }
++ break;
++
++ }
++
++ switch (alt3)
++ {
++ case 1:
++ // RSP.g:33:15: AND crit
++ {
++ AND8 = (pANTLR3_COMMON_TOKEN) MATCHT(AND, &FOLLOW_AND_in_aexpr84);
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ AND8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, AND8));
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, AND8_tree, root_0));
++
++ FOLLOWPUSH(FOLLOW_crit_in_aexpr87);
++ crit9=crit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleaexprEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, crit9.tree);
++
++ }
++ break;
++
++ default:
++ goto loop3; /* break out of the loop */
++ break;
++ }
++ }
++ loop3: ; /* Jump out to here if this rule does not match */
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleaexprEx; /* Prevent compiler warnings */
++ ruleaexprEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end aexpr */
++
++/**
++ * $ANTLR start crit
++ * RSP.g:36:1: crit : ( LPAR expr RPAR -> expr | strcrit | intcrit | datecrit );
++ */
++static RSPParser_crit_return
++crit(pRSPParser ctx)
++{
++ RSPParser_crit_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN LPAR10;
++ pANTLR3_COMMON_TOKEN RPAR12;
++ RSPParser_expr_return expr11;
++ #undef RETURN_TYPE_expr11
++ #define RETURN_TYPE_expr11 RSPParser_expr_return
++
++ RSPParser_strcrit_return strcrit13;
++ #undef RETURN_TYPE_strcrit13
++ #define RETURN_TYPE_strcrit13 RSPParser_strcrit_return
++
++ RSPParser_intcrit_return intcrit14;
++ #undef RETURN_TYPE_intcrit14
++ #define RETURN_TYPE_intcrit14 RSPParser_intcrit_return
++
++ RSPParser_datecrit_return datecrit15;
++ #undef RETURN_TYPE_datecrit15
++ #define RETURN_TYPE_datecrit15 RSPParser_datecrit_return
++
++ pANTLR3_BASE_TREE LPAR10_tree;
++ pANTLR3_BASE_TREE RPAR12_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_RPAR;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_LPAR;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ LPAR10 = NULL;
++ RPAR12 = NULL;
++ expr11.tree = NULL;
++
++ strcrit13.tree = NULL;
++
++ intcrit14.tree = NULL;
++
++ datecrit15.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ LPAR10_tree = NULL;
++ RPAR12_tree = NULL;
++
++ stream_RPAR = NULL;
++ #define CREATE_stream_RPAR if (stream_RPAR == NULL) {stream_RPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token RPAR"); }
++ stream_LPAR = NULL;
++ #define CREATE_stream_LPAR if (stream_LPAR == NULL) {stream_LPAR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token LPAR"); }
++ stream_expr = NULL;
++ #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); }
++
++ retval.tree = NULL;
++ {
++ {
++ // RSP.g:36:6: ( LPAR expr RPAR -> expr | strcrit | intcrit | datecrit )
++
++ ANTLR3_UINT32 alt4;
++
++ alt4=4;
++
++ switch ( LA(1) )
++ {
++ case LPAR:
++ {
++ alt4=1;
++ }
++ break;
++ case FIELD:
++ {
++ switch ( LA(2) )
++ {
++ case NOT:
++ {
++ switch ( LA(3) )
++ {
++ case EQUAL:
++ {
++ switch ( LA(4) )
++ {
++ case STR:
++ {
++ alt4=2;
++ }
++ break;
++ case INT:
++ {
++ alt4=3;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 8;
++
++
++ goto rulecritEx;
++ }
++
++ }
++ break;
++ case INCLUDES:
++ case STARTSW:
++ case ENDSW:
++ {
++ alt4=2;
++ }
++ break;
++ case LESS:
++ case GREATER:
++ case LTE:
++ case GTE:
++ {
++ alt4=3;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 3;
++
++
++ goto rulecritEx;
++ }
++
++ }
++ break;
++ case EQUAL:
++ {
++ switch ( LA(3) )
++ {
++ case INT:
++ {
++ alt4=3;
++ }
++ break;
++ case STR:
++ {
++ alt4=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 4;
++
++
++ goto rulecritEx;
++ }
++
++ }
++ break;
++ case BEFORE:
++ case AFTER:
++ {
++ alt4=4;
++ }
++ break;
++ case LESS:
++ case GREATER:
++ case LTE:
++ case GTE:
++ {
++ alt4=3;
++ }
++ break;
++ case INCLUDES:
++ case STARTSW:
++ case ENDSW:
++ {
++ alt4=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 2;
++
++
++ goto rulecritEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 4;
++ EXCEPTION->state = 0;
++
++
++ goto rulecritEx;
++ }
++
++ switch (alt4)
++ {
++ case 1:
++ // RSP.g:36:8: LPAR expr RPAR
++ {
++ LPAR10 = (pANTLR3_COMMON_TOKEN) MATCHT(LPAR, &FOLLOW_LPAR_in_crit99);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_LPAR; stream_LPAR->add(stream_LPAR, LPAR10, NULL);
++
++ FOLLOWPUSH(FOLLOW_expr_in_crit101);
++ expr11=expr(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_expr; stream_expr->add(stream_expr, expr11.tree, NULL);
++ RPAR12 = (pANTLR3_COMMON_TOKEN) MATCHT(RPAR, &FOLLOW_RPAR_in_crit103);
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ CREATE_stream_RPAR; stream_RPAR->add(stream_RPAR, RPAR12, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : expr
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 36:25: -> expr
++ {
++ ADAPTOR->addChild(ADAPTOR, root_0, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr));
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++ case 2:
++ // RSP.g:37:4: strcrit
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_strcrit_in_crit114);
++ strcrit13=strcrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, strcrit13.tree);
++
++ }
++ break;
++ case 3:
++ // RSP.g:38:4: intcrit
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_intcrit_in_crit119);
++ intcrit14=intcrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, intcrit14.tree);
++
++ }
++ break;
++ case 4:
++ // RSP.g:39:4: datecrit
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_datecrit_in_crit124);
++ datecrit15=datecrit(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulecritEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, datecrit15.tree);
++
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulecritEx; /* Prevent compiler warnings */
++ rulecritEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_RPAR != NULL) stream_RPAR->free(stream_RPAR);
++ if (stream_LPAR != NULL) stream_LPAR->free(stream_LPAR);
++ if (stream_expr != NULL) stream_expr->free(stream_expr);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end crit */
++
++/**
++ * $ANTLR start strcrit
++ * RSP.g:42:1: strcrit : ( FIELD strop STR -> ^( strop FIELD STR ) | FIELD NOT strop STR -> ^( NOT ^( strop FIELD STR ) ) );
++ */
++static RSPParser_strcrit_return
++strcrit(pRSPParser ctx)
++{
++ RSPParser_strcrit_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN FIELD16;
++ pANTLR3_COMMON_TOKEN STR18;
++ pANTLR3_COMMON_TOKEN FIELD19;
++ pANTLR3_COMMON_TOKEN NOT20;
++ pANTLR3_COMMON_TOKEN STR22;
++ RSPParser_strop_return strop17;
++ #undef RETURN_TYPE_strop17
++ #define RETURN_TYPE_strop17 RSPParser_strop_return
++
++ RSPParser_strop_return strop21;
++ #undef RETURN_TYPE_strop21
++ #define RETURN_TYPE_strop21 RSPParser_strop_return
++
++ pANTLR3_BASE_TREE FIELD16_tree;
++ pANTLR3_BASE_TREE STR18_tree;
++ pANTLR3_BASE_TREE FIELD19_tree;
++ pANTLR3_BASE_TREE NOT20_tree;
++ pANTLR3_BASE_TREE STR22_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_STR;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_strop;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ FIELD16 = NULL;
++ STR18 = NULL;
++ FIELD19 = NULL;
++ NOT20 = NULL;
++ STR22 = NULL;
++ strop17.tree = NULL;
++
++ strop21.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ FIELD16_tree = NULL;
++ STR18_tree = NULL;
++ FIELD19_tree = NULL;
++ NOT20_tree = NULL;
++ STR22_tree = NULL;
++
++ stream_STR = NULL;
++ #define CREATE_stream_STR if (stream_STR == NULL) {stream_STR = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token STR"); }
++ stream_FIELD = NULL;
++ #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); }
++ stream_NOT = NULL;
++ #define CREATE_stream_NOT if (stream_NOT == NULL) {stream_NOT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NOT"); }
++ stream_strop = NULL;
++ #define CREATE_stream_strop if (stream_strop == NULL) {stream_strop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule strop"); }
++
++ retval.tree = NULL;
++ {
++ {
++ // RSP.g:42:9: ( FIELD strop STR -> ^( strop FIELD STR ) | FIELD NOT strop STR -> ^( NOT ^( strop FIELD STR ) ) )
++
++ ANTLR3_UINT32 alt5;
++
++ alt5=2;
++
++ switch ( LA(1) )
++ {
++ case FIELD:
++ {
++ switch ( LA(2) )
++ {
++ case NOT:
++ {
++ alt5=2;
++ }
++ break;
++ case EQUAL:
++ case INCLUDES:
++ case STARTSW:
++ case ENDSW:
++ {
++ alt5=1;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 1;
++
++
++ goto rulestrcritEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 5;
++ EXCEPTION->state = 0;
++
++
++ goto rulestrcritEx;
++ }
++
++ switch (alt5)
++ {
++ case 1:
++ // RSP.g:42:11: FIELD strop STR
++ {
++ FIELD16 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit134);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD16, NULL);
++
++ FOLLOWPUSH(FOLLOW_strop_in_strcrit136);
++ strop17=strop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_strop; stream_strop->add(stream_strop, strop17.tree, NULL);
++ STR18 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_strcrit138);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_STR; stream_STR->add(stream_STR, STR18, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : strop, STR, FIELD
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 42:29: -> ^( strop FIELD STR )
++ {
++ // RSP.g:42:32: ^( strop FIELD STR )
++ {
++ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_strop == NULL ? NULL : stream_strop->nextNode(stream_strop), root_1));
++
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_STR == NULL ? NULL : stream_STR->nextNode(stream_STR));
++
++ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
++ }
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++ case 2:
++ // RSP.g:43:4: FIELD NOT strop STR
++ {
++ FIELD19 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_strcrit155);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD19, NULL);
++
++ NOT20 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_strcrit157);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT20, NULL);
++
++ FOLLOWPUSH(FOLLOW_strop_in_strcrit159);
++ strop21=strop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_strop; stream_strop->add(stream_strop, strop21.tree, NULL);
++ STR22 = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_strcrit161);
++ if (HASEXCEPTION())
++ {
++ goto rulestrcritEx;
++ }
++
++ CREATE_stream_STR; stream_STR->add(stream_STR, STR22, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : NOT, FIELD, strop, STR
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 43:25: -> ^( NOT ^( strop FIELD STR ) )
++ {
++ // RSP.g:43:28: ^( NOT ^( strop FIELD STR ) )
++ {
++ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_NOT == NULL ? NULL : stream_NOT->nextNode(stream_NOT), root_1));
++
++ // RSP.g:43:34: ^( strop FIELD STR )
++ {
++ pANTLR3_BASE_TREE root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_strop == NULL ? NULL : stream_strop->nextNode(stream_strop), root_2));
++
++ ADAPTOR->addChild(ADAPTOR, root_2, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
++ ADAPTOR->addChild(ADAPTOR, root_2, stream_STR == NULL ? NULL : stream_STR->nextNode(stream_STR));
++
++ ADAPTOR->addChild(ADAPTOR, root_1, root_2);
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
++ }
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulestrcritEx; /* Prevent compiler warnings */
++ rulestrcritEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_STR != NULL) stream_STR->free(stream_STR);
++ if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD);
++ if (stream_NOT != NULL) stream_NOT->free(stream_NOT);
++ if (stream_strop != NULL) stream_strop->free(stream_strop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end strcrit */
++
++/**
++ * $ANTLR start strop
++ * RSP.g:46:1: strop : ( EQUAL | INCLUDES | STARTSW | ENDSW );
++ */
++static RSPParser_strop_return
++strop(pRSPParser ctx)
++{
++ RSPParser_strop_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN set23;
++
++ pANTLR3_BASE_TREE set23_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ set23 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ set23_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:46:7: ( EQUAL | INCLUDES | STARTSW | ENDSW )
++ // RSP.g:
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ set23=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( ((LA(1) >= EQUAL) && (LA(1) <= ENDSW)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set23)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_strop0;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_strop0); goto rulestropEx;
++ }
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto rulestropEx; /* Prevent compiler warnings */
++ rulestropEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end strop */
++
++/**
++ * $ANTLR start intcrit
++ * RSP.g:52:1: intcrit : ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) );
++ */
++static RSPParser_intcrit_return
++intcrit(pRSPParser ctx)
++{
++ RSPParser_intcrit_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN FIELD24;
++ pANTLR3_COMMON_TOKEN INT26;
++ pANTLR3_COMMON_TOKEN FIELD27;
++ pANTLR3_COMMON_TOKEN NOT28;
++ pANTLR3_COMMON_TOKEN INT30;
++ RSPParser_intop_return intop25;
++ #undef RETURN_TYPE_intop25
++ #define RETURN_TYPE_intop25 RSPParser_intop_return
++
++ RSPParser_intop_return intop29;
++ #undef RETURN_TYPE_intop29
++ #define RETURN_TYPE_intop29 RSPParser_intop_return
++
++ pANTLR3_BASE_TREE FIELD24_tree;
++ pANTLR3_BASE_TREE INT26_tree;
++ pANTLR3_BASE_TREE FIELD27_tree;
++ pANTLR3_BASE_TREE NOT28_tree;
++ pANTLR3_BASE_TREE INT30_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_NOT;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_intop;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ FIELD24 = NULL;
++ INT26 = NULL;
++ FIELD27 = NULL;
++ NOT28 = NULL;
++ INT30 = NULL;
++ intop25.tree = NULL;
++
++ intop29.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ FIELD24_tree = NULL;
++ INT26_tree = NULL;
++ FIELD27_tree = NULL;
++ NOT28_tree = NULL;
++ INT30_tree = NULL;
++
++ stream_FIELD = NULL;
++ #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); }
++ stream_INT = NULL;
++ #define CREATE_stream_INT if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); }
++ stream_NOT = NULL;
++ #define CREATE_stream_NOT if (stream_NOT == NULL) {stream_NOT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token NOT"); }
++ stream_intop = NULL;
++ #define CREATE_stream_intop if (stream_intop == NULL) {stream_intop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule intop"); }
++
++ retval.tree = NULL;
++ {
++ {
++ // RSP.g:52:9: ( FIELD intop INT -> ^( intop FIELD INT ) | FIELD NOT intop INT -> ^( NOT ^( intop FIELD INT ) ) )
++
++ ANTLR3_UINT32 alt6;
++
++ alt6=2;
++
++ switch ( LA(1) )
++ {
++ case FIELD:
++ {
++ switch ( LA(2) )
++ {
++ case NOT:
++ {
++ alt6=2;
++ }
++ break;
++ case EQUAL:
++ case LESS:
++ case GREATER:
++ case LTE:
++ case GTE:
++ {
++ alt6=1;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 6;
++ EXCEPTION->state = 1;
++
++
++ goto ruleintcritEx;
++ }
++
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 6;
++ EXCEPTION->state = 0;
++
++
++ goto ruleintcritEx;
++ }
++
++ switch (alt6)
++ {
++ case 1:
++ // RSP.g:52:11: FIELD intop INT
++ {
++ FIELD24 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit211);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD24, NULL);
++
++ FOLLOWPUSH(FOLLOW_intop_in_intcrit213);
++ intop25=intop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_intop; stream_intop->add(stream_intop, intop25.tree, NULL);
++ INT26 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit215);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_INT; stream_INT->add(stream_INT, INT26, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : FIELD, intop, INT
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 52:29: -> ^( intop FIELD INT )
++ {
++ // RSP.g:52:32: ^( intop FIELD INT )
++ {
++ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_intop == NULL ? NULL : stream_intop->nextNode(stream_intop), root_1));
++
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT));
++
++ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
++ }
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++ case 2:
++ // RSP.g:53:4: FIELD NOT intop INT
++ {
++ FIELD27 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_intcrit232);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD27, NULL);
++
++ NOT28 = (pANTLR3_COMMON_TOKEN) MATCHT(NOT, &FOLLOW_NOT_in_intcrit234);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_NOT; stream_NOT->add(stream_NOT, NOT28, NULL);
++
++ FOLLOWPUSH(FOLLOW_intop_in_intcrit236);
++ intop29=intop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_intop; stream_intop->add(stream_intop, intop29.tree, NULL);
++ INT30 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_intcrit238);
++ if (HASEXCEPTION())
++ {
++ goto ruleintcritEx;
++ }
++
++ CREATE_stream_INT; stream_INT->add(stream_INT, INT30, NULL);
++
++
++
++ /* AST REWRITE
++ * elements : NOT, INT, FIELD, intop
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 53:25: -> ^( NOT ^( intop FIELD INT ) )
++ {
++ // RSP.g:53:28: ^( NOT ^( intop FIELD INT ) )
++ {
++ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_NOT == NULL ? NULL : stream_NOT->nextNode(stream_NOT), root_1));
++
++ // RSP.g:53:34: ^( intop FIELD INT )
++ {
++ pANTLR3_BASE_TREE root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_2 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_intop == NULL ? NULL : stream_intop->nextNode(stream_intop), root_2));
++
++ ADAPTOR->addChild(ADAPTOR, root_2, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
++ ADAPTOR->addChild(ADAPTOR, root_2, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT));
++
++ ADAPTOR->addChild(ADAPTOR, root_1, root_2);
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
++ }
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleintcritEx; /* Prevent compiler warnings */
++ ruleintcritEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD);
++ if (stream_INT != NULL) stream_INT->free(stream_INT);
++ if (stream_NOT != NULL) stream_NOT->free(stream_NOT);
++ if (stream_intop != NULL) stream_intop->free(stream_intop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end intcrit */
++
++/**
++ * $ANTLR start intop
++ * RSP.g:56:1: intop : ( EQUAL | LESS | GREATER | LTE | GTE );
++ */
++static RSPParser_intop_return
++intop(pRSPParser ctx)
++{
++ RSPParser_intop_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN set31;
++
++ pANTLR3_BASE_TREE set31_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ set31 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ set31_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:56:7: ( EQUAL | LESS | GREATER | LTE | GTE )
++ // RSP.g:
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ set31=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( LA(1) == EQUAL || ((LA(1) >= LESS) && (LA(1) <= GTE)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set31)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_intop0;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_intop0); goto ruleintopEx;
++ }
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruleintopEx; /* Prevent compiler warnings */
++ ruleintopEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end intop */
++
++/**
++ * $ANTLR start datecrit
++ * RSP.g:63:1: datecrit : FIELD dateop datespec -> ^( dateop FIELD datespec ) ;
++ */
++static RSPParser_datecrit_return
++datecrit(pRSPParser ctx)
++{
++ RSPParser_datecrit_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN FIELD32;
++ RSPParser_dateop_return dateop33;
++ #undef RETURN_TYPE_dateop33
++ #define RETURN_TYPE_dateop33 RSPParser_dateop_return
++
++ RSPParser_datespec_return datespec34;
++ #undef RETURN_TYPE_datespec34
++ #define RETURN_TYPE_datespec34 RSPParser_datespec_return
++
++ pANTLR3_BASE_TREE FIELD32_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_FIELD;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_datespec;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ FIELD32 = NULL;
++ dateop33.tree = NULL;
++
++ datespec34.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ FIELD32_tree = NULL;
++
++ stream_FIELD = NULL;
++ #define CREATE_stream_FIELD if (stream_FIELD == NULL) {stream_FIELD = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token FIELD"); }
++ stream_datespec = NULL;
++ #define CREATE_stream_datespec if (stream_datespec == NULL) {stream_datespec = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule datespec"); }
++ stream_dateop = NULL;
++ #define CREATE_stream_dateop if (stream_dateop == NULL) {stream_dateop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateop"); }
++
++ retval.tree = NULL;
++ {
++ // RSP.g:63:9: ( FIELD dateop datespec -> ^( dateop FIELD datespec ) )
++ // RSP.g:63:11: FIELD dateop datespec
++ {
++ FIELD32 = (pANTLR3_COMMON_TOKEN) MATCHT(FIELD, &FOLLOW_FIELD_in_datecrit292);
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++ CREATE_stream_FIELD; stream_FIELD->add(stream_FIELD, FIELD32, NULL);
++
++ FOLLOWPUSH(FOLLOW_dateop_in_datecrit294);
++ dateop33=dateop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++ CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop33.tree, NULL);
++ FOLLOWPUSH(FOLLOW_datespec_in_datecrit296);
++ datespec34=datespec(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatecritEx;
++ }
++
++ CREATE_stream_datespec; stream_datespec->add(stream_datespec, datespec34.tree, NULL);
++
++
++ /* AST REWRITE
++ * elements : FIELD, datespec, dateop
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 63:34: -> ^( dateop FIELD datespec )
++ {
++ // RSP.g:63:37: ^( dateop FIELD datespec )
++ {
++ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_dateop == NULL ? NULL : stream_dateop->nextNode(stream_dateop), root_1));
++
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_FIELD == NULL ? NULL : stream_FIELD->nextNode(stream_FIELD));
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_datespec == NULL ? NULL : stream_datespec->nextTree(stream_datespec));
++
++ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
++ }
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledatecritEx; /* Prevent compiler warnings */
++ ruledatecritEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_FIELD != NULL) stream_FIELD->free(stream_FIELD);
++ if (stream_datespec != NULL) stream_datespec->free(stream_datespec);
++ if (stream_dateop != NULL) stream_dateop->free(stream_dateop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end datecrit */
++
++/**
++ * $ANTLR start dateop
++ * RSP.g:66:1: dateop : ( BEFORE | AFTER );
++ */
++static RSPParser_dateop_return
++dateop(pRSPParser ctx)
++{
++ RSPParser_dateop_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN set35;
++
++ pANTLR3_BASE_TREE set35_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ set35 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ set35_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:66:8: ( BEFORE | AFTER )
++ // RSP.g:
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ set35=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( ((LA(1) >= BEFORE) && (LA(1) <= AFTER)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set35)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_dateop0;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateop0); goto ruledateopEx;
++ }
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledateopEx; /* Prevent compiler warnings */
++ ruledateopEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end dateop */
++
++/**
++ * $ANTLR start datespec
++ * RSP.g:70:1: datespec : ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) );
++ */
++static RSPParser_datespec_return
++datespec(pRSPParser ctx)
++{
++ RSPParser_datespec_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN INT37;
++ RSPParser_dateref_return dateref36;
++ #undef RETURN_TYPE_dateref36
++ #define RETURN_TYPE_dateref36 RSPParser_dateref_return
++
++ RSPParser_dateintval_return dateintval38;
++ #undef RETURN_TYPE_dateintval38
++ #define RETURN_TYPE_dateintval38 RSPParser_dateintval_return
++
++ RSPParser_dateop_return dateop39;
++ #undef RETURN_TYPE_dateop39
++ #define RETURN_TYPE_dateop39 RSPParser_dateop_return
++
++ RSPParser_dateref_return dateref40;
++ #undef RETURN_TYPE_dateref40
++ #define RETURN_TYPE_dateref40 RSPParser_dateref_return
++
++ pANTLR3_BASE_TREE INT37_tree;
++ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_INT;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateintval;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateref;
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_dateop;
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ INT37 = NULL;
++ dateref36.tree = NULL;
++
++ dateintval38.tree = NULL;
++
++ dateop39.tree = NULL;
++
++ dateref40.tree = NULL;
++
++ retval.start = LT(1); retval.stop = retval.start;
++
++ INT37_tree = NULL;
++
++ stream_INT = NULL;
++ #define CREATE_stream_INT if (stream_INT == NULL) {stream_INT = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token INT"); }
++ stream_dateintval = NULL;
++ #define CREATE_stream_dateintval if (stream_dateintval == NULL) {stream_dateintval = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateintval"); }
++ stream_dateref = NULL;
++ #define CREATE_stream_dateref if (stream_dateref == NULL) {stream_dateref = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateref"); }
++ stream_dateop = NULL;
++ #define CREATE_stream_dateop if (stream_dateop == NULL) {stream_dateop = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule dateop"); }
++
++ retval.tree = NULL;
++ {
++ {
++ // RSP.g:70:9: ( dateref | INT dateintval dateop dateref -> ^( dateop dateref INT dateintval ) )
++
++ ANTLR3_UINT32 alt7;
++
++ alt7=2;
++
++ switch ( LA(1) )
++ {
++ case DATE:
++ case TODAY:
++ {
++ alt7=1;
++ }
++ break;
++ case INT:
++ {
++ alt7=2;
++ }
++ break;
++
++ default:
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
++ EXCEPTION->message = (void *)"";
++ EXCEPTION->decisionNum = 7;
++ EXCEPTION->state = 0;
++
++
++ goto ruledatespecEx;
++ }
++
++ switch (alt7)
++ {
++ case 1:
++ // RSP.g:70:11: dateref
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ FOLLOWPUSH(FOLLOW_dateref_in_datespec331);
++ dateref36=dateref(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ ADAPTOR->addChild(ADAPTOR, root_0, dateref36.tree);
++
++ }
++ break;
++ case 2:
++ // RSP.g:71:4: INT dateintval dateop dateref
++ {
++ INT37 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_datespec336);
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ CREATE_stream_INT; stream_INT->add(stream_INT, INT37, NULL);
++
++ FOLLOWPUSH(FOLLOW_dateintval_in_datespec338);
++ dateintval38=dateintval(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ CREATE_stream_dateintval; stream_dateintval->add(stream_dateintval, dateintval38.tree, NULL);
++ FOLLOWPUSH(FOLLOW_dateop_in_datespec340);
++ dateop39=dateop(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ CREATE_stream_dateop; stream_dateop->add(stream_dateop, dateop39.tree, NULL);
++ FOLLOWPUSH(FOLLOW_dateref_in_datespec342);
++ dateref40=dateref(ctx);
++
++ FOLLOWPOP();
++ if (HASEXCEPTION())
++ {
++ goto ruledatespecEx;
++ }
++
++ CREATE_stream_dateref; stream_dateref->add(stream_dateref, dateref40.tree, NULL);
++
++
++ /* AST REWRITE
++ * elements : dateintval, INT, dateref, dateop
++ * token labels :
++ * rule labels : retval
++ * token list labels :
++ * rule list labels :
++ */
++ {
++ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
++
++ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
++
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ retval.tree = root_0;
++ // 71:34: -> ^( dateop dateref INT dateintval )
++ {
++ // RSP.g:71:37: ^( dateop dateref INT dateintval )
++ {
++ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, stream_dateop == NULL ? NULL : stream_dateop->nextNode(stream_dateop), root_1));
++
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_dateref == NULL ? NULL : stream_dateref->nextTree(stream_dateref));
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_INT == NULL ? NULL : stream_INT->nextNode(stream_INT));
++ ADAPTOR->addChild(ADAPTOR, root_1, stream_dateintval == NULL ? NULL : stream_dateintval->nextTree(stream_dateintval));
++
++ ADAPTOR->addChild(ADAPTOR, root_0, root_1);
++ }
++
++ }
++
++ retval.tree = root_0; // set result root
++ if (stream_retval != NULL) stream_retval->free(stream_retval);
++
++
++ }
++ }
++ break;
++
++ }
++ }
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledatespecEx; /* Prevent compiler warnings */
++ ruledatespecEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++ if (stream_INT != NULL) stream_INT->free(stream_INT);
++ if (stream_dateintval != NULL) stream_dateintval->free(stream_dateintval);
++ if (stream_dateref != NULL) stream_dateref->free(stream_dateref);
++ if (stream_dateop != NULL) stream_dateop->free(stream_dateop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end datespec */
++
++/**
++ * $ANTLR start dateref
++ * RSP.g:74:1: dateref : ( DATE | TODAY );
++ */
++static RSPParser_dateref_return
++dateref(pRSPParser ctx)
++{
++ RSPParser_dateref_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN set41;
++
++ pANTLR3_BASE_TREE set41_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ set41 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ set41_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:74:9: ( DATE | TODAY )
++ // RSP.g:
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ set41=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( ((LA(1) >= DATE) && (LA(1) <= TODAY)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set41)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_dateref0;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateref0); goto ruledaterefEx;
++ }
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledaterefEx; /* Prevent compiler warnings */
++ ruledaterefEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end dateref */
++
++/**
++ * $ANTLR start dateintval
++ * RSP.g:78:1: dateintval : ( DAY | WEEK | MONTH | YEAR );
++ */
++static RSPParser_dateintval_return
++dateintval(pRSPParser ctx)
++{
++ RSPParser_dateintval_return retval;
++
++ pANTLR3_BASE_TREE root_0;
++
++ pANTLR3_COMMON_TOKEN set42;
++
++ pANTLR3_BASE_TREE set42_tree;
++
++ /* Initialize rule variables
++ */
++
++
++ root_0 = NULL;
++
++ set42 = NULL;
++ retval.start = LT(1); retval.stop = retval.start;
++
++ set42_tree = NULL;
++
++
++ retval.tree = NULL;
++ {
++ // RSP.g:79:2: ( DAY | WEEK | MONTH | YEAR )
++ // RSP.g:
++ {
++ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
++
++ set42=(pANTLR3_COMMON_TOKEN)LT(1);
++ if ( ((LA(1) >= DAY) && (LA(1) <= YEAR)) )
++ {
++ CONSUME();
++ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set42)));
++ PERRORRECOVERY=ANTLR3_FALSE;
++ }
++ else
++ {
++ CONSTRUCTEX();
++ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
++ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
++ EXCEPTION->expectingSet = &FOLLOW_set_in_dateintval0;
++ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_dateintval0); goto ruledateintvalEx;
++ }
++
++
++ }
++
++ }
++
++
++ // This is where rules clean up and exit
++ //
++ goto ruledateintvalEx; /* Prevent compiler warnings */
++ ruledateintvalEx: ;
++ retval.stop = LT(-1);
++
++ retval.stop = LT(-1);
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
++ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
++
++ if (HASEXCEPTION())
++ {
++ PREPORTERROR();
++ PRECOVER();
++ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
++ }
++
++
++ return retval;
++}
++/* $ANTLR end dateintval */
++/* End of parsing rules
++ * ==============================================
++ */
++
++/* ==============================================
++ * Syntactic predicates
++ */
++/* End of syntactic predicates
++ * ==============================================
++ */
++
++
++
++
++
++
++/* End of code
++ * =============================================================================
++ */
+diff --git a/src/pregen/RSPParser.h b/src/pregen/RSPParser.h
+new file mode 100644
+index 0000000..d0744a2
+--- /dev/null
++++ b/src/pregen/RSPParser.h
+@@ -0,0 +1,365 @@
++/** \file
++ * This C header file was generated by $ANTLR version 3.2 debian-7ubuntu3
++ *
++ * - From the grammar source file : RSP.g
++ * - On : 2014-09-30 21:42:40
++ * - for the parser : RSPParserParser *
++ * Editing it, at least manually, is not wise.
++ *
++ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
++ *
++ *
++ * The parser RSPParser has the callable functions (rules) shown below,
++ * which will invoke the code for the associated rule in the source grammar
++ * assuming that the input stream is pointing to a token/text stream that could begin
++ * this rule.
++ *
++ * For instance if you call the first (topmost) rule in a parser grammar, you will
++ * get the results of a full parse, but calling a rule half way through the grammar will
++ * allow you to pass part of a full token stream to the parser, such as for syntax checking
++ * in editors and so on.
++ *
++ * The parser entry points are called indirectly (by function pointer to function) via
++ * a parser context typedef pRSPParser, which is returned from a call to RSPParserNew().
++ *
++ * The methods in pRSPParser are as follows:
++ *
++ * - RSPParser_query_return pRSPParser->query(pRSPParser)
++ * - RSPParser_expr_return pRSPParser->expr(pRSPParser)
++ * - RSPParser_aexpr_return pRSPParser->aexpr(pRSPParser)
++ * - RSPParser_crit_return pRSPParser->crit(pRSPParser)
++ * - RSPParser_strcrit_return pRSPParser->strcrit(pRSPParser)
++ * - RSPParser_strop_return pRSPParser->strop(pRSPParser)
++ * - RSPParser_intcrit_return pRSPParser->intcrit(pRSPParser)
++ * - RSPParser_intop_return pRSPParser->intop(pRSPParser)
++ * - RSPParser_datecrit_return pRSPParser->datecrit(pRSPParser)
++ * - RSPParser_dateop_return pRSPParser->dateop(pRSPParser)
++ * - RSPParser_datespec_return pRSPParser->datespec(pRSPParser)
++ * - RSPParser_dateref_return pRSPParser->dateref(pRSPParser)
++ * - RSPParser_dateintval_return pRSPParser->dateintval(pRSPParser)
++ *
++ * The return type for any particular rule is of course determined by the source
++ * grammar file.
++ */
++// [The "BSD licence"]
++// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
++// http://www.temporal-wave.com
++// http://www.linkedin.com/in/jimidle
++//
++// All rights reserved.
++//
++// Redistribution and use in source and binary forms, with or without
++// modification, are permitted provided that the following conditions
++// are met:
++// 1. Redistributions of source code must retain the above copyright
++// notice, this list of conditions and the following disclaimer.
++// 2. Redistributions in binary form must reproduce the above copyright
++// notice, this list of conditions and the following disclaimer in the
++// documentation and/or other materials provided with the distribution.
++// 3. The name of the author may not be used to endorse or promote products
++// derived from this software without specific prior written permission.
++//
++// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++#ifndef _RSPParser_H
++#define _RSPParser_H
++/* =============================================================================
++ * Standard antlr3 C runtime definitions
++ */
++#include <antlr3.h>
++
++/* End of standard antlr 3 runtime definitions
++ * =============================================================================
++ */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// Forward declare the context typedef so that we can use it before it is
++// properly defined. Delegators and delegates (from import statements) are
++// interdependent and their context structures contain pointers to each other
++// C only allows such things to be declared if you pre-declare the typedef.
++//
++typedef struct RSPParser_Ctx_struct RSPParser, * pRSPParser;
++
++
++
++#ifdef ANTLR3_WINDOWS
++// Disable: Unreferenced parameter, - Rules with parameters that are not used
++// constant conditional, - ANTLR realizes that a prediction is always true (synpred usually)
++// initialized but unused variable - tree rewrite variables declared but not needed
++// Unreferenced local variable - lexer rule declares but does not always use _type
++// potentially unitialized variable used - retval always returned from a rule
++// unreferenced local function has been removed - susually getTokenNames or freeScope, they can go without warnigns
++//
++// These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
++// and the codegen must generate some of these warnings by necessity, apart from 4100, which is
++// usually generated when a parser rule is given a parameter that it does not use. Mostly though
++// this is a matter of orthogonality hence I disable that one.
++//
++#pragma warning( disable : 4100 )
++#pragma warning( disable : 4101 )
++#pragma warning( disable : 4127 )
++#pragma warning( disable : 4189 )
++#pragma warning( disable : 4505 )
++#pragma warning( disable : 4701 )
++#endif
++typedef struct RSPParser_query_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_query_return;
++
++typedef struct RSPParser_expr_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_expr_return;
++
++typedef struct RSPParser_aexpr_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_aexpr_return;
++
++typedef struct RSPParser_crit_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_crit_return;
++
++typedef struct RSPParser_strcrit_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_strcrit_return;
++
++typedef struct RSPParser_strop_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_strop_return;
++
++typedef struct RSPParser_intcrit_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_intcrit_return;
++
++typedef struct RSPParser_intop_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_intop_return;
++
++typedef struct RSPParser_datecrit_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_datecrit_return;
++
++typedef struct RSPParser_dateop_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_dateop_return;
++
++typedef struct RSPParser_datespec_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_datespec_return;
++
++typedef struct RSPParser_dateref_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_dateref_return;
++
++typedef struct RSPParser_dateintval_return_struct
++{
++ /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
++ */
++ pANTLR3_COMMON_TOKEN start;
++ pANTLR3_COMMON_TOKEN stop;
++ pANTLR3_BASE_TREE tree;
++
++}
++ RSPParser_dateintval_return;
++
++
++
++/** Context tracking structure for RSPParser
++ */
++struct RSPParser_Ctx_struct
++{
++ /** Built in ANTLR3 context tracker contains all the generic elements
++ * required for context tracking.
++ */
++ pANTLR3_PARSER pParser;
++
++
++ RSPParser_query_return (*query) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_expr_return (*expr) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_aexpr_return (*aexpr) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_crit_return (*crit) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_strcrit_return (*strcrit) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_strop_return (*strop) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_intcrit_return (*intcrit) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_intop_return (*intop) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_datecrit_return (*datecrit) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_dateop_return (*dateop) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_datespec_return (*datespec) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_dateref_return (*dateref) (struct RSPParser_Ctx_struct * ctx);
++ RSPParser_dateintval_return (*dateintval) (struct RSPParser_Ctx_struct * ctx);
++ // Delegated rules
++ const char * (*getGrammarFileName)();
++ void (*free) (struct RSPParser_Ctx_struct * ctx);
++ /* @headerFile.members() */
++ pANTLR3_BASE_TREE_ADAPTOR adaptor;
++ pANTLR3_VECTOR_FACTORY vectors;
++ /* End @headerFile.members() */
++};
++
++// Function protoypes for the constructor functions that external translation units
++// such as delegators and delegates may wish to call.
++//
++ANTLR3_API pRSPParser RSPParserNew (pANTLR3_COMMON_TOKEN_STREAM instream);
++ANTLR3_API pRSPParser RSPParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
++
++/** Symbolic definitions of all the tokens that the parser will work with.
++ * \{
++ *
++ * Antlr will define EOF, but we can't use that as it it is too common in
++ * in C header files and that would be confusing. There is no way to filter this out at the moment
++ * so we just undef it here for now. That isn't the value we get back from C recognizers
++ * anyway. We are looking for ANTLR3_TOKEN_EOF.
++ */
++#ifdef EOF
++#undef EOF
++#endif
++#ifdef Tokens
++#undef Tokens
++#endif
++#define STARTSW 14
++#define WEEK 26
++#define TODAY 24
++#define YEAR 28
++#define ENDSW 15
++#define GTE 20
++#define BEFORE 21
++#define DAY 25
++#define INT 16
++#define NOT 11
++#define AFTER 22
++#define AND 6
++#define EOF -1
++#define LTE 19
++#define MONTH 27
++#define DIGIT19 31
++#define INCLUDES 13
++#define STR 10
++#define QUOTE 29
++#define WS 30
++#define GREATER 18
++#define NEWLINE 4
++#define LPAR 7
++#define EQUAL 12
++#define OR 5
++#define LESS 17
++#define RPAR 8
++#define FIELD 9
++#define ESCAPED 33
++#define DATE 23
++#define DIGIT09 32
++#ifdef EOF
++#undef EOF
++#define EOF ANTLR3_TOKEN_EOF
++#endif
++
++#ifndef TOKENSOURCE
++#define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
++#endif
++
++/* End of token definitions for RSPParser
++ * =============================================================================
++ */
++/** \} */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++/* END - Note:Keep extra line feed to satisfy UNIX systems */