VaeQueryLanguageTreeParser.c

/** \file
 *  This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23
 *
 *     -  From the grammar source file : VaeQueryLanguageTreeParser.g
 *     -                            On : 2016-03-04 14:33:13
 *     -           for the tree parser : VaeQueryLanguageTreeParserTreeParser *
 * 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 "vaeql.h"
#define FUNCTION_ARG_LIST_SIZE 25

/* End of Header action.
 * =============================================================================
 */
/* -----------------------------------------
 * Include the ANTLR3 generated header file.
 */
#include    "VaeQueryLanguageTreeParser.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)   pVaeQueryLanguageTreeParser_##scope##_SCOPE
#define SCOPE_STACK(scope)  pVaeQueryLanguageTreeParser_##scope##Stack
#define	SCOPE_TOP(scope)    ctx->pVaeQueryLanguageTreeParser_##scope##Top
#define	SCOPE_SIZE(scope)		ctx->pVaeQueryLanguageTreeParser_##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   VaeQueryLanguageTreeParserTokenNames[59+4]
     = {
        (pANTLR3_UINT8) "<invalid>",       /* String to print to indicate an invalid token */
        (pANTLR3_UINT8) "<EOR>",
        (pANTLR3_UINT8) "<DOWN>", 
        (pANTLR3_UINT8) "<UP>", 
        (pANTLR3_UINT8) "NODE_ABSOLUTE",
        (pANTLR3_UINT8) "NODE_FUNCTION",
        (pANTLR3_UINT8) "NODE_IF",
        (pANTLR3_UINT8) "NODE_PARENEXPR",
        (pANTLR3_UINT8) "NODE_PATH",
        (pANTLR3_UINT8) "NODE_PATHREF",
        (pANTLR3_UINT8) "NODE_PREDICATE",
        (pANTLR3_UINT8) "NODE_SQL",
        (pANTLR3_UINT8) "NODE_STAR",
        (pANTLR3_UINT8) "NODE_VALUE",
        (pANTLR3_UINT8) "NODE_XPATHFUNCTION",
        (pANTLR3_UINT8) "SPECIAL_NEXT",
        (pANTLR3_UINT8) "SPECIAL_PREV",
        (pANTLR3_UINT8) "DIV",
        (pANTLR3_UINT8) "MULT",
        (pANTLR3_UINT8) "SLASH",
        (pANTLR3_UINT8) "STAR",
        (pANTLR3_UINT8) "SQL",
        (pANTLR3_UINT8) "AT",
        (pANTLR3_UINT8) "XPATH_AXIS_SEP",
        (pANTLR3_UINT8) "EQUALITY",
        (pANTLR3_UINT8) "EQUALITY_ALT",
        (pANTLR3_UINT8) "INEQUALITY",
        (pANTLR3_UINT8) "INEQUALITY_ALT",
        (pANTLR3_UINT8) "LESS",
        (pANTLR3_UINT8) "LTE",
        (pANTLR3_UINT8) "GREATER",
        (pANTLR3_UINT8) "GTE",
        (pANTLR3_UINT8) "AND",
        (pANTLR3_UINT8) "OR",
        (pANTLR3_UINT8) "XOR",
        (pANTLR3_UINT8) "NOT",
        (pANTLR3_UINT8) "ADD_TOK",
        (pANTLR3_UINT8) "SUB",
        (pANTLR3_UINT8) "MOD",
        (pANTLR3_UINT8) "PIPE",
        (pANTLR3_UINT8) "IFTRUE",
        (pANTLR3_UINT8) "COLON",
        (pANTLR3_UINT8) "PATHREF",
        (pANTLR3_UINT8) "LBRACKET",
        (pANTLR3_UINT8) "RBRACKET",
        (pANTLR3_UINT8) "LPAREN",
        (pANTLR3_UINT8) "RPAREN",
        (pANTLR3_UINT8) "COMMA",
        (pANTLR3_UINT8) "FUNCTION",
        (pANTLR3_UINT8) "PERMALINK",
        (pANTLR3_UINT8) "INT",
        (pANTLR3_UINT8) "NAME",
        (pANTLR3_UINT8) "DOT_STEP",
        (pANTLR3_UINT8) "XPATH_AXES",
        (pANTLR3_UINT8) "XPATH_FUNCTION",
        (pANTLR3_UINT8) "AND_ALT",
        (pANTLR3_UINT8) "OR_ALT",
        (pANTLR3_UINT8) "XOR_ALT",
        (pANTLR3_UINT8) "STRING",
        (pANTLR3_UINT8) "FLOAT",
        (pANTLR3_UINT8) "VARIABLE",
        (pANTLR3_UINT8) "ESC_SEQ",
        (pANTLR3_UINT8) "WS"
       };

        

// Forward declare the locally static matching functions we have generated.
//
static VaeQueryLanguageTreeParser_start_return	start    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	at    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_expr_return	expr    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	evaledExpr    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	function    (pVaeQueryLanguageTreeParser ctx);
static void	expressionList    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_oper_return	oper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	path    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	piper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicate    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateExpr    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateOper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicatePath    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateEqualityOper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateInequalityOper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateAndOper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateOrOper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateComparisonOper    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	predicateRangeOper    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_rangeFunction_return	rangeFunction    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_rootExpr_return	rootExpr    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_rootPath_return	rootPath    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	slash    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_value_return	value    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	variable    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	xpathExpr    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	xpathFunction    (pVaeQueryLanguageTreeParser ctx);
static pANTLR3_STRING	xpathFunctionExpression    (pVaeQueryLanguageTreeParser ctx);
static void	andOper    (pVaeQueryLanguageTreeParser ctx);
static void	orOper    (pVaeQueryLanguageTreeParser ctx);
static void	equalityOper    (pVaeQueryLanguageTreeParser ctx);
static void	inequalityOper    (pVaeQueryLanguageTreeParser ctx);
static VaeQueryLanguageTreeParser_comparisonOper_return	comparisonOper    (pVaeQueryLanguageTreeParser ctx);
static void	VaeQueryLanguageTreeParserFree(pVaeQueryLanguageTreeParser 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[] = "VaeQueryLanguageTreeParser.g";

/** \brief Return the name of the grammar file that generated this code.
 */
static const char * getGrammarFileName()
{
	return fileName;
}
/** \brief Create a new VaeQueryLanguageTreeParser 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 pVaeQueryLanguageTreeParser
VaeQueryLanguageTreeParserNew   (pANTLR3_COMMON_TREE_NODE_STREAM instream)
{
	// See if we can create a new parser with the standard constructor
	//
	return VaeQueryLanguageTreeParserNewSSD(instream, NULL);
}

/** \brief Create a new VaeQueryLanguageTreeParser 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 pVaeQueryLanguageTreeParser
VaeQueryLanguageTreeParserNewSSD   (pANTLR3_COMMON_TREE_NODE_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
{
    pVaeQueryLanguageTreeParser ctx;	    /* Context structure we will build and return   */
    
    ctx	= (pVaeQueryLanguageTreeParser) ANTLR3_CALLOC(1, sizeof(VaeQueryLanguageTreeParser));
    
    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 VaeQueryLanguageTreeParser.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 VaeQueryLanguageTreeParser interface
     */
    ctx->start	= start;
    ctx->at	= at;
    ctx->expr	= expr;
    ctx->evaledExpr	= evaledExpr;
    ctx->function	= function;
    ctx->expressionList	= expressionList;
    ctx->oper	= oper;
    ctx->path	= path;
    ctx->piper	= piper;
    ctx->predicate	= predicate;
    ctx->predicateExpr	= predicateExpr;
    ctx->predicateOper	= predicateOper;
    ctx->predicatePath	= predicatePath;
    ctx->predicateEqualityOper	= predicateEqualityOper;
    ctx->predicateInequalityOper	= predicateInequalityOper;
    ctx->predicateAndOper	= predicateAndOper;
    ctx->predicateOrOper	= predicateOrOper;
    ctx->predicateComparisonOper	= predicateComparisonOper;
    ctx->predicateRangeOper	= predicateRangeOper;
    ctx->rangeFunction	= rangeFunction;
    ctx->rootExpr	= rootExpr;
    ctx->rootPath	= rootPath;
    ctx->slash	= slash;
    ctx->value	= value;
    ctx->variable	= variable;
    ctx->xpathExpr	= xpathExpr;
    ctx->xpathFunction	= xpathFunction;
    ctx->xpathFunctionExpression	= xpathFunctionExpression;
    ctx->andOper	= andOper;
    ctx->orOper	= orOper;
    ctx->equalityOper	= equalityOper;
    ctx->inequalityOper	= inequalityOper;
    ctx->comparisonOper	= comparisonOper;
    ctx->free			= VaeQueryLanguageTreeParserFree;
    ctx->getGrammarFileName	= getGrammarFileName;
    
    /* Install the scope pushing methods.
     */

        
    

	
    /* Install the token table
     */
    PSRSTATE->tokenNames   = VaeQueryLanguageTreeParserTokenNames;
    
    
    /* Return the newly built parser to the caller
     */
    return  ctx;
}

/** Free the parser resources
 */
 static void
 VaeQueryLanguageTreeParserFree(pVaeQueryLanguageTreeParser 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 VaeQueryLanguageTreeParserTokenNames; 
}



      char *functionArgList[FUNCTION_ARG_LIST_SIZE+1];
      char functionArgCount;

      int asBoolean(pANTLR3_STRING a) {
        double dummy;
        if (!strlen(a->chars)) {
          return 0;
        }
        if (sscanf(a->chars, "%lf", &dummy)) {
          return (dummy != 0);
        }
        return strcmp(a->chars, "");
      }
      
      int asInt(pANTLR3_STRING a) {
        return atoi(a->chars);
      }
      
      double asNumber(pANTLR3_STRING a) {
        return strtod(a->chars, NULL);
      }

      int bothNumbers(pANTLR3_STRING a, pANTLR3_STRING b) {
        double dummy;
        return (sscanf(a->chars, "%lf", &dummy) && sscanf(b->chars, "%lf", &dummy));
      }

      char *replace_str(char *str, char *orig, char *rep) {
        static char buffer[1024];
        char buffer2[1024];
        char *p, *b = buffer, *b2 = buffer2;
        strncpy(buffer, str, 1023);
        do {
          if(!(p = strstr(b, orig))) {
            return buffer;
          }
          strncpy(buffer2, buffer, 1023);
          sprintf(p, "%s%s", rep, b2+(p-buffer)+strlen(orig));
          b += (p-buffer)+strlen(rep);
        } while (1);
      }
      
      pANTLR3_STRING booleanResponse(int t, pANTLR3_BASE_TREE e) {
        if (t) {
          return e->strFactory->newStr(e->strFactory, "1");
        } else {
          return e->strFactory->newStr(e->strFactory, "0");
        }
      }
      
      pANTLR3_STRING escapeApos(pANTLR3_STRING e) {
        if (strstr(e->chars, "'")) {
          e->set8(e, replace_str(replace_str(e->chars, "&#039;", "'"), "'", "',\"'\",'"));
    	    e->insert8(e, 0, "concat('");
    	    e->append8(e, "')");
        } else {
    	    e->insert8(e, 0, "'");
    	    e->append8(e, "'");
    	  }
    	}
      
      pANTLR3_STRING predicateResult(pANTLR3_STRING p1, pANTLR3_STRING p2, char *sym) {
        if (!strlen(p1->chars)) {
          return p1;
        } else if (!strlen(p2->chars)) {
          return p2;
        } else {
          p1->append8(p1, sym);
          p1->appendS(p1, p2);
          return p1;
        }
      }
      
      pANTLR3_STRING newStr(pANTLR3_BASE_TREE e, char *c) {
        return e->strFactory->newStr(e->strFactory, c);
      }
      
      pANTLR3_STRING numberResponse(double t, pANTLR3_BASE_TREE e) {
        char buf[30];
        sprintf(buf, "%lg", t);
        return e->strFactory->newStr(e->strFactory, buf);
      }

      pANTLR3_STRING longResponse(long t, pANTLR3_BASE_TREE e) {
        char buf[30];
        sprintf(buf, "%ld", t);
        return e->strFactory->newStr(e->strFactory, buf);
      }


    
/* Declare the bitsets
 */

