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 +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 ++ #include ++ #include ++ #include ++ #include ++ ++ #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) "", /* String to print to indicate an invalid token */ ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (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 ++ ++/* 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 ++ #include ++ #include ++ #include ++ #include ++ ++ #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 ++ ++/* 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) "", /* String to print to indicate an invalid token */ ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (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 ++ ++/* 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 ++ #include ++ #include ++ #include ++ ++ #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) "", /* String to print to indicate an invalid token */ ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (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 ++ ++/* 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 ++ #include ++ #include ++ #include ++ ++ #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 ++ ++/* 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) "", /* String to print to indicate an invalid token */ ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (pANTLR3_UINT8) "", ++ (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 ++ ++/* 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 */