/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_start62  */
static	ANTLR3_BITWORD FOLLOW_expr_in_start62_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000000) };
static  ANTLR3_BITSET_LIST FOLLOW_expr_in_start62	= { FOLLOW_expr_in_start62_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EOF_in_start64  */
static	ANTLR3_BITWORD FOLLOW_EOF_in_start64_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_EOF_in_start64	= { FOLLOW_EOF_in_start64_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_AT_in_at90  */
static	ANTLR3_BITWORD FOLLOW_AT_in_at90_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_AT_in_at90	= { FOLLOW_AT_in_at90_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_at94  */
static	ANTLR3_BITWORD FOLLOW_path_in_at94_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_at94	= { FOLLOW_path_in_at94_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_XPATH_AXIS_SEP_in_at108  */
static	ANTLR3_BITWORD FOLLOW_XPATH_AXIS_SEP_in_at108_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_XPATH_AXIS_SEP_in_at108	= { FOLLOW_XPATH_AXIS_SEP_in_at108_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_XPATH_AXES_in_at110  */
static	ANTLR3_BITWORD FOLLOW_XPATH_AXES_in_at110_bits[]	= { ANTLR3_UINT64_LIT(0x001E008000D9A430) };
static  ANTLR3_BITSET_LIST FOLLOW_XPATH_AXES_in_at110	= { FOLLOW_XPATH_AXES_in_at110_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_at114  */
static	ANTLR3_BITWORD FOLLOW_path_in_at114_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_at114	= { FOLLOW_path_in_at114_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rootExpr_in_expr140  */
static	ANTLR3_BITWORD FOLLOW_rootExpr_in_expr140_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rootExpr_in_expr140	= { FOLLOW_rootExpr_in_expr140_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rootPath_in_expr151  */
static	ANTLR3_BITWORD FOLLOW_rootPath_in_expr151_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_rootPath_in_expr151	= { FOLLOW_rootPath_in_expr151_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_evaledExpr173  */
static	ANTLR3_BITWORD FOLLOW_expr_in_evaledExpr173_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_expr_in_evaledExpr173	= { FOLLOW_expr_in_evaledExpr173_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_FUNCTION_in_function197  */
static	ANTLR3_BITWORD FOLLOW_NODE_FUNCTION_in_function197_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_FUNCTION_in_function197	= { FOLLOW_NODE_FUNCTION_in_function197_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_FUNCTION_in_function199  */
static	ANTLR3_BITWORD FOLLOW_FUNCTION_in_function199_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD38) };
static  ANTLR3_BITSET_LIST FOLLOW_FUNCTION_in_function199	= { FOLLOW_FUNCTION_in_function199_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expressionList_in_function214  */
static	ANTLR3_BITWORD FOLLOW_expressionList_in_function214_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_expressionList_in_function214	= { FOLLOW_expressionList_in_function214_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COMMA_in_expressionList238  */
static	ANTLR3_BITWORD FOLLOW_COMMA_in_expressionList238_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_COMMA_in_expressionList238	= { FOLLOW_COMMA_in_expressionList238_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expressionList_in_expressionList240  */
static	ANTLR3_BITWORD FOLLOW_expressionList_in_expressionList240_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_expressionList_in_expressionList240	= { FOLLOW_expressionList_in_expressionList240_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expressionList_in_expressionList242  */
static	ANTLR3_BITWORD FOLLOW_expressionList_in_expressionList242_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_expressionList_in_expressionList242	= { FOLLOW_expressionList_in_expressionList242_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_expressionList250  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_expressionList250_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_expressionList250	= { FOLLOW_evaledExpr_in_expressionList250_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_IFTRUE_in_oper277  */
static	ANTLR3_BITWORD FOLLOW_IFTRUE_in_oper277_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_IFTRUE_in_oper277	= { FOLLOW_IFTRUE_in_oper277_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper281  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper281_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper281	= { FOLLOW_evaledExpr_in_oper281_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_oper285  */
static	ANTLR3_BITWORD FOLLOW_expr_in_oper285_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_expr_in_oper285	= { FOLLOW_expr_in_oper285_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_oper289  */
static	ANTLR3_BITWORD FOLLOW_expr_in_oper289_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_expr_in_oper289	= { FOLLOW_expr_in_oper289_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUALITY_in_oper305  */
static	ANTLR3_BITWORD FOLLOW_EQUALITY_in_oper305_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUALITY_in_oper305	= { FOLLOW_EQUALITY_in_oper305_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_EQUALITY_ALT_in_oper311  */
static	ANTLR3_BITWORD FOLLOW_EQUALITY_ALT_in_oper311_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_EQUALITY_ALT_in_oper311	= { FOLLOW_EQUALITY_ALT_in_oper311_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper316  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper316_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper316	= { FOLLOW_evaledExpr_in_oper316_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper320  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper320_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper320	= { FOLLOW_evaledExpr_in_oper320_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_INEQUALITY_in_oper336  */
static	ANTLR3_BITWORD FOLLOW_INEQUALITY_in_oper336_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_INEQUALITY_in_oper336	= { FOLLOW_INEQUALITY_in_oper336_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_INEQUALITY_ALT_in_oper342  */
static	ANTLR3_BITWORD FOLLOW_INEQUALITY_ALT_in_oper342_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_INEQUALITY_ALT_in_oper342	= { FOLLOW_INEQUALITY_ALT_in_oper342_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper347  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper347_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper347	= { FOLLOW_evaledExpr_in_oper347_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper351  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper351_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper351	= { FOLLOW_evaledExpr_in_oper351_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LESS_in_oper366  */
static	ANTLR3_BITWORD FOLLOW_LESS_in_oper366_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_LESS_in_oper366	= { FOLLOW_LESS_in_oper366_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper370  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper370_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper370	= { FOLLOW_evaledExpr_in_oper370_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper374  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper374_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper374	= { FOLLOW_evaledExpr_in_oper374_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_LTE_in_oper389  */
static	ANTLR3_BITWORD FOLLOW_LTE_in_oper389_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_LTE_in_oper389	= { FOLLOW_LTE_in_oper389_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper393  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper393_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper393	= { FOLLOW_evaledExpr_in_oper393_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper397  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper397_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper397	= { FOLLOW_evaledExpr_in_oper397_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_in_oper412  */
static	ANTLR3_BITWORD FOLLOW_GREATER_in_oper412_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_GREATER_in_oper412	= { FOLLOW_GREATER_in_oper412_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper416  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper416_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper416	= { FOLLOW_evaledExpr_in_oper416_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper420  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper420_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper420	= { FOLLOW_evaledExpr_in_oper420_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_GTE_in_oper435  */
static	ANTLR3_BITWORD FOLLOW_GTE_in_oper435_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_GTE_in_oper435	= { FOLLOW_GTE_in_oper435_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper439  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper439_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper439	= { FOLLOW_evaledExpr_in_oper439_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper443  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper443_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper443	= { FOLLOW_evaledExpr_in_oper443_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_in_oper459  */
static	ANTLR3_BITWORD FOLLOW_AND_in_oper459_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_AND_in_oper459	= { FOLLOW_AND_in_oper459_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_AND_ALT_in_oper465  */
static	ANTLR3_BITWORD FOLLOW_AND_ALT_in_oper465_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_AND_ALT_in_oper465	= { FOLLOW_AND_ALT_in_oper465_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper470  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper470_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper470	= { FOLLOW_evaledExpr_in_oper470_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper474  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper474_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper474	= { FOLLOW_evaledExpr_in_oper474_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_in_oper490  */
static	ANTLR3_BITWORD FOLLOW_OR_in_oper490_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_OR_in_oper490	= { FOLLOW_OR_in_oper490_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_OR_ALT_in_oper496  */
static	ANTLR3_BITWORD FOLLOW_OR_ALT_in_oper496_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_OR_ALT_in_oper496	= { FOLLOW_OR_ALT_in_oper496_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper501  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper501_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper501	= { FOLLOW_evaledExpr_in_oper501_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper505  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper505_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper505	= { FOLLOW_evaledExpr_in_oper505_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_XOR_in_oper521  */
static	ANTLR3_BITWORD FOLLOW_XOR_in_oper521_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_XOR_in_oper521	= { FOLLOW_XOR_in_oper521_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_XOR_ALT_in_oper527  */
static	ANTLR3_BITWORD FOLLOW_XOR_ALT_in_oper527_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_XOR_ALT_in_oper527	= { FOLLOW_XOR_ALT_in_oper527_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper532  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper532_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper532	= { FOLLOW_evaledExpr_in_oper532_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper536  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper536_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper536	= { FOLLOW_evaledExpr_in_oper536_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_ADD_TOK_in_oper551  */
static	ANTLR3_BITWORD FOLLOW_ADD_TOK_in_oper551_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_ADD_TOK_in_oper551	= { FOLLOW_ADD_TOK_in_oper551_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper555  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper555_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper555	= { FOLLOW_evaledExpr_in_oper555_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper559  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper559_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper559	= { FOLLOW_evaledExpr_in_oper559_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SUB_in_oper574  */
static	ANTLR3_BITWORD FOLLOW_SUB_in_oper574_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_SUB_in_oper574	= { FOLLOW_SUB_in_oper574_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper578  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper578_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper578	= { FOLLOW_evaledExpr_in_oper578_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper582  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper582_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper582	= { FOLLOW_evaledExpr_in_oper582_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_MULT_in_oper597  */
static	ANTLR3_BITWORD FOLLOW_MULT_in_oper597_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_MULT_in_oper597	= { FOLLOW_MULT_in_oper597_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper601  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper601_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper601	= { FOLLOW_evaledExpr_in_oper601_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper605  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper605_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper605	= { FOLLOW_evaledExpr_in_oper605_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DIV_in_oper620  */
static	ANTLR3_BITWORD FOLLOW_DIV_in_oper620_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_DIV_in_oper620	= { FOLLOW_DIV_in_oper620_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper624  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper624_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper624	= { FOLLOW_evaledExpr_in_oper624_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper628  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper628_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper628	= { FOLLOW_evaledExpr_in_oper628_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_MOD_in_oper643  */
static	ANTLR3_BITWORD FOLLOW_MOD_in_oper643_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_MOD_in_oper643	= { FOLLOW_MOD_in_oper643_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper647  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper647_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD30) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper647	= { FOLLOW_evaledExpr_in_oper647_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper651  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper651_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper651	= { FOLLOW_evaledExpr_in_oper651_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NOT_in_oper667  */
static	ANTLR3_BITWORD FOLLOW_NOT_in_oper667_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NOT_in_oper667	= { FOLLOW_NOT_in_oper667_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_oper671  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_oper671_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_oper671	= { FOLLOW_evaledExpr_in_oper671_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_slash_in_path696  */
static	ANTLR3_BITWORD FOLLOW_slash_in_path696_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_slash_in_path696	= { FOLLOW_slash_in_path696_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_at_in_path708  */
static	ANTLR3_BITWORD FOLLOW_at_in_path708_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_at_in_path708	= { FOLLOW_at_in_path708_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_piper_in_path720  */
static	ANTLR3_BITWORD FOLLOW_piper_in_path720_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_piper_in_path720	= { FOLLOW_piper_in_path720_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_PREDICATE_in_path733  */
static	ANTLR3_BITWORD FOLLOW_NODE_PREDICATE_in_path733_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_PREDICATE_in_path733	= { FOLLOW_NODE_PREDICATE_in_path733_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicate_in_path735  */
static	ANTLR3_BITWORD FOLLOW_predicate_in_path735_bits[]	= { ANTLR3_UINT64_LIT(0x001E008000D9A430) };
static  ANTLR3_BITSET_LIST FOLLOW_predicate_in_path735	= { FOLLOW_predicate_in_path735_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_path739  */
static	ANTLR3_BITWORD FOLLOW_path_in_path739_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_path739	= { FOLLOW_path_in_path739_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_path752  */
static	ANTLR3_BITWORD FOLLOW_INT_in_path752_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_INT_in_path752	= { FOLLOW_INT_in_path752_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NAME_in_path764  */
static	ANTLR3_BITWORD FOLLOW_NAME_in_path764_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_NAME_in_path764	= { FOLLOW_NAME_in_path764_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_STAR_in_path776  */
static	ANTLR3_BITWORD FOLLOW_STAR_in_path776_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_STAR_in_path776	= { FOLLOW_STAR_in_path776_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_DOT_STEP_in_path788  */
static	ANTLR3_BITWORD FOLLOW_DOT_STEP_in_path788_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_DOT_STEP_in_path788	= { FOLLOW_DOT_STEP_in_path788_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_PERMALINK_in_path800  */
static	ANTLR3_BITWORD FOLLOW_PERMALINK_in_path800_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_PERMALINK_in_path800	= { FOLLOW_PERMALINK_in_path800_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPECIAL_NEXT_in_path812  */
static	ANTLR3_BITWORD FOLLOW_SPECIAL_NEXT_in_path812_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_SPECIAL_NEXT_in_path812	= { FOLLOW_SPECIAL_NEXT_in_path812_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SPECIAL_PREV_in_path824  */
static	ANTLR3_BITWORD FOLLOW_SPECIAL_PREV_in_path824_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_SPECIAL_PREV_in_path824	= { FOLLOW_SPECIAL_PREV_in_path824_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_variable_in_path836  */
static	ANTLR3_BITWORD FOLLOW_variable_in_path836_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_variable_in_path836	= { FOLLOW_variable_in_path836_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_function_in_path848  */
static	ANTLR3_BITWORD FOLLOW_function_in_path848_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_function_in_path848	= { FOLLOW_function_in_path848_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_PIPE_in_piper876  */
static	ANTLR3_BITWORD FOLLOW_PIPE_in_piper876_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_PIPE_in_piper876	= { FOLLOW_PIPE_in_piper876_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_piper880  */
static	ANTLR3_BITWORD FOLLOW_path_in_piper880_bits[]	= { ANTLR3_UINT64_LIT(0x001E008000D9A430) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_piper880	= { FOLLOW_path_in_piper880_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_piper884  */
static	ANTLR3_BITWORD FOLLOW_path_in_piper884_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_piper884	= { FOLLOW_path_in_piper884_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_predicate908  */
static	ANTLR3_BITWORD FOLLOW_INT_in_predicate908_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_INT_in_predicate908	= { FOLLOW_INT_in_predicate908_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateOper_in_predicate920  */
static	ANTLR3_BITWORD FOLLOW_predicateOper_in_predicate920_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateOper_in_predicate920	= { FOLLOW_predicateOper_in_predicate920_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicatePath_in_predicateExpr945  */
static	ANTLR3_BITWORD FOLLOW_predicatePath_in_predicateExpr945_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicatePath_in_predicateExpr945	= { FOLLOW_predicatePath_in_predicateExpr945_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_xpathFunction_in_predicateExpr957  */
static	ANTLR3_BITWORD FOLLOW_xpathFunction_in_predicateExpr957_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_xpathFunction_in_predicateExpr957	= { FOLLOW_xpathFunction_in_predicateExpr957_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_predicateExpr968  */
static	ANTLR3_BITWORD FOLLOW_value_in_predicateExpr968_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_value_in_predicateExpr968	= { FOLLOW_value_in_predicateExpr968_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateOper_in_predicateExpr979  */
static	ANTLR3_BITWORD FOLLOW_predicateOper_in_predicateExpr979_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateOper_in_predicateExpr979	= { FOLLOW_predicateOper_in_predicateExpr979_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateEqualityOper_in_predicateOper1004  */
static	ANTLR3_BITWORD FOLLOW_predicateEqualityOper_in_predicateOper1004_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateEqualityOper_in_predicateOper1004	= { FOLLOW_predicateEqualityOper_in_predicateOper1004_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateInequalityOper_in_predicateOper1016  */
static	ANTLR3_BITWORD FOLLOW_predicateInequalityOper_in_predicateOper1016_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateInequalityOper_in_predicateOper1016	= { FOLLOW_predicateInequalityOper_in_predicateOper1016_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateAndOper_in_predicateOper1028  */
static	ANTLR3_BITWORD FOLLOW_predicateAndOper_in_predicateOper1028_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateAndOper_in_predicateOper1028	= { FOLLOW_predicateAndOper_in_predicateOper1028_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateOrOper_in_predicateOper1040  */
static	ANTLR3_BITWORD FOLLOW_predicateOrOper_in_predicateOper1040_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateOrOper_in_predicateOper1040	= { FOLLOW_predicateOrOper_in_predicateOper1040_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateComparisonOper_in_predicateOper1052  */
static	ANTLR3_BITWORD FOLLOW_predicateComparisonOper_in_predicateOper1052_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateComparisonOper_in_predicateOper1052	= { FOLLOW_predicateComparisonOper_in_predicateOper1052_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateRangeOper_in_predicateOper1064  */
static	ANTLR3_BITWORD FOLLOW_predicateRangeOper_in_predicateOper1064_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateRangeOper_in_predicateOper1064	= { FOLLOW_predicateRangeOper_in_predicateOper1064_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_slash_in_predicatePath1087  */
static	ANTLR3_BITWORD FOLLOW_slash_in_predicatePath1087_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_slash_in_predicatePath1087	= { FOLLOW_slash_in_predicatePath1087_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_AT_in_predicatePath1100  */
static	ANTLR3_BITWORD FOLLOW_AT_in_predicatePath1100_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_AT_in_predicatePath1100	= { FOLLOW_AT_in_predicatePath1100_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicatePath_in_predicatePath1104  */
static	ANTLR3_BITWORD FOLLOW_predicatePath_in_predicatePath1104_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicatePath_in_predicatePath1104	= { FOLLOW_predicatePath_in_predicatePath1104_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_PATHREF_in_predicatePath1118  */
static	ANTLR3_BITWORD FOLLOW_NODE_PATHREF_in_predicatePath1118_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_PATHREF_in_predicatePath1118	= { FOLLOW_NODE_PATHREF_in_predicatePath1118_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_evaledExpr_in_predicatePath1120  */
static	ANTLR3_BITWORD FOLLOW_evaledExpr_in_predicatePath1120_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_evaledExpr_in_predicatePath1120	= { FOLLOW_evaledExpr_in_predicatePath1120_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NAME_in_predicatePath1133  */
static	ANTLR3_BITWORD FOLLOW_NAME_in_predicatePath1133_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_NAME_in_predicatePath1133	= { FOLLOW_NAME_in_predicatePath1133_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_equalityOper_in_predicateEqualityOper1159  */
static	ANTLR3_BITWORD FOLLOW_equalityOper_in_predicateEqualityOper1159_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_equalityOper_in_predicateEqualityOper1159	= { FOLLOW_equalityOper_in_predicateEqualityOper1159_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateEqualityOper1163  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateEqualityOper1163_bits[]	= { ANTLR3_UINT64_LIT(0x039E03FFFFDFE630) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateEqualityOper1163	= { FOLLOW_predicateExpr_in_predicateEqualityOper1163_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateEqualityOper1167  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateEqualityOper1167_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateEqualityOper1167	= { FOLLOW_predicateExpr_in_predicateEqualityOper1167_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_inequalityOper_in_predicateInequalityOper1191  */
static	ANTLR3_BITWORD FOLLOW_inequalityOper_in_predicateInequalityOper1191_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_inequalityOper_in_predicateInequalityOper1191	= { FOLLOW_inequalityOper_in_predicateInequalityOper1191_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateInequalityOper1195  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateInequalityOper1195_bits[]	= { ANTLR3_UINT64_LIT(0x039E03FFFFDFE630) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateInequalityOper1195	= { FOLLOW_predicateExpr_in_predicateInequalityOper1195_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateInequalityOper1199  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateInequalityOper1199_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateInequalityOper1199	= { FOLLOW_predicateExpr_in_predicateInequalityOper1199_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_andOper_in_predicateAndOper1223  */
static	ANTLR3_BITWORD FOLLOW_andOper_in_predicateAndOper1223_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_andOper_in_predicateAndOper1223	= { FOLLOW_andOper_in_predicateAndOper1223_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateAndOper1227  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateAndOper1227_bits[]	= { ANTLR3_UINT64_LIT(0x039E03FFFFDFE630) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateAndOper1227	= { FOLLOW_predicateExpr_in_predicateAndOper1227_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateAndOper1231  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateAndOper1231_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateAndOper1231	= { FOLLOW_predicateExpr_in_predicateAndOper1231_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_orOper_in_predicateOrOper1255  */
static	ANTLR3_BITWORD FOLLOW_orOper_in_predicateOrOper1255_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_orOper_in_predicateOrOper1255	= { FOLLOW_orOper_in_predicateOrOper1255_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateOrOper1259  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateOrOper1259_bits[]	= { ANTLR3_UINT64_LIT(0x039E03FFFFDFE630) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateOrOper1259	= { FOLLOW_predicateExpr_in_predicateOrOper1259_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateOrOper1263  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateOrOper1263_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateOrOper1263	= { FOLLOW_predicateExpr_in_predicateOrOper1263_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_comparisonOper_in_predicateComparisonOper1287  */
static	ANTLR3_BITWORD FOLLOW_comparisonOper_in_predicateComparisonOper1287_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_comparisonOper_in_predicateComparisonOper1287	= { FOLLOW_comparisonOper_in_predicateComparisonOper1287_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateComparisonOper1291  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateComparisonOper1291_bits[]	= { ANTLR3_UINT64_LIT(0x039E03FFFFDFE630) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateComparisonOper1291	= { FOLLOW_predicateExpr_in_predicateComparisonOper1291_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateComparisonOper1295  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateComparisonOper1295_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateComparisonOper1295	= { FOLLOW_predicateExpr_in_predicateComparisonOper1295_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COLON_in_predicateRangeOper1319  */
static	ANTLR3_BITWORD FOLLOW_COLON_in_predicateRangeOper1319_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_COLON_in_predicateRangeOper1319	= { FOLLOW_COLON_in_predicateRangeOper1319_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicateExpr_in_predicateRangeOper1323  */
static	ANTLR3_BITWORD FOLLOW_predicateExpr_in_predicateRangeOper1323_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000020) };
static  ANTLR3_BITSET_LIST FOLLOW_predicateExpr_in_predicateRangeOper1323	= { FOLLOW_predicateExpr_in_predicateRangeOper1323_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_rangeFunction_in_predicateRangeOper1327  */
static	ANTLR3_BITWORD FOLLOW_rangeFunction_in_predicateRangeOper1327_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_rangeFunction_in_predicateRangeOper1327	= { FOLLOW_rangeFunction_in_predicateRangeOper1327_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_FUNCTION_in_rangeFunction1350  */
static	ANTLR3_BITWORD FOLLOW_NODE_FUNCTION_in_rangeFunction1350_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_FUNCTION_in_rangeFunction1350	= { FOLLOW_NODE_FUNCTION_in_rangeFunction1350_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_FUNCTION_in_rangeFunction1352  */
static	ANTLR3_BITWORD FOLLOW_FUNCTION_in_rangeFunction1352_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFAD38) };
static  ANTLR3_BITSET_LIST FOLLOW_FUNCTION_in_rangeFunction1352	= { FOLLOW_FUNCTION_in_rangeFunction1352_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_expressionList_in_rangeFunction1367  */
static	ANTLR3_BITWORD FOLLOW_expressionList_in_rangeFunction1367_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_expressionList_in_rangeFunction1367	= { FOLLOW_expressionList_in_rangeFunction1367_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_oper_in_rootExpr1395  */
static	ANTLR3_BITWORD FOLLOW_oper_in_rootExpr1395_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_oper_in_rootExpr1395	= { FOLLOW_oper_in_rootExpr1395_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_rootExpr1407  */
static	ANTLR3_BITWORD FOLLOW_value_in_rootExpr1407_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_value_in_rootExpr1407	= { FOLLOW_value_in_rootExpr1407_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_SQL_in_rootPath1433  */
static	ANTLR3_BITWORD FOLLOW_NODE_SQL_in_rootPath1433_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_SQL_in_rootPath1433	= { FOLLOW_NODE_SQL_in_rootPath1433_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_rootPath1435  */
static	ANTLR3_BITWORD FOLLOW_path_in_rootPath1435_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_rootPath1435	= { FOLLOW_path_in_rootPath1435_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_PATH_in_rootPath1449  */
static	ANTLR3_BITWORD FOLLOW_NODE_PATH_in_rootPath1449_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_PATH_in_rootPath1449	= { FOLLOW_NODE_PATH_in_rootPath1449_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_rootPath1451  */
static	ANTLR3_BITWORD FOLLOW_path_in_rootPath1451_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_rootPath1451	= { FOLLOW_path_in_rootPath1451_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_ABSOLUTE_in_slash1481  */
static	ANTLR3_BITWORD FOLLOW_NODE_ABSOLUTE_in_slash1481_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_ABSOLUTE_in_slash1481	= { FOLLOW_NODE_ABSOLUTE_in_slash1481_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_slash1485  */
static	ANTLR3_BITWORD FOLLOW_path_in_slash1485_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_slash1485	= { FOLLOW_path_in_slash1485_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_SLASH_in_slash1499  */
static	ANTLR3_BITWORD FOLLOW_SLASH_in_slash1499_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_SLASH_in_slash1499	= { FOLLOW_SLASH_in_slash1499_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_slash1503  */
static	ANTLR3_BITWORD FOLLOW_path_in_slash1503_bits[]	= { ANTLR3_UINT64_LIT(0x001E008000D9A430) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_slash1503	= { FOLLOW_path_in_slash1503_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_path_in_slash1507  */
static	ANTLR3_BITWORD FOLLOW_path_in_slash1507_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_path_in_slash1507	= { FOLLOW_path_in_slash1507_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_VALUE_in_value1533  */
static	ANTLR3_BITWORD FOLLOW_NODE_VALUE_in_value1533_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_VALUE_in_value1533	= { FOLLOW_NODE_VALUE_in_value1533_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRING_in_value1535  */
static	ANTLR3_BITWORD FOLLOW_STRING_in_value1535_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_STRING_in_value1535	= { FOLLOW_STRING_in_value1535_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_VALUE_in_value1549  */
static	ANTLR3_BITWORD FOLLOW_NODE_VALUE_in_value1549_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_VALUE_in_value1549	= { FOLLOW_NODE_VALUE_in_value1549_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_FLOAT_in_value1551  */
static	ANTLR3_BITWORD FOLLOW_FLOAT_in_value1551_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_FLOAT_in_value1551	= { FOLLOW_FLOAT_in_value1551_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_VALUE_in_value1565  */
static	ANTLR3_BITWORD FOLLOW_NODE_VALUE_in_value1565_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_VALUE_in_value1565	= { FOLLOW_NODE_VALUE_in_value1565_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_value1567  */
static	ANTLR3_BITWORD FOLLOW_INT_in_value1567_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_INT_in_value1567	= { FOLLOW_INT_in_value1567_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_variable_in_value1579  */
static	ANTLR3_BITWORD FOLLOW_variable_in_value1579_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_variable_in_value1579	= { FOLLOW_variable_in_value1579_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_function_in_value1589  */
static	ANTLR3_BITWORD FOLLOW_function_in_value1589_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_function_in_value1589	= { FOLLOW_function_in_value1589_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_VALUE_in_variable1613  */
static	ANTLR3_BITWORD FOLLOW_NODE_VALUE_in_variable1613_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_VALUE_in_variable1613	= { FOLLOW_NODE_VALUE_in_variable1613_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_VARIABLE_in_variable1615  */
static	ANTLR3_BITWORD FOLLOW_VARIABLE_in_variable1615_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_VARIABLE_in_variable1615	= { FOLLOW_VARIABLE_in_variable1615_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_PATH_in_xpathExpr1642  */
static	ANTLR3_BITWORD FOLLOW_NODE_PATH_in_xpathExpr1642_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_PATH_in_xpathExpr1642	= { FOLLOW_NODE_PATH_in_xpathExpr1642_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_predicatePath_in_xpathExpr1644  */
static	ANTLR3_BITWORD FOLLOW_predicatePath_in_xpathExpr1644_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_predicatePath_in_xpathExpr1644	= { FOLLOW_predicatePath_in_xpathExpr1644_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_xpathFunction_in_xpathExpr1657  */
static	ANTLR3_BITWORD FOLLOW_xpathFunction_in_xpathExpr1657_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_xpathFunction_in_xpathExpr1657	= { FOLLOW_xpathFunction_in_xpathExpr1657_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_xpathExpr1668  */
static	ANTLR3_BITWORD FOLLOW_value_in_xpathExpr1668_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_value_in_xpathExpr1668	= { FOLLOW_value_in_xpathExpr1668_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_NODE_XPATHFUNCTION_in_xpathFunction1692  */
static	ANTLR3_BITWORD FOLLOW_NODE_XPATHFUNCTION_in_xpathFunction1692_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_NODE_XPATHFUNCTION_in_xpathFunction1692	= { FOLLOW_NODE_XPATHFUNCTION_in_xpathFunction1692_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_XPATH_FUNCTION_in_xpathFunction1694  */
static	ANTLR3_BITWORD FOLLOW_XPATH_FUNCTION_in_xpathFunction1694_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFE538) };
static  ANTLR3_BITSET_LIST FOLLOW_XPATH_FUNCTION_in_xpathFunction1694	= { FOLLOW_XPATH_FUNCTION_in_xpathFunction1694_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_xpathFunctionExpression_in_xpathFunction1696  */
static	ANTLR3_BITWORD FOLLOW_xpathFunctionExpression_in_xpathFunction1696_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_xpathFunctionExpression_in_xpathFunction1696	= { FOLLOW_xpathFunctionExpression_in_xpathFunction1696_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_COMMA_in_xpathFunctionExpression1721  */
static	ANTLR3_BITWORD FOLLOW_COMMA_in_xpathFunctionExpression1721_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000004) };
static  ANTLR3_BITSET_LIST FOLLOW_COMMA_in_xpathFunctionExpression1721	= { FOLLOW_COMMA_in_xpathFunctionExpression1721_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1725  */
static	ANTLR3_BITWORD FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1725_bits[]	= { ANTLR3_UINT64_LIT(0x039E81FFFFDFE530) };
static  ANTLR3_BITSET_LIST FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1725	= { FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1725_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1729  */
static	ANTLR3_BITWORD FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1729_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000008) };
static  ANTLR3_BITSET_LIST FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1729	= { FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1729_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_xpathExpr_in_xpathFunctionExpression1743  */
static	ANTLR3_BITWORD FOLLOW_xpathExpr_in_xpathFunctionExpression1743_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_xpathExpr_in_xpathFunctionExpression1743	= { FOLLOW_xpathExpr_in_xpathFunctionExpression1743_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_andOper0  */
static	ANTLR3_BITWORD FOLLOW_set_in_andOper0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_set_in_andOper0	= { FOLLOW_set_in_andOper0_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_orOper0  */
static	ANTLR3_BITWORD FOLLOW_set_in_orOper0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_set_in_orOper0	= { FOLLOW_set_in_orOper0_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_equalityOper0  */
static	ANTLR3_BITWORD FOLLOW_set_in_equalityOper0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_set_in_equalityOper0	= { FOLLOW_set_in_equalityOper0_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_inequalityOper0  */
static	ANTLR3_BITWORD FOLLOW_set_in_inequalityOper0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_set_in_inequalityOper0	= { FOLLOW_set_in_inequalityOper0_bits, 1	};
/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_comparisonOper0  */
static	ANTLR3_BITWORD FOLLOW_set_in_comparisonOper0_bits[]	= { ANTLR3_UINT64_LIT(0x0000000000000002) };
static  ANTLR3_BITSET_LIST FOLLOW_set_in_comparisonOper0	= { FOLLOW_set_in_comparisonOper0_bits, 1	};
     

 
 
/* ==============================================
 * Parsing rules
 */
/** 
 * $ANTLR start start
 * VaeQueryLanguageTreeParser.g:110:1: start returns [ pANTLR3_STRING result, int isPath ] : expr EOF ;
 */
static VaeQueryLanguageTreeParser_start_return
start(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_start_return retval;

    VaeQueryLanguageTreeParser_expr_return expr1;
    #undef	RETURN_TYPE_expr1
    #define	RETURN_TYPE_expr1 VaeQueryLanguageTreeParser_expr_return

    /* Initialize rule variables
     */


    retval.start = LT(1); retval.stop = retval.start;

    {
        // VaeQueryLanguageTreeParser.g:112:3: ( expr EOF )
        // VaeQueryLanguageTreeParser.g:112:5: expr EOF
        {
            FOLLOWPUSH(FOLLOW_expr_in_start62);
            expr1=expr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulestartEx;
            }

             MATCHT(EOF, &FOLLOW_EOF_in_start64); 
            if  (HASEXCEPTION())
            {
                goto rulestartEx;
            }

            {

                      retval.isPath= (expr1.isPath > 0);
                      retval.result= expr1.result;
                    
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulestartEx; /* Prevent compiler warnings */
    rulestartEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end start */

/** 
 * $ANTLR start at
 * VaeQueryLanguageTreeParser.g:119:1: at returns [ pANTLR3_STRING result ] : ( ^( AT p1= path ) | ^( XPATH_AXIS_SEP XPATH_AXES p2= path ) );
 */
static pANTLR3_STRING
at(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    XPATH_AXES2;
    pANTLR3_BASE_TREE    XPATH_AXIS_SEP3;
    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    XPATH_AXES2       = NULL;
    XPATH_AXIS_SEP3       = NULL;
    p1 = NULL;
    p2 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:121:3: ( ^( AT p1= path ) | ^( XPATH_AXIS_SEP XPATH_AXES p2= path ) )
            
            ANTLR3_UINT32 alt1;

            alt1=2;

            switch ( LA(1) ) 
            {
            case AT:
            	{
            		alt1=1;
            	}
                break;
            case XPATH_AXIS_SEP:
            	{
            		alt1=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 1;
                EXCEPTION->state        = 0;


                goto ruleatEx;
            }

            switch (alt1) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:121:5: ^( AT p1= path )
        	    {
        	         MATCHT(AT, &FOLLOW_AT_in_at90); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_at94);
        	        p1=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }

        	        {

        	                  result= p1;
        	                  result->insert8(result, 0, "@");
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:126:5: ^( XPATH_AXIS_SEP XPATH_AXES p2= path )
        	    {
        	        XPATH_AXIS_SEP3 = (pANTLR3_BASE_TREE) MATCHT(XPATH_AXIS_SEP, &FOLLOW_XPATH_AXIS_SEP_in_at108); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }

        	        XPATH_AXES2 = (pANTLR3_BASE_TREE) MATCHT(XPATH_AXES, &FOLLOW_XPATH_AXES_in_at110); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_at114);
        	        p2=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleatEx;
        	        }

        	        {

        	                  result= (XPATH_AXES2->getText(XPATH_AXES2));
        	                  result->appendS(result, (XPATH_AXIS_SEP3->getText(XPATH_AXIS_SEP3)));
        	                  result->appendS(result, p2);
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto ruleatEx; /* Prevent compiler warnings */
    ruleatEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end at */

/** 
 * $ANTLR start expr
 * VaeQueryLanguageTreeParser.g:134:1: expr returns [ pANTLR3_STRING result, int isPath ] : ( rootExpr | rootPath );
 */
static VaeQueryLanguageTreeParser_expr_return
expr(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_expr_return retval;

    VaeQueryLanguageTreeParser_rootExpr_return rootExpr4;
    #undef	RETURN_TYPE_rootExpr4
    #define	RETURN_TYPE_rootExpr4 VaeQueryLanguageTreeParser_rootExpr_return

    VaeQueryLanguageTreeParser_rootPath_return rootPath5;
    #undef	RETURN_TYPE_rootPath5
    #define	RETURN_TYPE_rootPath5 VaeQueryLanguageTreeParser_rootPath_return

    /* Initialize rule variables
     */


    retval.start = LT(1); retval.stop = retval.start;

    {
        {
            //  VaeQueryLanguageTreeParser.g:136:3: ( rootExpr | rootPath )
            
            ANTLR3_UINT32 alt2;

            alt2=2;

            switch ( LA(1) ) 
            {
            case NODE_FUNCTION:
            case NODE_VALUE:
            case DIV:
            case MULT:
            case EQUALITY:
            case EQUALITY_ALT:
            case INEQUALITY:
            case INEQUALITY_ALT:
            case LESS:
            case LTE:
            case GREATER:
            case GTE:
            case AND:
            case OR:
            case XOR:
            case NOT:
            case ADD_TOK:
            case SUB:
            case MOD:
            case IFTRUE:
            case AND_ALT:
            case OR_ALT:
            case XOR_ALT:
            	{
            		alt2=1;
            	}
                break;
            case NODE_PATH:
            case NODE_SQL:
            	{
            		alt2=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 2;
                EXCEPTION->state        = 0;


                goto ruleexprEx;
            }

            switch (alt2) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:136:5: rootExpr
        	    {
        	        FOLLOWPUSH(FOLLOW_rootExpr_in_expr140);
        	        rootExpr4=rootExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexprEx;
        	        }

        	        {

        	                  retval.isPath= rootExpr4.isPath;
        	                  retval.result= rootExpr4.result;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:141:4: rootPath
        	    {
        	        FOLLOWPUSH(FOLLOW_rootPath_in_expr151);
        	        rootPath5=rootPath(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexprEx;
        	        }

        	        {

        	            	    retval.isPath= 1;
        	            	    retval.result= rootPath5.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 evaledExpr
 * VaeQueryLanguageTreeParser.g:148:1: evaledExpr returns [ pANTLR3_STRING result ] : expr ;
 */
static pANTLR3_STRING
evaledExpr(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    VaeQueryLanguageTreeParser_expr_return expr6;
    #undef	RETURN_TYPE_expr6
    #define	RETURN_TYPE_expr6 VaeQueryLanguageTreeParser_expr_return

    /* Initialize rule variables
     */


    {
        // VaeQueryLanguageTreeParser.g:150:3: ( expr )
        // VaeQueryLanguageTreeParser.g:150:5: expr
        {
            FOLLOWPUSH(FOLLOW_expr_in_evaledExpr173);
            expr6=expr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto ruleevaledExprEx;
            }

            {

                      if (expr6.isPath == 1) {
                        result= expr6.result;
                        char *value = resolvePath(expr6.result->chars);
                        result->set8(result, value);
                        free(value);
                      } else {
                        result= expr6.result;
                      }
                    
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto ruleevaledExprEx; /* Prevent compiler warnings */
    ruleevaledExprEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end evaledExpr */

/** 
 * $ANTLR start function
 * VaeQueryLanguageTreeParser.g:163:1: function returns [ pANTLR3_STRING result ] : ^( NODE_FUNCTION FUNCTION ( expressionList )? ) ;
 */
static pANTLR3_STRING
function(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    FUNCTION7;

    /* Initialize rule variables
     */


    FUNCTION7       = NULL;

    {
        // VaeQueryLanguageTreeParser.g:165:2: ( ^( NODE_FUNCTION FUNCTION ( expressionList )? ) )
        // VaeQueryLanguageTreeParser.g:165:4: ^( NODE_FUNCTION FUNCTION ( expressionList )? )
        {
             MATCHT(NODE_FUNCTION, &FOLLOW_NODE_FUNCTION_in_function197); 
            if  (HASEXCEPTION())
            {
                goto rulefunctionEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulefunctionEx;
            }

            FUNCTION7 = (pANTLR3_BASE_TREE) MATCHT(FUNCTION, &FOLLOW_FUNCTION_in_function199); 
            if  (HASEXCEPTION())
            {
                goto rulefunctionEx;
            }

            {

                	      functionArgCount = 0;
                        functionArgList[0] = NULL;
                	    
            }

            // VaeQueryLanguageTreeParser.g:170:6: ( expressionList )?
            {
                int alt3=2;
                switch ( LA(1) ) 
                {
                    case NODE_FUNCTION:
                    case NODE_PATH:
                    case NODE_SQL:
                    case NODE_VALUE:
                    case DIV:
                    case MULT:
                    case EQUALITY:
                    case EQUALITY_ALT:
                    case INEQUALITY:
                    case INEQUALITY_ALT:
                    case LESS:
                    case LTE:
                    case GREATER:
                    case GTE:
                    case AND:
                    case OR:
                    case XOR:
                    case NOT:
                    case ADD_TOK:
                    case SUB:
                    case MOD:
                    case IFTRUE:
                    case COMMA:
                    case AND_ALT:
                    case OR_ALT:
                    case XOR_ALT:
                    	{
                    		alt3=1;
                    	}
                        break;
                }

                switch (alt3) 
                {
            	case 1:
            	    // VaeQueryLanguageTreeParser.g:170:6: expressionList
            	    {
            	        FOLLOWPUSH(FOLLOW_expressionList_in_function214);
            	        expressionList(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulefunctionEx;
            	        }


            	    }
            	    break;

                }
            }

            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulefunctionEx;
            }

            {

                	    char *value = resolveFunction((FUNCTION7->getText(FUNCTION7))->subString((FUNCTION7->getText(FUNCTION7)), 0, strlen((FUNCTION7->getText(FUNCTION7))->chars) - 1)->chars, functionArgList);
                	    result= newStr(FUNCTION7, value);
                	    free(value);
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulefunctionEx; /* Prevent compiler warnings */
    rulefunctionEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end function */

/** 
 * $ANTLR start expressionList
 * VaeQueryLanguageTreeParser.g:179:1: expressionList : ( ^( COMMA expressionList expressionList ) | evaledExpr );
 */
static void
expressionList(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING evaledExpr8;
    #undef	RETURN_TYPE_evaledExpr8
    #define	RETURN_TYPE_evaledExpr8 pANTLR3_STRING

    /* Initialize rule variables
     */


    evaledExpr8 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:180:3: ( ^( COMMA expressionList expressionList ) | evaledExpr )
            
            ANTLR3_UINT32 alt4;

            alt4=2;

            switch ( LA(1) ) 
            {
            case COMMA:
            	{
            		alt4=1;
            	}
                break;
            case NODE_FUNCTION:
            case NODE_PATH:
            case NODE_SQL:
            case NODE_VALUE:
            case DIV:
            case MULT:
            case EQUALITY:
            case EQUALITY_ALT:
            case INEQUALITY:
            case INEQUALITY_ALT:
            case LESS:
            case LTE:
            case GREATER:
            case GTE:
            case AND:
            case OR:
            case XOR:
            case NOT:
            case ADD_TOK:
            case SUB:
            case MOD:
            case IFTRUE:
            case AND_ALT:
            case OR_ALT:
            case XOR_ALT:
            	{
            		alt4=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 4;
                EXCEPTION->state        = 0;


                goto ruleexpressionListEx;
            }

            switch (alt4) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:180:5: ^( COMMA expressionList expressionList )
        	    {
        	         MATCHT(COMMA, &FOLLOW_COMMA_in_expressionList238); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexpressionListEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexpressionListEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_expressionList_in_expressionList240);
        	        expressionList(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexpressionListEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_expressionList_in_expressionList242);
        	        expressionList(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexpressionListEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexpressionListEx;
        	        }


        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:181:5: evaledExpr
        	    {
        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_expressionList250);
        	        evaledExpr8=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleexpressionListEx;
        	        }

        	        {

        	                  if (functionArgCount < FUNCTION_ARG_LIST_SIZE) {
        	                    functionArgList[functionArgCount] = evaledExpr8->chars;
        	                    functionArgCount++;
        	                    functionArgList[functionArgCount] = NULL;
        	                  }
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto ruleexpressionListEx; /* Prevent compiler warnings */
    ruleexpressionListEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return ;
}
/* $ANTLR end expressionList */

/** 
 * $ANTLR start oper
 * VaeQueryLanguageTreeParser.g:191:1: oper returns [ pANTLR3_STRING result, int isPath ] : ( ^(e= IFTRUE e1= evaledExpr ie2= expr ie3= expr ) | ^( (e= EQUALITY | e= EQUALITY_ALT ) e1= evaledExpr e2= evaledExpr ) | ^( (e= INEQUALITY | e= INEQUALITY_ALT ) e1= evaledExpr e2= evaledExpr ) | ^(e= LESS e1= evaledExpr e2= evaledExpr ) | ^(e= LTE e1= evaledExpr e2= evaledExpr ) | ^(e= GREATER e1= evaledExpr e2= evaledExpr ) | ^(e= GTE e1= evaledExpr e2= evaledExpr ) | ^( (e= AND | e= AND_ALT ) e1= evaledExpr e2= evaledExpr ) | ^( (e= OR | e= OR_ALT ) e1= evaledExpr e2= evaledExpr ) | ^( (e= XOR | e= XOR_ALT ) e1= evaledExpr e2= evaledExpr ) | ^(e= ADD_TOK e1= evaledExpr e2= evaledExpr ) | ^(e= SUB e1= evaledExpr e2= evaledExpr ) | ^(e= MULT e1= evaledExpr e2= evaledExpr ) | ^(e= DIV e1= evaledExpr e2= evaledExpr ) | ^(e= MOD e1= evaledExpr e2= evaledExpr ) | ^(e= NOT e1= evaledExpr ) );
 */
static VaeQueryLanguageTreeParser_oper_return
oper(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_oper_return retval;

    pANTLR3_BASE_TREE    e;
    pANTLR3_STRING e1;
    #undef	RETURN_TYPE_e1
    #define	RETURN_TYPE_e1 pANTLR3_STRING

    VaeQueryLanguageTreeParser_expr_return ie2;
    #undef	RETURN_TYPE_ie2
    #define	RETURN_TYPE_ie2 VaeQueryLanguageTreeParser_expr_return

    VaeQueryLanguageTreeParser_expr_return ie3;
    #undef	RETURN_TYPE_ie3
    #define	RETURN_TYPE_ie3 VaeQueryLanguageTreeParser_expr_return

    pANTLR3_STRING e2;
    #undef	RETURN_TYPE_e2
    #define	RETURN_TYPE_e2 pANTLR3_STRING

    /* Initialize rule variables
     */


    e       = NULL;
    e1 = NULL;
    e2 = NULL;
    retval.start = LT(1); retval.stop = retval.start;

    {
        {
            //  VaeQueryLanguageTreeParser.g:193:2: ( ^(e= IFTRUE e1= evaledExpr ie2= expr ie3= expr ) | ^( (e= EQUALITY | e= EQUALITY_ALT ) e1= evaledExpr e2= evaledExpr ) | ^( (e= INEQUALITY | e= INEQUALITY_ALT ) e1= evaledExpr e2= evaledExpr ) | ^(e= LESS e1= evaledExpr e2= evaledExpr ) | ^(e= LTE e1= evaledExpr e2= evaledExpr ) | ^(e= GREATER e1= evaledExpr e2= evaledExpr ) | ^(e= GTE e1= evaledExpr e2= evaledExpr ) | ^( (e= AND | e= AND_ALT ) e1= evaledExpr e2= evaledExpr ) | ^( (e= OR | e= OR_ALT ) e1= evaledExpr e2= evaledExpr ) | ^( (e= XOR | e= XOR_ALT ) e1= evaledExpr e2= evaledExpr ) | ^(e= ADD_TOK e1= evaledExpr e2= evaledExpr ) | ^(e= SUB e1= evaledExpr e2= evaledExpr ) | ^(e= MULT e1= evaledExpr e2= evaledExpr ) | ^(e= DIV e1= evaledExpr e2= evaledExpr ) | ^(e= MOD e1= evaledExpr e2= evaledExpr ) | ^(e= NOT e1= evaledExpr ) )
            
            ANTLR3_UINT32 alt10;

            alt10=16;

            switch ( LA(1) ) 
            {
            case IFTRUE:
            	{
            		alt10=1;
            	}
                break;
            case EQUALITY:
            case EQUALITY_ALT:
            	{
            		alt10=2;
            	}
                break;
            case INEQUALITY:
            case INEQUALITY_ALT:
            	{
            		alt10=3;
            	}
                break;
            case LESS:
            	{
            		alt10=4;
            	}
                break;
            case LTE:
            	{
            		alt10=5;
            	}
                break;
            case GREATER:
            	{
            		alt10=6;
            	}
                break;
            case GTE:
            	{
            		alt10=7;
            	}
                break;
            case AND:
            case AND_ALT:
            	{
            		alt10=8;
            	}
                break;
            case OR:
            case OR_ALT:
            	{
            		alt10=9;
            	}
                break;
            case XOR:
            case XOR_ALT:
            	{
            		alt10=10;
            	}
                break;
            case ADD_TOK:
            	{
            		alt10=11;
            	}
                break;
            case SUB:
            	{
            		alt10=12;
            	}
                break;
            case MULT:
            	{
            		alt10=13;
            	}
                break;
            case DIV:
            	{
            		alt10=14;
            	}
                break;
            case MOD:
            	{
            		alt10=15;
            	}
                break;
            case NOT:
            	{
            		alt10=16;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 10;
                EXCEPTION->state        = 0;


                goto ruleoperEx;
            }

            switch (alt10) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:193:4: ^(e= IFTRUE e1= evaledExpr ie2= expr ie3= expr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(IFTRUE, &FOLLOW_IFTRUE_in_oper277); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper281);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_expr_in_oper285);
        	        ie2=expr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_expr_in_oper289);
        	        ie3=expr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  int t = asBoolean(e1);
        	                  retval.isPath= (t ? ie2.isPath : ie3.isPath);
        	                  retval.result= (t ? ie2.result : ie3.result);
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:199:4: ^( (e= EQUALITY | e= EQUALITY_ALT ) e1= evaledExpr e2= evaledExpr )
        	    {

        	        // VaeQueryLanguageTreeParser.g:199:6: (e= EQUALITY | e= EQUALITY_ALT )
        	        {
        	            int alt5=2;
        	            switch ( LA(1) ) 
        	            {
        	            case EQUALITY:
        	            	{
        	            		alt5=1;
        	            	}
        	                break;
        	            case EQUALITY_ALT:
        	            	{
        	            		alt5=2;
        	            	}
        	                break;

        	            default:
        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
        	                EXCEPTION->message      = (void *)"";
        	                EXCEPTION->decisionNum  = 5;
        	                EXCEPTION->state        = 0;


        	                goto ruleoperEx;
        	            }

        	            switch (alt5) 
        	            {
        	        	case 1:
        	        	    // VaeQueryLanguageTreeParser.g:199:7: e= EQUALITY
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(EQUALITY, &FOLLOW_EQUALITY_in_oper305); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;
        	        	case 2:
        	        	    // VaeQueryLanguageTreeParser.g:199:20: e= EQUALITY_ALT
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(EQUALITY_ALT, &FOLLOW_EQUALITY_ALT_in_oper311); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;

        	            }
        	        }

        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper316);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper320);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse((bothNumbers(e1, e2) ? asNumber(e1) == asNumber(e2) : !strcmp(e1->chars, e2->chars)), e);
        	                
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:204:4: ^( (e= INEQUALITY | e= INEQUALITY_ALT ) e1= evaledExpr e2= evaledExpr )
        	    {

        	        // VaeQueryLanguageTreeParser.g:204:6: (e= INEQUALITY | e= INEQUALITY_ALT )
        	        {
        	            int alt6=2;
        	            switch ( LA(1) ) 
        	            {
        	            case INEQUALITY:
        	            	{
        	            		alt6=1;
        	            	}
        	                break;
        	            case INEQUALITY_ALT:
        	            	{
        	            		alt6=2;
        	            	}
        	                break;

        	            default:
        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
        	                EXCEPTION->message      = (void *)"";
        	                EXCEPTION->decisionNum  = 6;
        	                EXCEPTION->state        = 0;


        	                goto ruleoperEx;
        	            }

        	            switch (alt6) 
        	            {
        	        	case 1:
        	        	    // VaeQueryLanguageTreeParser.g:204:7: e= INEQUALITY
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(INEQUALITY, &FOLLOW_INEQUALITY_in_oper336); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;
        	        	case 2:
        	        	    // VaeQueryLanguageTreeParser.g:204:22: e= INEQUALITY_ALT
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(INEQUALITY_ALT, &FOLLOW_INEQUALITY_ALT_in_oper342); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;

        	            }
        	        }

        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper347);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper351);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse((bothNumbers(e1, e2) ? asNumber(e1) != asNumber(e2) : strcmp(e1->chars, e2->chars)), e);
        	                
        	        }

        	    }
        	    break;
        	case 4:
        	    // VaeQueryLanguageTreeParser.g:209:4: ^(e= LESS e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(LESS, &FOLLOW_LESS_in_oper366); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper370);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper374);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse((bothNumbers(e1, e2) ? asNumber(e1) < asNumber(e2) : strcmp(e1->chars, e2->chars) < 0), e);
        	                
        	        }

        	    }
        	    break;
        	case 5:
        	    // VaeQueryLanguageTreeParser.g:214:4: ^(e= LTE e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(LTE, &FOLLOW_LTE_in_oper389); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper393);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper397);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse((bothNumbers(e1, e2) ? asNumber(e1) <= asNumber(e2) : strcmp(e1->chars, e2->chars) <= 0), e);
        	                
        	        }

        	    }
        	    break;
        	case 6:
        	    // VaeQueryLanguageTreeParser.g:219:4: ^(e= GREATER e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(GREATER, &FOLLOW_GREATER_in_oper412); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper416);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper420);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse((bothNumbers(e1, e2) ? asNumber(e1) > asNumber(e2) : strcmp(e1->chars, e2->chars) > 0), e);
        	                
        	        }

        	    }
        	    break;
        	case 7:
        	    // VaeQueryLanguageTreeParser.g:224:4: ^(e= GTE e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(GTE, &FOLLOW_GTE_in_oper435); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper439);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper443);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse((bothNumbers(e1, e2) ? asNumber(e1) >= asNumber(e2) : strcmp(e1->chars, e2->chars) >= 0), e);
        	                
        	        }

        	    }
        	    break;
        	case 8:
        	    // VaeQueryLanguageTreeParser.g:229:4: ^( (e= AND | e= AND_ALT ) e1= evaledExpr e2= evaledExpr )
        	    {

        	        // VaeQueryLanguageTreeParser.g:229:6: (e= AND | e= AND_ALT )
        	        {
        	            int alt7=2;
        	            switch ( LA(1) ) 
        	            {
        	            case AND:
        	            	{
        	            		alt7=1;
        	            	}
        	                break;
        	            case AND_ALT:
        	            	{
        	            		alt7=2;
        	            	}
        	                break;

        	            default:
        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
        	                EXCEPTION->message      = (void *)"";
        	                EXCEPTION->decisionNum  = 7;
        	                EXCEPTION->state        = 0;


        	                goto ruleoperEx;
        	            }

        	            switch (alt7) 
        	            {
        	        	case 1:
        	        	    // VaeQueryLanguageTreeParser.g:229:7: e= AND
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(AND, &FOLLOW_AND_in_oper459); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;
        	        	case 2:
        	        	    // VaeQueryLanguageTreeParser.g:229:15: e= AND_ALT
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(AND_ALT, &FOLLOW_AND_ALT_in_oper465); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;

        	            }
        	        }

        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper470);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper474);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse(asBoolean(e1) && asBoolean(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 9:
        	    // VaeQueryLanguageTreeParser.g:234:4: ^( (e= OR | e= OR_ALT ) e1= evaledExpr e2= evaledExpr )
        	    {

        	        // VaeQueryLanguageTreeParser.g:234:6: (e= OR | e= OR_ALT )
        	        {
        	            int alt8=2;
        	            switch ( LA(1) ) 
        	            {
        	            case OR:
        	            	{
        	            		alt8=1;
        	            	}
        	                break;
        	            case OR_ALT:
        	            	{
        	            		alt8=2;
        	            	}
        	                break;

        	            default:
        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
        	                EXCEPTION->message      = (void *)"";
        	                EXCEPTION->decisionNum  = 8;
        	                EXCEPTION->state        = 0;


        	                goto ruleoperEx;
        	            }

        	            switch (alt8) 
        	            {
        	        	case 1:
        	        	    // VaeQueryLanguageTreeParser.g:234:7: e= OR
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(OR, &FOLLOW_OR_in_oper490); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;
        	        	case 2:
        	        	    // VaeQueryLanguageTreeParser.g:234:14: e= OR_ALT
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(OR_ALT, &FOLLOW_OR_ALT_in_oper496); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;

        	            }
        	        }

        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper501);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper505);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse(asBoolean(e1) || asBoolean(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 10:
        	    // VaeQueryLanguageTreeParser.g:239:4: ^( (e= XOR | e= XOR_ALT ) e1= evaledExpr e2= evaledExpr )
        	    {

        	        // VaeQueryLanguageTreeParser.g:239:6: (e= XOR | e= XOR_ALT )
        	        {
        	            int alt9=2;
        	            switch ( LA(1) ) 
        	            {
        	            case XOR:
        	            	{
        	            		alt9=1;
        	            	}
        	                break;
        	            case XOR_ALT:
        	            	{
        	            		alt9=2;
        	            	}
        	                break;

        	            default:
        	                CONSTRUCTEX();
        	                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
        	                EXCEPTION->message      = (void *)"";
        	                EXCEPTION->decisionNum  = 9;
        	                EXCEPTION->state        = 0;


        	                goto ruleoperEx;
        	            }

        	            switch (alt9) 
        	            {
        	        	case 1:
        	        	    // VaeQueryLanguageTreeParser.g:239:7: e= XOR
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(XOR, &FOLLOW_XOR_in_oper521); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;
        	        	case 2:
        	        	    // VaeQueryLanguageTreeParser.g:239:15: e= XOR_ALT
        	        	    {
        	        	        e = (pANTLR3_BASE_TREE) MATCHT(XOR_ALT, &FOLLOW_XOR_ALT_in_oper527); 
        	        	        if  (HASEXCEPTION())
        	        	        {
        	        	            goto ruleoperEx;
        	        	        }


        	        	    }
        	        	    break;

        	            }
        	        }

        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper532);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper536);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= booleanResponse(asBoolean(e1) ^ asBoolean(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 11:
        	    // VaeQueryLanguageTreeParser.g:244:4: ^(e= ADD_TOK e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(ADD_TOK, &FOLLOW_ADD_TOK_in_oper551); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper555);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper559);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= numberResponse(asNumber(e1) + asNumber(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 12:
        	    // VaeQueryLanguageTreeParser.g:249:4: ^(e= SUB e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(SUB, &FOLLOW_SUB_in_oper574); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper578);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper582);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= numberResponse(asNumber(e1) - asNumber(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 13:
        	    // VaeQueryLanguageTreeParser.g:254:4: ^(e= MULT e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(MULT, &FOLLOW_MULT_in_oper597); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper601);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper605);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= numberResponse(asNumber(e1) * asNumber(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 14:
        	    // VaeQueryLanguageTreeParser.g:259:4: ^(e= DIV e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(DIV, &FOLLOW_DIV_in_oper620); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper624);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper628);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= numberResponse(asNumber(e1) / asNumber(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 15:
        	    // VaeQueryLanguageTreeParser.g:264:4: ^(e= MOD e1= evaledExpr e2= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(MOD, &FOLLOW_MOD_in_oper643); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper647);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper651);
        	        e2=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= numberResponse(asInt(e1) % asInt(e2), e);
        	                
        	        }

        	    }
        	    break;
        	case 16:
        	    // VaeQueryLanguageTreeParser.g:269:5: ^(e= NOT e1= evaledExpr )
        	    {
        	        e = (pANTLR3_BASE_TREE) MATCHT(NOT, &FOLLOW_NOT_in_oper667); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_oper671);
        	        e1=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleoperEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.result= numberResponse(!asInt(e1), e);
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto ruleoperEx; /* Prevent compiler warnings */
    ruleoperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end oper */

/** 
 * $ANTLR start path
 * VaeQueryLanguageTreeParser.g:276:1: path returns [ pANTLR3_STRING result ] : ( slash | at | piper | ^( NODE_PREDICATE predicate p3= path ) | INT | NAME | STAR | DOT_STEP | PERMALINK | SPECIAL_NEXT | SPECIAL_PREV | variable | function );
 */
static pANTLR3_STRING
path(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    INT13;
    pANTLR3_BASE_TREE    NAME14;
    pANTLR3_BASE_TREE    STAR15;
    pANTLR3_BASE_TREE    DOT_STEP16;
    pANTLR3_BASE_TREE    PERMALINK17;
    pANTLR3_BASE_TREE    SPECIAL_NEXT18;
    pANTLR3_BASE_TREE    SPECIAL_PREV19;
    pANTLR3_STRING p3;
    #undef	RETURN_TYPE_p3
    #define	RETURN_TYPE_p3 pANTLR3_STRING

    pANTLR3_STRING slash9;
    #undef	RETURN_TYPE_slash9
    #define	RETURN_TYPE_slash9 pANTLR3_STRING

    pANTLR3_STRING at10;
    #undef	RETURN_TYPE_at10
    #define	RETURN_TYPE_at10 pANTLR3_STRING

    pANTLR3_STRING piper11;
    #undef	RETURN_TYPE_piper11
    #define	RETURN_TYPE_piper11 pANTLR3_STRING

    pANTLR3_STRING predicate12;
    #undef	RETURN_TYPE_predicate12
    #define	RETURN_TYPE_predicate12 pANTLR3_STRING

    pANTLR3_STRING variable20;
    #undef	RETURN_TYPE_variable20
    #define	RETURN_TYPE_variable20 pANTLR3_STRING

    pANTLR3_STRING function21;
    #undef	RETURN_TYPE_function21
    #define	RETURN_TYPE_function21 pANTLR3_STRING

    /* Initialize rule variables
     */


    INT13       = NULL;
    NAME14       = NULL;
    STAR15       = NULL;
    DOT_STEP16       = NULL;
    PERMALINK17       = NULL;
    SPECIAL_NEXT18       = NULL;
    SPECIAL_PREV19       = NULL;
    p3 = NULL;
    slash9 = NULL;
    at10 = NULL;
    piper11 = NULL;
    predicate12 = NULL;
    variable20 = NULL;
    function21 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:278:3: ( slash | at | piper | ^( NODE_PREDICATE predicate p3= path ) | INT | NAME | STAR | DOT_STEP | PERMALINK | SPECIAL_NEXT | SPECIAL_PREV | variable | function )
            
            ANTLR3_UINT32 alt11;

            alt11=13;

            switch ( LA(1) ) 
            {
            case NODE_ABSOLUTE:
            case SLASH:
            	{
            		alt11=1;
            	}
                break;
            case AT:
            case XPATH_AXIS_SEP:
            	{
            		alt11=2;
            	}
                break;
            case PIPE:
            	{
            		alt11=3;
            	}
                break;
            case NODE_PREDICATE:
            	{
            		alt11=4;
            	}
                break;
            case INT:
            	{
            		alt11=5;
            	}
                break;
            case NAME:
            	{
            		alt11=6;
            	}
                break;
            case STAR:
            	{
            		alt11=7;
            	}
                break;
            case DOT_STEP:
            	{
            		alt11=8;
            	}
                break;
            case PERMALINK:
            	{
            		alt11=9;
            	}
                break;
            case SPECIAL_NEXT:
            	{
            		alt11=10;
            	}
                break;
            case SPECIAL_PREV:
            	{
            		alt11=11;
            	}
                break;
            case NODE_VALUE:
            	{
            		alt11=12;
            	}
                break;
            case NODE_FUNCTION:
            	{
            		alt11=13;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 11;
                EXCEPTION->state        = 0;


                goto rulepathEx;
            }

            switch (alt11) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:278:5: slash
        	    {
        	        FOLLOWPUSH(FOLLOW_slash_in_path696);
        	        slash9=slash(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= slash9;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:282:5: at
        	    {
        	        FOLLOWPUSH(FOLLOW_at_in_path708);
        	        at10=at(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= at10;
        	                
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:286:5: piper
        	    {
        	        FOLLOWPUSH(FOLLOW_piper_in_path720);
        	        piper11=piper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= piper11;
        	                
        	        }

        	    }
        	    break;
        	case 4:
        	    // VaeQueryLanguageTreeParser.g:290:5: ^( NODE_PREDICATE predicate p3= path )
        	    {
        	         MATCHT(NODE_PREDICATE, &FOLLOW_NODE_PREDICATE_in_path733); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_predicate_in_path735);
        	        predicate12=predicate(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_path739);
        	        p3=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= p3;
        	                  if (strlen(predicate12->chars)) {
        	                    result->append8(result, "[");
        	                    result->appendS(result, predicate12);
        	                    result->append8(result, "]");
        	                  }
        	                
        	        }

        	    }
        	    break;
        	case 5:
        	    // VaeQueryLanguageTreeParser.g:299:5: INT
        	    {
        	        INT13 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_path752); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (INT13->getText(INT13));
        	                
        	        }

        	    }
        	    break;
        	case 6:
        	    // VaeQueryLanguageTreeParser.g:303:5: NAME
        	    {
        	        NAME14 = (pANTLR3_BASE_TREE) MATCHT(NAME, &FOLLOW_NAME_in_path764); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (NAME14->getText(NAME14));
        	                
        	        }

        	    }
        	    break;
        	case 7:
        	    // VaeQueryLanguageTreeParser.g:307:5: STAR
        	    {
        	        STAR15 = (pANTLR3_BASE_TREE) MATCHT(STAR, &FOLLOW_STAR_in_path776); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (STAR15->getText(STAR15));
        	                
        	        }

        	    }
        	    break;
        	case 8:
        	    // VaeQueryLanguageTreeParser.g:311:5: DOT_STEP
        	    {
        	        DOT_STEP16 = (pANTLR3_BASE_TREE) MATCHT(DOT_STEP, &FOLLOW_DOT_STEP_in_path788); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (DOT_STEP16->getText(DOT_STEP16));
        	                
        	        }

        	    }
        	    break;
        	case 9:
        	    // VaeQueryLanguageTreeParser.g:315:5: PERMALINK
        	    {
        	        PERMALINK17 = (pANTLR3_BASE_TREE) MATCHT(PERMALINK, &FOLLOW_PERMALINK_in_path800); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (PERMALINK17->getText(PERMALINK17));
        	                
        	        }

        	    }
        	    break;
        	case 10:
        	    // VaeQueryLanguageTreeParser.g:319:5: SPECIAL_NEXT
        	    {
        	        SPECIAL_NEXT18 = (pANTLR3_BASE_TREE) MATCHT(SPECIAL_NEXT, &FOLLOW_SPECIAL_NEXT_in_path812); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (SPECIAL_NEXT18->getText(SPECIAL_NEXT18));
        	                
        	        }

        	    }
        	    break;
        	case 11:
        	    // VaeQueryLanguageTreeParser.g:323:5: SPECIAL_PREV
        	    {
        	        SPECIAL_PREV19 = (pANTLR3_BASE_TREE) MATCHT(SPECIAL_PREV, &FOLLOW_SPECIAL_PREV_in_path824); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= (SPECIAL_PREV19->getText(SPECIAL_PREV19));
        	                
        	        }

        	    }
        	    break;
        	case 12:
        	    // VaeQueryLanguageTreeParser.g:327:5: variable
        	    {
        	        FOLLOWPUSH(FOLLOW_variable_in_path836);
        	        variable20=variable(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= variable20;
        	                
        	        }

        	    }
        	    break;
        	case 13:
        	    // VaeQueryLanguageTreeParser.g:331:5: function
        	    {
        	        FOLLOWPUSH(FOLLOW_function_in_path848);
        	        function21=function(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepathEx;
        	        }

        	        {

        	                  result= function21;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulepathEx; /* Prevent compiler warnings */
    rulepathEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end path */

/** 
 * $ANTLR start piper
 * VaeQueryLanguageTreeParser.g:337:1: piper returns [ pANTLR3_STRING result ] : ^( PIPE p1= path p2= path ) ;
 */
static pANTLR3_STRING
piper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    p1 = NULL;
    p2 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:339:3: ( ^( PIPE p1= path p2= path ) )
        // VaeQueryLanguageTreeParser.g:339:5: ^( PIPE p1= path p2= path )
        {
             MATCHT(PIPE, &FOLLOW_PIPE_in_piper876); 
            if  (HASEXCEPTION())
            {
                goto rulepiperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepiperEx;
            }

            FOLLOWPUSH(FOLLOW_path_in_piper880);
            p1=path(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepiperEx;
            }

            FOLLOWPUSH(FOLLOW_path_in_piper884);
            p2=path(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepiperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepiperEx;
            }

            {

                      result= p1;
                      result->append8(result, "|");
                      result->appendS(result, p2);
                    
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepiperEx; /* Prevent compiler warnings */
    rulepiperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end piper */

/** 
 * $ANTLR start predicate
 * VaeQueryLanguageTreeParser.g:347:1: predicate returns [ pANTLR3_STRING result ] : ( INT | predicateOper );
 */
static pANTLR3_STRING
predicate(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    INT22;
    pANTLR3_STRING predicateOper23;
    #undef	RETURN_TYPE_predicateOper23
    #define	RETURN_TYPE_predicateOper23 pANTLR3_STRING

    /* Initialize rule variables
     */


    INT22       = NULL;
    predicateOper23 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:349:3: ( INT | predicateOper )
            
            ANTLR3_UINT32 alt12;

            alt12=2;

            switch ( LA(1) ) 
            {
            case INT:
            	{
            		alt12=1;
            	}
                break;
            case EQUALITY:
            case EQUALITY_ALT:
            case INEQUALITY:
            case INEQUALITY_ALT:
            case LESS:
            case LTE:
            case GREATER:
            case GTE:
            case AND:
            case OR:
            case COLON:
            case AND_ALT:
            case OR_ALT:
            	{
            		alt12=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 12;
                EXCEPTION->state        = 0;


                goto rulepredicateEx;
            }

            switch (alt12) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:349:5: INT
        	    {
        	        INT22 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_predicate908); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateEx;
        	        }

        	        {

        	                  return (INT22->getText(INT22));
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:353:5: predicateOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateOper_in_predicate920);
        	        predicateOper23=predicateOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateEx;
        	        }

        	        {

        	                  return predicateOper23;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateEx; /* Prevent compiler warnings */
    rulepredicateEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicate */

/** 
 * $ANTLR start predicateExpr
 * VaeQueryLanguageTreeParser.g:359:1: predicateExpr returns [ pANTLR3_STRING result ] : ( predicatePath | xpathFunction | value | predicateOper );
 */
static pANTLR3_STRING
predicateExpr(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING predicatePath24;
    #undef	RETURN_TYPE_predicatePath24
    #define	RETURN_TYPE_predicatePath24 pANTLR3_STRING

    pANTLR3_STRING xpathFunction25;
    #undef	RETURN_TYPE_xpathFunction25
    #define	RETURN_TYPE_xpathFunction25 pANTLR3_STRING

    VaeQueryLanguageTreeParser_value_return value26;
    #undef	RETURN_TYPE_value26
    #define	RETURN_TYPE_value26 VaeQueryLanguageTreeParser_value_return

    pANTLR3_STRING predicateOper27;
    #undef	RETURN_TYPE_predicateOper27
    #define	RETURN_TYPE_predicateOper27 pANTLR3_STRING

    /* Initialize rule variables
     */


    predicatePath24 = NULL;
    xpathFunction25 = NULL;
    predicateOper27 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:361:3: ( predicatePath | xpathFunction | value | predicateOper )
            
            ANTLR3_UINT32 alt13;

            alt13=4;

            switch ( LA(1) ) 
            {
            case NODE_ABSOLUTE:
            case NODE_PATHREF:
            case SLASH:
            case AT:
            case NAME:
            	{
            		alt13=1;
            	}
                break;
            case NODE_XPATHFUNCTION:
            	{
            		alt13=2;
            	}
                break;
            case NODE_FUNCTION:
            case NODE_VALUE:
            	{
            		alt13=3;
            	}
                break;
            case EQUALITY:
            case EQUALITY_ALT:
            case INEQUALITY:
            case INEQUALITY_ALT:
            case LESS:
            case LTE:
            case GREATER:
            case GTE:
            case AND:
            case OR:
            case COLON:
            case AND_ALT:
            case OR_ALT:
            	{
            		alt13=4;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 13;
                EXCEPTION->state        = 0;


                goto rulepredicateExprEx;
            }

            switch (alt13) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:361:5: predicatePath
        	    {
        	        FOLLOWPUSH(FOLLOW_predicatePath_in_predicateExpr945);
        	        predicatePath24=predicatePath(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateExprEx;
        	        }

        	        {

        	                  result= predicatePath24;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:365:5: xpathFunction
        	    {
        	        FOLLOWPUSH(FOLLOW_xpathFunction_in_predicateExpr957);
        	        xpathFunction25=xpathFunction(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateExprEx;
        	        }

        	        {

        	            	    result= xpathFunction25;
        	            	  
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:369:5: value
        	    {
        	        FOLLOWPUSH(FOLLOW_value_in_predicateExpr968);
        	        value26=value(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateExprEx;
        	        }

        	        {

        	            	    result= value26.result;
        	            	    if (!value26.isBlankVariable) {
        	            	      escapeApos(result);
        	                  }
        	            	  
        	        }

        	    }
        	    break;
        	case 4:
        	    // VaeQueryLanguageTreeParser.g:376:5: predicateOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateOper_in_predicateExpr979);
        	        predicateOper27=predicateOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateExprEx;
        	        }

        	        {

        	                  result= predicateOper27;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateExprEx; /* Prevent compiler warnings */
    rulepredicateExprEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateExpr */

/** 
 * $ANTLR start predicateOper
 * VaeQueryLanguageTreeParser.g:382:1: predicateOper returns [ pANTLR3_STRING result ] : ( predicateEqualityOper | predicateInequalityOper | predicateAndOper | predicateOrOper | predicateComparisonOper | predicateRangeOper );
 */
static pANTLR3_STRING
predicateOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING predicateEqualityOper28;
    #undef	RETURN_TYPE_predicateEqualityOper28
    #define	RETURN_TYPE_predicateEqualityOper28 pANTLR3_STRING

    pANTLR3_STRING predicateInequalityOper29;
    #undef	RETURN_TYPE_predicateInequalityOper29
    #define	RETURN_TYPE_predicateInequalityOper29 pANTLR3_STRING

    pANTLR3_STRING predicateAndOper30;
    #undef	RETURN_TYPE_predicateAndOper30
    #define	RETURN_TYPE_predicateAndOper30 pANTLR3_STRING

    pANTLR3_STRING predicateOrOper31;
    #undef	RETURN_TYPE_predicateOrOper31
    #define	RETURN_TYPE_predicateOrOper31 pANTLR3_STRING

    pANTLR3_STRING predicateComparisonOper32;
    #undef	RETURN_TYPE_predicateComparisonOper32
    #define	RETURN_TYPE_predicateComparisonOper32 pANTLR3_STRING

    pANTLR3_STRING predicateRangeOper33;
    #undef	RETURN_TYPE_predicateRangeOper33
    #define	RETURN_TYPE_predicateRangeOper33 pANTLR3_STRING

    /* Initialize rule variables
     */


    predicateEqualityOper28 = NULL;
    predicateInequalityOper29 = NULL;
    predicateAndOper30 = NULL;
    predicateOrOper31 = NULL;
    predicateComparisonOper32 = NULL;
    predicateRangeOper33 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:384:3: ( predicateEqualityOper | predicateInequalityOper | predicateAndOper | predicateOrOper | predicateComparisonOper | predicateRangeOper )
            
            ANTLR3_UINT32 alt14;

            alt14=6;

            switch ( LA(1) ) 
            {
            case EQUALITY:
            case EQUALITY_ALT:
            	{
            		alt14=1;
            	}
                break;
            case INEQUALITY:
            case INEQUALITY_ALT:
            	{
            		alt14=2;
            	}
                break;
            case AND:
            case AND_ALT:
            	{
            		alt14=3;
            	}
                break;
            case OR:
            case OR_ALT:
            	{
            		alt14=4;
            	}
                break;
            case LESS:
            case LTE:
            case GREATER:
            case GTE:
            	{
            		alt14=5;
            	}
                break;
            case COLON:
            	{
            		alt14=6;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 14;
                EXCEPTION->state        = 0;


                goto rulepredicateOperEx;
            }

            switch (alt14) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:384:5: predicateEqualityOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateEqualityOper_in_predicateOper1004);
        	        predicateEqualityOper28=predicateEqualityOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateOperEx;
        	        }

        	        {

        	                  return predicateEqualityOper28;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:388:5: predicateInequalityOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateInequalityOper_in_predicateOper1016);
        	        predicateInequalityOper29=predicateInequalityOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateOperEx;
        	        }

        	        {

        	                  return predicateInequalityOper29;
        	                
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:392:5: predicateAndOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateAndOper_in_predicateOper1028);
        	        predicateAndOper30=predicateAndOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateOperEx;
        	        }

        	        {

        	                  return predicateAndOper30;
        	                
        	        }

        	    }
        	    break;
        	case 4:
        	    // VaeQueryLanguageTreeParser.g:396:5: predicateOrOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateOrOper_in_predicateOper1040);
        	        predicateOrOper31=predicateOrOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateOperEx;
        	        }

        	        {

        	                  return predicateOrOper31;
        	                
        	        }

        	    }
        	    break;
        	case 5:
        	    // VaeQueryLanguageTreeParser.g:400:5: predicateComparisonOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateComparisonOper_in_predicateOper1052);
        	        predicateComparisonOper32=predicateComparisonOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateOperEx;
        	        }

        	        {

        	                  return predicateComparisonOper32;
        	                
        	        }

        	    }
        	    break;
        	case 6:
        	    // VaeQueryLanguageTreeParser.g:404:5: predicateRangeOper
        	    {
        	        FOLLOWPUSH(FOLLOW_predicateRangeOper_in_predicateOper1064);
        	        predicateRangeOper33=predicateRangeOper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicateOperEx;
        	        }

        	        {

        	                  return predicateRangeOper33;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateOperEx; /* Prevent compiler warnings */
    rulepredicateOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateOper */

/** 
 * $ANTLR start predicatePath
 * VaeQueryLanguageTreeParser.g:410:1: predicatePath returns [ pANTLR3_STRING result ] : ( slash | ^( AT p= predicatePath ) | ^( NODE_PATHREF evaledExpr ) | NAME );
 */
static pANTLR3_STRING
predicatePath(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    AT35;
    pANTLR3_BASE_TREE    NAME37;
    pANTLR3_STRING p;
    #undef	RETURN_TYPE_p
    #define	RETURN_TYPE_p pANTLR3_STRING

    pANTLR3_STRING slash34;
    #undef	RETURN_TYPE_slash34
    #define	RETURN_TYPE_slash34 pANTLR3_STRING

    pANTLR3_STRING evaledExpr36;
    #undef	RETURN_TYPE_evaledExpr36
    #define	RETURN_TYPE_evaledExpr36 pANTLR3_STRING

    /* Initialize rule variables
     */


    AT35       = NULL;
    NAME37       = NULL;
    p = NULL;
    slash34 = NULL;
    evaledExpr36 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:412:3: ( slash | ^( AT p= predicatePath ) | ^( NODE_PATHREF evaledExpr ) | NAME )
            
            ANTLR3_UINT32 alt15;

            alt15=4;

            switch ( LA(1) ) 
            {
            case NODE_ABSOLUTE:
            case SLASH:
            	{
            		alt15=1;
            	}
                break;
            case AT:
            	{
            		alt15=2;
            	}
                break;
            case NODE_PATHREF:
            	{
            		alt15=3;
            	}
                break;
            case NAME:
            	{
            		alt15=4;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 15;
                EXCEPTION->state        = 0;


                goto rulepredicatePathEx;
            }

            switch (alt15) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:412:5: slash
        	    {
        	        FOLLOWPUSH(FOLLOW_slash_in_predicatePath1087);
        	        slash34=slash(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }

        	        {

        	                  result= slash34;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:416:5: ^( AT p= predicatePath )
        	    {
        	        AT35 = (pANTLR3_BASE_TREE) MATCHT(AT, &FOLLOW_AT_in_predicatePath1100); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_predicatePath_in_predicatePath1104);
        	        p=predicatePath(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }

        	        {

        	                  result= (AT35->getText(AT35));
        	                  result->appendS(result, p);
        	                
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:421:5: ^( NODE_PATHREF evaledExpr )
        	    {
        	         MATCHT(NODE_PATHREF, &FOLLOW_NODE_PATHREF_in_predicatePath1118); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_evaledExpr_in_predicatePath1120);
        	        evaledExpr36=evaledExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }

        	        {

        	                  result= evaledExpr36;
        	            	    escapeApos(result);
        	                
        	        }

        	    }
        	    break;
        	case 4:
        	    // VaeQueryLanguageTreeParser.g:426:5: NAME
        	    {
        	        NAME37 = (pANTLR3_BASE_TREE) MATCHT(NAME, &FOLLOW_NAME_in_predicatePath1133); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulepredicatePathEx;
        	        }

        	        {

        	                  result= (NAME37->getText(NAME37));
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicatePathEx; /* Prevent compiler warnings */
    rulepredicatePathEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicatePath */

/** 
 * $ANTLR start predicateEqualityOper
 * VaeQueryLanguageTreeParser.g:432:1: predicateEqualityOper returns [ pANTLR3_STRING result ] : ^( equalityOper p1= predicateExpr p2= predicateExpr ) ;
 */
static pANTLR3_STRING
predicateEqualityOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    p1 = NULL;
    p2 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:434:3: ( ^( equalityOper p1= predicateExpr p2= predicateExpr ) )
        // VaeQueryLanguageTreeParser.g:434:5: ^( equalityOper p1= predicateExpr p2= predicateExpr )
        {
            FOLLOWPUSH(FOLLOW_equalityOper_in_predicateEqualityOper1159);
            equalityOper(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateEqualityOperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateEqualityOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateEqualityOper1163);
            p1=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateEqualityOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateEqualityOper1167);
            p2=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateEqualityOperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateEqualityOperEx;
            }

            {

                	    result= predicateResult(p1, p2, "=");
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateEqualityOperEx; /* Prevent compiler warnings */
    rulepredicateEqualityOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateEqualityOper */

/** 
 * $ANTLR start predicateInequalityOper
 * VaeQueryLanguageTreeParser.g:440:1: predicateInequalityOper returns [ pANTLR3_STRING result ] : ^( inequalityOper p1= predicateExpr p2= predicateExpr ) ;
 */
static pANTLR3_STRING
predicateInequalityOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    p1 = NULL;
    p2 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:442:3: ( ^( inequalityOper p1= predicateExpr p2= predicateExpr ) )
        // VaeQueryLanguageTreeParser.g:442:5: ^( inequalityOper p1= predicateExpr p2= predicateExpr )
        {
            FOLLOWPUSH(FOLLOW_inequalityOper_in_predicateInequalityOper1191);
            inequalityOper(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateInequalityOperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateInequalityOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateInequalityOper1195);
            p1=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateInequalityOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateInequalityOper1199);
            p2=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateInequalityOperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateInequalityOperEx;
            }

            {

                	    result= predicateResult(p1, p2, "!=");
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateInequalityOperEx; /* Prevent compiler warnings */
    rulepredicateInequalityOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateInequalityOper */

/** 
 * $ANTLR start predicateAndOper
 * VaeQueryLanguageTreeParser.g:448:1: predicateAndOper returns [ pANTLR3_STRING result ] : ^( andOper p1= predicateExpr p2= predicateExpr ) ;
 */
static pANTLR3_STRING
predicateAndOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    p1 = NULL;
    p2 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:450:3: ( ^( andOper p1= predicateExpr p2= predicateExpr ) )
        // VaeQueryLanguageTreeParser.g:450:5: ^( andOper p1= predicateExpr p2= predicateExpr )
        {
            FOLLOWPUSH(FOLLOW_andOper_in_predicateAndOper1223);
            andOper(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateAndOperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateAndOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateAndOper1227);
            p1=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateAndOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateAndOper1231);
            p2=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateAndOperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateAndOperEx;
            }

            {

                	    result= predicateResult(p1, p2, " and ");
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateAndOperEx; /* Prevent compiler warnings */
    rulepredicateAndOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateAndOper */

/** 
 * $ANTLR start predicateOrOper
 * VaeQueryLanguageTreeParser.g:456:1: predicateOrOper returns [ pANTLR3_STRING result ] : ^( orOper p1= predicateExpr p2= predicateExpr ) ;
 */
static pANTLR3_STRING
predicateOrOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    p1 = NULL;
    p2 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:458:3: ( ^( orOper p1= predicateExpr p2= predicateExpr ) )
        // VaeQueryLanguageTreeParser.g:458:5: ^( orOper p1= predicateExpr p2= predicateExpr )
        {
            FOLLOWPUSH(FOLLOW_orOper_in_predicateOrOper1255);
            orOper(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateOrOperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateOrOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateOrOper1259);
            p1=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateOrOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateOrOper1263);
            p2=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateOrOperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateOrOperEx;
            }

            {

                	    result= predicateResult(p1, p2, " or ");
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateOrOperEx; /* Prevent compiler warnings */
    rulepredicateOrOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateOrOper */

/** 
 * $ANTLR start predicateComparisonOper
 * VaeQueryLanguageTreeParser.g:464:1: predicateComparisonOper returns [ pANTLR3_STRING result ] : ^( comparisonOper p1= predicateExpr p2= predicateExpr ) ;
 */
static pANTLR3_STRING
predicateComparisonOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    VaeQueryLanguageTreeParser_comparisonOper_return comparisonOper38;
    #undef	RETURN_TYPE_comparisonOper38
    #define	RETURN_TYPE_comparisonOper38 VaeQueryLanguageTreeParser_comparisonOper_return

    /* Initialize rule variables
     */


    p1 = NULL;
    p2 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:466:3: ( ^( comparisonOper p1= predicateExpr p2= predicateExpr ) )
        // VaeQueryLanguageTreeParser.g:466:5: ^( comparisonOper p1= predicateExpr p2= predicateExpr )
        {
            FOLLOWPUSH(FOLLOW_comparisonOper_in_predicateComparisonOper1287);
            comparisonOper38=comparisonOper(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateComparisonOperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateComparisonOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateComparisonOper1291);
            p1=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateComparisonOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateComparisonOper1295);
            p2=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateComparisonOperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateComparisonOperEx;
            }

            {

                	    result= predicateResult(p1, p2, (STRSTREAM->toStringSS(STRSTREAM, comparisonOper38.start, comparisonOper38.start))->chars);
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateComparisonOperEx; /* Prevent compiler warnings */
    rulepredicateComparisonOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateComparisonOper */

/** 
 * $ANTLR start predicateRangeOper
 * VaeQueryLanguageTreeParser.g:472:1: predicateRangeOper returns [ pANTLR3_STRING result ] : ^( COLON p1= predicateExpr p2= rangeFunction ) ;
 */
static pANTLR3_STRING
predicateRangeOper(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    COLON39;
    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    VaeQueryLanguageTreeParser_rangeFunction_return p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 VaeQueryLanguageTreeParser_rangeFunction_return

    /* Initialize rule variables
     */


    COLON39       = NULL;
    p1 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:474:3: ( ^( COLON p1= predicateExpr p2= rangeFunction ) )
        // VaeQueryLanguageTreeParser.g:474:5: ^( COLON p1= predicateExpr p2= rangeFunction )
        {
            COLON39 = (pANTLR3_BASE_TREE) MATCHT(COLON, &FOLLOW_COLON_in_predicateRangeOper1319); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateRangeOperEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateRangeOperEx;
            }

            FOLLOWPUSH(FOLLOW_predicateExpr_in_predicateRangeOper1323);
            p1=predicateExpr(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateRangeOperEx;
            }

            FOLLOWPUSH(FOLLOW_rangeFunction_in_predicateRangeOper1327);
            p2=rangeFunction(ctx);

            FOLLOWPOP();
            if  (HASEXCEPTION())
            {
                goto rulepredicateRangeOperEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulepredicateRangeOperEx;
            }

            {

                      result= newStr(COLON39, p1->chars);
                      if (strcmp(p2.lowResult->chars, "") && strcmp(p2.highResult->chars, "")) {
                        result->append8(result, ">='");
                        result->appendS(result, p2.lowResult);
                        result->append8(result, "'][");
                        result->appendS(result, p1);
                        result->append8(result, "<'");
                        result->appendS(result, p2.highResult);
                        result->append8(result, "'");
                      } else {
                        result->append8(result, "='0'");
                      }
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulepredicateRangeOperEx; /* Prevent compiler warnings */
    rulepredicateRangeOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end predicateRangeOper */

/** 
 * $ANTLR start rangeFunction
 * VaeQueryLanguageTreeParser.g:491:1: rangeFunction returns [ pANTLR3_STRING lowResult, pANTLR3_STRING highResult ] : ^( NODE_FUNCTION FUNCTION ( expressionList )? ) ;
 */
static VaeQueryLanguageTreeParser_rangeFunction_return
rangeFunction(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_rangeFunction_return retval;

    pANTLR3_BASE_TREE    FUNCTION40;

    /* Initialize rule variables
     */


    FUNCTION40       = NULL;
    retval.start = LT(1); retval.stop = retval.start;

    {
        // VaeQueryLanguageTreeParser.g:493:2: ( ^( NODE_FUNCTION FUNCTION ( expressionList )? ) )
        // VaeQueryLanguageTreeParser.g:493:4: ^( NODE_FUNCTION FUNCTION ( expressionList )? )
        {
             MATCHT(NODE_FUNCTION, &FOLLOW_NODE_FUNCTION_in_rangeFunction1350); 
            if  (HASEXCEPTION())
            {
                goto rulerangeFunctionEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulerangeFunctionEx;
            }

            FUNCTION40 = (pANTLR3_BASE_TREE) MATCHT(FUNCTION, &FOLLOW_FUNCTION_in_rangeFunction1352); 
            if  (HASEXCEPTION())
            {
                goto rulerangeFunctionEx;
            }

            {

                	      functionArgCount = 0;
                        functionArgList[0] = NULL;
                	    
            }

            // VaeQueryLanguageTreeParser.g:498:6: ( expressionList )?
            {
                int alt16=2;
                switch ( LA(1) ) 
                {
                    case NODE_FUNCTION:
                    case NODE_PATH:
                    case NODE_SQL:
                    case NODE_VALUE:
                    case DIV:
                    case MULT:
                    case EQUALITY:
                    case EQUALITY_ALT:
                    case INEQUALITY:
                    case INEQUALITY_ALT:
                    case LESS:
                    case LTE:
                    case GREATER:
                    case GTE:
                    case AND:
                    case OR:
                    case XOR:
                    case NOT:
                    case ADD_TOK:
                    case SUB:
                    case MOD:
                    case IFTRUE:
                    case COMMA:
                    case AND_ALT:
                    case OR_ALT:
                    case XOR_ALT:
                    	{
                    		alt16=1;
                    	}
                        break;
                }

                switch (alt16) 
                {
            	case 1:
            	    // VaeQueryLanguageTreeParser.g:498:6: expressionList
            	    {
            	        FOLLOWPUSH(FOLLOW_expressionList_in_rangeFunction1367);
            	        expressionList(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulerangeFunctionEx;
            	        }


            	    }
            	    break;

                }
            }

            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulerangeFunctionEx;
            }

            {

                	    RangeFunctionRange ret = resolveRangeFunction((FUNCTION40->getText(FUNCTION40))->subString((FUNCTION40->getText(FUNCTION40)), 0, strlen((FUNCTION40->getText(FUNCTION40))->chars) - 1)->chars, functionArgList);
                	    retval.lowResult= longResponse(ret.low, FUNCTION40);
                	    retval.highResult= longResponse(ret.high, FUNCTION40);
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulerangeFunctionEx; /* Prevent compiler warnings */
    rulerangeFunctionEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end rangeFunction */

/** 
 * $ANTLR start rootExpr
 * VaeQueryLanguageTreeParser.g:507:1: rootExpr returns [ pANTLR3_STRING result, int isPath ] : ( oper | value );
 */
static VaeQueryLanguageTreeParser_rootExpr_return
rootExpr(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_rootExpr_return retval;

    VaeQueryLanguageTreeParser_oper_return oper41;
    #undef	RETURN_TYPE_oper41
    #define	RETURN_TYPE_oper41 VaeQueryLanguageTreeParser_oper_return

    VaeQueryLanguageTreeParser_value_return value42;
    #undef	RETURN_TYPE_value42
    #define	RETURN_TYPE_value42 VaeQueryLanguageTreeParser_value_return

    /* Initialize rule variables
     */


    retval.start = LT(1); retval.stop = retval.start;

    {
        {
            //  VaeQueryLanguageTreeParser.g:509:3: ( oper | value )
            
            ANTLR3_UINT32 alt17;

            alt17=2;

            switch ( LA(1) ) 
            {
            case DIV:
            case MULT:
            case EQUALITY:
            case EQUALITY_ALT:
            case INEQUALITY:
            case INEQUALITY_ALT:
            case LESS:
            case LTE:
            case GREATER:
            case GTE:
            case AND:
            case OR:
            case XOR:
            case NOT:
            case ADD_TOK:
            case SUB:
            case MOD:
            case IFTRUE:
            case AND_ALT:
            case OR_ALT:
            case XOR_ALT:
            	{
            		alt17=1;
            	}
                break;
            case NODE_FUNCTION:
            case NODE_VALUE:
            	{
            		alt17=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 17;
                EXCEPTION->state        = 0;


                goto rulerootExprEx;
            }

            switch (alt17) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:509:5: oper
        	    {
        	        FOLLOWPUSH(FOLLOW_oper_in_rootExpr1395);
        	        oper41=oper(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootExprEx;
        	        }

        	        {

        	                  retval.isPath= oper41.isPath;
        	                  retval.result= oper41.result;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:514:5: value
        	    {
        	        FOLLOWPUSH(FOLLOW_value_in_rootExpr1407);
        	        value42=value(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootExprEx;
        	        }

        	        {

        	                  retval.isPath= value42.isPath;
        	                  retval.result= value42.result;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulerootExprEx; /* Prevent compiler warnings */
    rulerootExprEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end rootExpr */

/** 
 * $ANTLR start rootPath
 * VaeQueryLanguageTreeParser.g:521:1: rootPath returns [ pANTLR3_STRING result, int isPath ] : ( ^( NODE_SQL path ) | ^( NODE_PATH path ) );
 */
static VaeQueryLanguageTreeParser_rootPath_return
rootPath(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_rootPath_return retval;

    pANTLR3_BASE_TREE    NODE_SQL43;
    pANTLR3_STRING path44;
    #undef	RETURN_TYPE_path44
    #define	RETURN_TYPE_path44 pANTLR3_STRING

    pANTLR3_STRING path45;
    #undef	RETURN_TYPE_path45
    #define	RETURN_TYPE_path45 pANTLR3_STRING

    /* Initialize rule variables
     */


    NODE_SQL43       = NULL;
    path44 = NULL;
    path45 = NULL;
    retval.start = LT(1); retval.stop = retval.start;

    {
        {
            //  VaeQueryLanguageTreeParser.g:523:3: ( ^( NODE_SQL path ) | ^( NODE_PATH path ) )
            
            ANTLR3_UINT32 alt18;

            alt18=2;

            switch ( LA(1) ) 
            {
            case NODE_SQL:
            	{
            		alt18=1;
            	}
                break;
            case NODE_PATH:
            	{
            		alt18=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 18;
                EXCEPTION->state        = 0;


                goto rulerootPathEx;
            }

            switch (alt18) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:523:5: ^( NODE_SQL path )
        	    {
        	        NODE_SQL43 = (pANTLR3_BASE_TREE) MATCHT(NODE_SQL, &FOLLOW_NODE_SQL_in_rootPath1433); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_rootPath1435);
        	        path44=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }

        	        {

        	                  retval.result= newStr(NODE_SQL43, "~");
        	                  retval.result->appendS(retval.result, path44);
        	                  retval.isPath= 1;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:529:5: ^( NODE_PATH path )
        	    {
        	         MATCHT(NODE_PATH, &FOLLOW_NODE_PATH_in_rootPath1449); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_rootPath1451);
        	        path45=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulerootPathEx;
        	        }

        	        {

        	                  retval.isPath= 1;
        	                  retval.result= path45;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulerootPathEx; /* Prevent compiler warnings */
    rulerootPathEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end rootPath */

/** 
 * $ANTLR start slash
 * VaeQueryLanguageTreeParser.g:536:1: slash returns [ pANTLR3_STRING result ] : ( ^( NODE_ABSOLUTE p3= path ) | ^( SLASH p1= path p2= path ) );
 */
static pANTLR3_STRING
slash(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING p3;
    #undef	RETURN_TYPE_p3
    #define	RETURN_TYPE_p3 pANTLR3_STRING

    pANTLR3_STRING p1;
    #undef	RETURN_TYPE_p1
    #define	RETURN_TYPE_p1 pANTLR3_STRING

    pANTLR3_STRING p2;
    #undef	RETURN_TYPE_p2
    #define	RETURN_TYPE_p2 pANTLR3_STRING

    /* Initialize rule variables
     */


    p3 = NULL;
    p1 = NULL;
    p2 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:538:3: ( ^( NODE_ABSOLUTE p3= path ) | ^( SLASH p1= path p2= path ) )
            
            ANTLR3_UINT32 alt19;

            alt19=2;

            switch ( LA(1) ) 
            {
            case NODE_ABSOLUTE:
            	{
            		alt19=1;
            	}
                break;
            case SLASH:
            	{
            		alt19=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 19;
                EXCEPTION->state        = 0;


                goto ruleslashEx;
            }

            switch (alt19) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:538:5: ^( NODE_ABSOLUTE p3= path )
        	    {
        	         MATCHT(NODE_ABSOLUTE, &FOLLOW_NODE_ABSOLUTE_in_slash1481); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_slash1485);
        	        p3=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }

        	        {

        	                  result= p3;
        	                  result->insert8(result, 0, "/");
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:543:5: ^( SLASH p1= path p2= path )
        	    {
        	         MATCHT(SLASH, &FOLLOW_SLASH_in_slash1499); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_slash1503);
        	        p1=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_path_in_slash1507);
        	        p2=path(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto ruleslashEx;
        	        }

        	        {

        	                  result= p1;
        	                  result->append8(result, "/");
        	                  result->appendS(result, p2);
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto ruleslashEx; /* Prevent compiler warnings */
    ruleslashEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end slash */

/** 
 * $ANTLR start value
 * VaeQueryLanguageTreeParser.g:551:1: value returns [ pANTLR3_STRING result, int isPath, int isBlankVariable ] : ( ^( NODE_VALUE STRING ) | ^( NODE_VALUE FLOAT ) | ^( NODE_VALUE INT ) | variable | function );
 */
static VaeQueryLanguageTreeParser_value_return
value(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_value_return retval;

    pANTLR3_BASE_TREE    STRING46;
    pANTLR3_BASE_TREE    FLOAT47;
    pANTLR3_BASE_TREE    INT48;
    pANTLR3_STRING variable49;
    #undef	RETURN_TYPE_variable49
    #define	RETURN_TYPE_variable49 pANTLR3_STRING

    pANTLR3_STRING function50;
    #undef	RETURN_TYPE_function50
    #define	RETURN_TYPE_function50 pANTLR3_STRING

    /* Initialize rule variables
     */


    STRING46       = NULL;
    FLOAT47       = NULL;
    INT48       = NULL;
    variable49 = NULL;
    function50 = NULL;
    retval.start = LT(1); retval.stop = retval.start;

    {
        {
            //  VaeQueryLanguageTreeParser.g:553:3: ( ^( NODE_VALUE STRING ) | ^( NODE_VALUE FLOAT ) | ^( NODE_VALUE INT ) | variable | function )
            
            ANTLR3_UINT32 alt20;

            alt20=5;

            switch ( LA(1) ) 
            {
            case NODE_VALUE:
            	{
            		switch ( LA(2) ) 
            		{
            		case DOWN:
            			{
            				switch ( LA(3) ) 
            				{
            				case STRING:
            					{
            						alt20=1;
            					}
            				    break;
            				case FLOAT:
            					{
            						alt20=2;
            					}
            				    break;
            				case INT:
            					{
            						alt20=3;
            					}
            				    break;
            				case VARIABLE:
            					{
            						alt20=4;
            					}
            				    break;

            				default:
            				    CONSTRUCTEX();
            				    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            				    EXCEPTION->message      = (void *)"";
            				    EXCEPTION->decisionNum  = 20;
            				    EXCEPTION->state        = 3;


            				    goto rulevalueEx;
            				}

            			}
            		    break;

            		default:
            		    CONSTRUCTEX();
            		    EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
            		    EXCEPTION->message      = (void *)"";
            		    EXCEPTION->decisionNum  = 20;
            		    EXCEPTION->state        = 1;


            		    goto rulevalueEx;
            		}

            	}
                break;
            case NODE_FUNCTION:
            	{
            		alt20=5;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 20;
                EXCEPTION->state        = 0;


                goto rulevalueEx;
            }

            switch (alt20) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:553:5: ^( NODE_VALUE STRING )
        	    {
        	         MATCHT(NODE_VALUE, &FOLLOW_NODE_VALUE_in_value1533); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        STRING46 = (pANTLR3_BASE_TREE) MATCHT(STRING, &FOLLOW_STRING_in_value1535); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.isBlankVariable= 0;
        	                  retval.result= (STRING46->getText(STRING46))->subString((STRING46->getText(STRING46)), 1, strlen((STRING46->getText(STRING46))->chars) - 1);
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:559:5: ^( NODE_VALUE FLOAT )
        	    {
        	         MATCHT(NODE_VALUE, &FOLLOW_NODE_VALUE_in_value1549); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        FLOAT47 = (pANTLR3_BASE_TREE) MATCHT(FLOAT, &FOLLOW_FLOAT_in_value1551); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.isBlankVariable= 0;
        	                  retval.result= (FLOAT47->getText(FLOAT47));
        	                
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:565:5: ^( NODE_VALUE INT )
        	    {
        	         MATCHT(NODE_VALUE, &FOLLOW_NODE_VALUE_in_value1565); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        INT48 = (pANTLR3_BASE_TREE) MATCHT(INT, &FOLLOW_INT_in_value1567); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        {

        	                  retval.isPath= 2;
        	                  retval.isBlankVariable= 0;
        	                  retval.result= (INT48->getText(INT48));
        	                
        	        }

        	    }
        	    break;
        	case 4:
        	    // VaeQueryLanguageTreeParser.g:571:4: variable
        	    {
        	        FOLLOWPUSH(FOLLOW_variable_in_value1579);
        	        variable49=variable(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	            	    retval.result= variable49;
        	                  retval.isBlankVariable= (strlen(retval.result->chars) == 0);
        	            	  
        	        }

        	    }
        	    break;
        	case 5:
        	    // VaeQueryLanguageTreeParser.g:577:4: function
        	    {
        	        FOLLOWPUSH(FOLLOW_function_in_value1589);
        	        function50=function(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulevalueEx;
        	        }

        	        {

        	                  retval.isPath= 0;
        	                  retval.isBlankVariable= 0;
        	            	    retval.result= function50;
        	            	  
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulevalueEx; /* Prevent compiler warnings */
    rulevalueEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end value */

/** 
 * $ANTLR start variable
 * VaeQueryLanguageTreeParser.g:585:1: variable returns [ pANTLR3_STRING result ] : ^( NODE_VALUE VARIABLE ) ;
 */
static pANTLR3_STRING
variable(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    VARIABLE51;

    /* Initialize rule variables
     */


    VARIABLE51       = NULL;

    {
        // VaeQueryLanguageTreeParser.g:587:3: ( ^( NODE_VALUE VARIABLE ) )
        // VaeQueryLanguageTreeParser.g:587:5: ^( NODE_VALUE VARIABLE )
        {
             MATCHT(NODE_VALUE, &FOLLOW_NODE_VALUE_in_variable1613); 
            if  (HASEXCEPTION())
            {
                goto rulevariableEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulevariableEx;
            }

            VARIABLE51 = (pANTLR3_BASE_TREE) MATCHT(VARIABLE, &FOLLOW_VARIABLE_in_variable1615); 
            if  (HASEXCEPTION())
            {
                goto rulevariableEx;
            }


            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulevariableEx;
            }

            {

                      result= (VARIABLE51->getText(VARIABLE51))->subString((VARIABLE51->getText(VARIABLE51)), 1, strlen((VARIABLE51->getText(VARIABLE51))->chars));
                      char *value = resolveVariable(result->chars);
                      result->set8(result, value);
                      free(value);
                    
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulevariableEx; /* Prevent compiler warnings */
    rulevariableEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end variable */

/** 
 * $ANTLR start xpathExpr
 * VaeQueryLanguageTreeParser.g:596:1: xpathExpr returns [ pANTLR3_STRING result ] : ( ^( NODE_PATH predicatePath ) | xpathFunction | value );
 */
static pANTLR3_STRING
xpathExpr(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING predicatePath52;
    #undef	RETURN_TYPE_predicatePath52
    #define	RETURN_TYPE_predicatePath52 pANTLR3_STRING

    pANTLR3_STRING xpathFunction53;
    #undef	RETURN_TYPE_xpathFunction53
    #define	RETURN_TYPE_xpathFunction53 pANTLR3_STRING

    VaeQueryLanguageTreeParser_value_return value54;
    #undef	RETURN_TYPE_value54
    #define	RETURN_TYPE_value54 VaeQueryLanguageTreeParser_value_return

    /* Initialize rule variables
     */


    predicatePath52 = NULL;
    xpathFunction53 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:598:3: ( ^( NODE_PATH predicatePath ) | xpathFunction | value )
            
            ANTLR3_UINT32 alt21;

            alt21=3;

            switch ( LA(1) ) 
            {
            case NODE_PATH:
            	{
            		alt21=1;
            	}
                break;
            case NODE_XPATHFUNCTION:
            	{
            		alt21=2;
            	}
                break;
            case NODE_FUNCTION:
            case NODE_VALUE:
            	{
            		alt21=3;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 21;
                EXCEPTION->state        = 0;


                goto rulexpathExprEx;
            }

            switch (alt21) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:598:5: ^( NODE_PATH predicatePath )
        	    {
        	         MATCHT(NODE_PATH, &FOLLOW_NODE_PATH_in_xpathExpr1642); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathExprEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathExprEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_predicatePath_in_xpathExpr1644);
        	        predicatePath52=predicatePath(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathExprEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathExprEx;
        	        }

        	        {

        	                  result= predicatePath52;
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:602:5: xpathFunction
        	    {
        	        FOLLOWPUSH(FOLLOW_xpathFunction_in_xpathExpr1657);
        	        xpathFunction53=xpathFunction(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathExprEx;
        	        }

        	        {

        	            	    result= xpathFunction53;
        	            	  
        	        }

        	    }
        	    break;
        	case 3:
        	    // VaeQueryLanguageTreeParser.g:606:5: value
        	    {
        	        FOLLOWPUSH(FOLLOW_value_in_xpathExpr1668);
        	        value54=value(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathExprEx;
        	        }

        	        {

        	            	    result= value54.result;
        	            	    escapeApos(result);
        	            	  
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulexpathExprEx; /* Prevent compiler warnings */
    rulexpathExprEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end xpathExpr */

/** 
 * $ANTLR start xpathFunction
 * VaeQueryLanguageTreeParser.g:613:1: xpathFunction returns [ pANTLR3_STRING result ] : ^( NODE_XPATHFUNCTION XPATH_FUNCTION ( xpathFunctionExpression )? ) ;
 */
static pANTLR3_STRING
xpathFunction(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_BASE_TREE    XPATH_FUNCTION55;
    pANTLR3_STRING xpathFunctionExpression56;
    #undef	RETURN_TYPE_xpathFunctionExpression56
    #define	RETURN_TYPE_xpathFunctionExpression56 pANTLR3_STRING

    /* Initialize rule variables
     */


    XPATH_FUNCTION55       = NULL;
    xpathFunctionExpression56 = NULL;

    {
        // VaeQueryLanguageTreeParser.g:615:2: ( ^( NODE_XPATHFUNCTION XPATH_FUNCTION ( xpathFunctionExpression )? ) )
        // VaeQueryLanguageTreeParser.g:615:4: ^( NODE_XPATHFUNCTION XPATH_FUNCTION ( xpathFunctionExpression )? )
        {
             MATCHT(NODE_XPATHFUNCTION, &FOLLOW_NODE_XPATHFUNCTION_in_xpathFunction1692); 
            if  (HASEXCEPTION())
            {
                goto rulexpathFunctionEx;
            }


            MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulexpathFunctionEx;
            }

            XPATH_FUNCTION55 = (pANTLR3_BASE_TREE) MATCHT(XPATH_FUNCTION, &FOLLOW_XPATH_FUNCTION_in_xpathFunction1694); 
            if  (HASEXCEPTION())
            {
                goto rulexpathFunctionEx;
            }


            // VaeQueryLanguageTreeParser.g:615:40: ( xpathFunctionExpression )?
            {
                int alt22=2;
                switch ( LA(1) ) 
                {
                    case NODE_FUNCTION:
                    case NODE_PATH:
                    case NODE_VALUE:
                    case NODE_XPATHFUNCTION:
                    case COMMA:
                    	{
                    		alt22=1;
                    	}
                        break;
                }

                switch (alt22) 
                {
            	case 1:
            	    // VaeQueryLanguageTreeParser.g:615:40: xpathFunctionExpression
            	    {
            	        FOLLOWPUSH(FOLLOW_xpathFunctionExpression_in_xpathFunction1696);
            	        xpathFunctionExpression56=xpathFunctionExpression(ctx);

            	        FOLLOWPOP();
            	        if  (HASEXCEPTION())
            	        {
            	            goto rulexpathFunctionEx;
            	        }


            	    }
            	    break;

                }
            }

            MATCHT(ANTLR3_TOKEN_UP, NULL); 
            if  (HASEXCEPTION())
            {
                goto rulexpathFunctionEx;
            }

            {

                	    result= (XPATH_FUNCTION55->getText(XPATH_FUNCTION55));
                	    result->appendS(result, xpathFunctionExpression56);
                	    result->append8(result, ")");
                	  
            }

        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulexpathFunctionEx; /* Prevent compiler warnings */
    rulexpathFunctionEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end xpathFunction */

/** 
 * $ANTLR start xpathFunctionExpression
 * VaeQueryLanguageTreeParser.g:623:1: xpathFunctionExpression returns [ pANTLR3_STRING result ] : ( ^( COMMA x1= xpathFunctionExpression x2= xpathFunctionExpression ) | xpathExpr );
 */
static pANTLR3_STRING
xpathFunctionExpression(pVaeQueryLanguageTreeParser ctx)
{   
    pANTLR3_STRING result = NULL;

    pANTLR3_STRING x1;
    #undef	RETURN_TYPE_x1
    #define	RETURN_TYPE_x1 pANTLR3_STRING

    pANTLR3_STRING x2;
    #undef	RETURN_TYPE_x2
    #define	RETURN_TYPE_x2 pANTLR3_STRING

    pANTLR3_STRING xpathExpr57;
    #undef	RETURN_TYPE_xpathExpr57
    #define	RETURN_TYPE_xpathExpr57 pANTLR3_STRING

    /* Initialize rule variables
     */


    x1 = NULL;
    x2 = NULL;
    xpathExpr57 = NULL;

    {
        {
            //  VaeQueryLanguageTreeParser.g:625:3: ( ^( COMMA x1= xpathFunctionExpression x2= xpathFunctionExpression ) | xpathExpr )
            
            ANTLR3_UINT32 alt23;

            alt23=2;

            switch ( LA(1) ) 
            {
            case COMMA:
            	{
            		alt23=1;
            	}
                break;
            case NODE_FUNCTION:
            case NODE_PATH:
            case NODE_VALUE:
            case NODE_XPATHFUNCTION:
            	{
            		alt23=2;
            	}
                break;

            default:
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
                EXCEPTION->message      = (void *)"";
                EXCEPTION->decisionNum  = 23;
                EXCEPTION->state        = 0;


                goto rulexpathFunctionExpressionEx;
            }

            switch (alt23) 
            {
        	case 1:
        	    // VaeQueryLanguageTreeParser.g:625:5: ^( COMMA x1= xpathFunctionExpression x2= xpathFunctionExpression )
        	    {
        	         MATCHT(COMMA, &FOLLOW_COMMA_in_xpathFunctionExpression1721); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathFunctionExpressionEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_DOWN, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathFunctionExpressionEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1725);
        	        x1=xpathFunctionExpression(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathFunctionExpressionEx;
        	        }

        	        FOLLOWPUSH(FOLLOW_xpathFunctionExpression_in_xpathFunctionExpression1729);
        	        x2=xpathFunctionExpression(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathFunctionExpressionEx;
        	        }


        	        MATCHT(ANTLR3_TOKEN_UP, NULL); 
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathFunctionExpressionEx;
        	        }

        	        {

        	                  result= x1;
        	                  result->append8(result, ",");
        	                  result->appendS(result, x2);
        	                
        	        }

        	    }
        	    break;
        	case 2:
        	    // VaeQueryLanguageTreeParser.g:631:5: xpathExpr
        	    {
        	        FOLLOWPUSH(FOLLOW_xpathExpr_in_xpathFunctionExpression1743);
        	        xpathExpr57=xpathExpr(ctx);

        	        FOLLOWPOP();
        	        if  (HASEXCEPTION())
        	        {
        	            goto rulexpathFunctionExpressionEx;
        	        }

        	        {

        	                  result= xpathExpr57;
        	                
        	        }

        	    }
        	    break;

            }
        }
    }
    

    // This is where rules clean up and exit
    //
    goto rulexpathFunctionExpressionEx; /* Prevent compiler warnings */
    rulexpathFunctionExpressionEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return result;
}
/* $ANTLR end xpathFunctionExpression */

/** 
 * $ANTLR start andOper
 * VaeQueryLanguageTreeParser.g:637:1: andOper : ( AND | AND_ALT );
 */
static void
andOper(pVaeQueryLanguageTreeParser ctx)
{   
    /* Initialize rule variables
     */


    {
        // VaeQueryLanguageTreeParser.g:638:3: ( AND | AND_ALT )
        // VaeQueryLanguageTreeParser.g:
        {
            if ( LA(1) == AND || LA(1) == AND_ALT )
            {
                CONSUME();
                PERRORRECOVERY=ANTLR3_FALSE;
            }
            else 
            {
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;

                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_andOper0);    goto ruleandOperEx;
            }


        }

    }
    

    // This is where rules clean up and exit
    //
    goto ruleandOperEx; /* Prevent compiler warnings */
    ruleandOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return ;
}
/* $ANTLR end andOper */

/** 
 * $ANTLR start orOper
 * VaeQueryLanguageTreeParser.g:641:1: orOper : ( OR | OR_ALT );
 */
static void
orOper(pVaeQueryLanguageTreeParser ctx)
{   
    /* Initialize rule variables
     */


    {
        // VaeQueryLanguageTreeParser.g:642:3: ( OR | OR_ALT )
        // VaeQueryLanguageTreeParser.g:
        {
            if ( LA(1) == OR || LA(1) == OR_ALT )
            {
                CONSUME();
                PERRORRECOVERY=ANTLR3_FALSE;
            }
            else 
            {
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;

                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_orOper0);    goto ruleorOperEx;
            }


        }

    }
    

    // This is where rules clean up and exit
    //
    goto ruleorOperEx; /* Prevent compiler warnings */
    ruleorOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return ;
}
/* $ANTLR end orOper */

/** 
 * $ANTLR start equalityOper
 * VaeQueryLanguageTreeParser.g:645:1: equalityOper : ( EQUALITY | EQUALITY_ALT );
 */
static void
equalityOper(pVaeQueryLanguageTreeParser ctx)
{   
    /* Initialize rule variables
     */


    {
        // VaeQueryLanguageTreeParser.g:646:2: ( EQUALITY | EQUALITY_ALT )
        // VaeQueryLanguageTreeParser.g:
        {
            if ( ((LA(1) >= EQUALITY) && (LA(1) <= EQUALITY_ALT)) )
            {
                CONSUME();
                PERRORRECOVERY=ANTLR3_FALSE;
            }
            else 
            {
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;

                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_equalityOper0);    goto ruleequalityOperEx;
            }


        }

    }
    

    // This is where rules clean up and exit
    //
    goto ruleequalityOperEx; /* Prevent compiler warnings */
    ruleequalityOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return ;
}
/* $ANTLR end equalityOper */

/** 
 * $ANTLR start inequalityOper
 * VaeQueryLanguageTreeParser.g:649:1: inequalityOper : ( INEQUALITY | INEQUALITY_ALT );
 */
static void
inequalityOper(pVaeQueryLanguageTreeParser ctx)
{   
    /* Initialize rule variables
     */


    {
        // VaeQueryLanguageTreeParser.g:650:2: ( INEQUALITY | INEQUALITY_ALT )
        // VaeQueryLanguageTreeParser.g:
        {
            if ( ((LA(1) >= INEQUALITY) && (LA(1) <= INEQUALITY_ALT)) )
            {
                CONSUME();
                PERRORRECOVERY=ANTLR3_FALSE;
            }
            else 
            {
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;

                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_inequalityOper0);    goto ruleinequalityOperEx;
            }


        }

    }
    

    // This is where rules clean up and exit
    //
    goto ruleinequalityOperEx; /* Prevent compiler warnings */
    ruleinequalityOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return ;
}
/* $ANTLR end inequalityOper */

/** 
 * $ANTLR start comparisonOper
 * VaeQueryLanguageTreeParser.g:653:1: comparisonOper : ( LESS | LTE | GREATER | GTE );
 */
static VaeQueryLanguageTreeParser_comparisonOper_return
comparisonOper(pVaeQueryLanguageTreeParser ctx)
{   
    VaeQueryLanguageTreeParser_comparisonOper_return retval;

    /* Initialize rule variables
     */


    retval.start = LT(1); retval.stop = retval.start;

    {
        // VaeQueryLanguageTreeParser.g:654:3: ( LESS | LTE | GREATER | GTE )
        // VaeQueryLanguageTreeParser.g:
        {
            if ( ((LA(1) >= LESS) && (LA(1) <= GTE)) )
            {
                CONSUME();
                PERRORRECOVERY=ANTLR3_FALSE;
            }
            else 
            {
                CONSTRUCTEX();
                EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;
                EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;

                RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_comparisonOper0);    goto rulecomparisonOperEx;
            }


        }

    }
    

    // This is where rules clean up and exit
    //
    goto rulecomparisonOperEx; /* Prevent compiler warnings */
    rulecomparisonOperEx: ;

            if (HASEXCEPTION())
            {
                PREPORTERROR();
                PRECOVER();
            }


    return retval;
}
/* $ANTLR end comparisonOper */
/* End of parsing rules
 * ==============================================
 */

/* ==============================================
 * Syntactic predicates
 */
/* End of syntactic predicates
 * ==============================================
 */

 
 



/* End of code
 * =============================================================================
 */