/* Copyright (c) 2006, Sun Microsystems, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the Sun Microsystems, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
 */


options {
  MULTI=true;
  VISITOR=true;
  NODE_DEFAULT_VOID=true;
}

PARSER_BEGIN(Expression)

package com.ebmwebsourcing.easybpel.xpath.exp.impl.analyzer;

import com.ebmwebsourcing.easybpel.xpath.exp.api.XPathExpressionException;
import com.ebmwebsourcing.easybpel.xpath.exp.impl.analyzer.ExpressionNode;

/** An Arithmetic Grammar. */
public class Expression {

  /** Main entry point. */
  public static void main(String args[]) {
    System.out.println("Reading from standard input...");
    Expression t = new Expression(System.in);
    try {
      ASTStart n = t.Start();
      ExpressionVisitor v = new ExpressionDumpVisitor(null, null, null);
      n.jjtAccept(v, null);
      System.out.println("Thank you.");
    } catch (Exception e) {
      System.out.println("Oops.");
      System.out.println(e.getMessage());
      e.printStackTrace();
    }
  }
}

PARSER_END(Expression)

/* WHITE SPACE */

SKIP :
{
  " "
| "\t"
| "\n"
| "\r"
| "\r\n"
| "\f"
}

/* COMMENTS */

MORE :
{
  "//" : IN_SINGLE_LINE_COMMENT
|
  <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
|
  "/*" : IN_MULTI_LINE_COMMENT
}



<IN_SINGLE_LINE_COMMENT>
MORE :
{
  < ~[] >
}

<IN_FORMAL_COMMENT>
SPECIAL_TOKEN :
{
  <FORMAL_COMMENT: "*/" > : DEFAULT
}

<IN_MULTI_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <MULTI_LINE_COMMENT: "*/" > : DEFAULT
}

<IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
MORE :
{
  < ~[] >
}

/* RESERVED WORDS */
TOKEN :
{
  < TRUE: "true" >
  
| < ABS: "abs" >
| < ADJUST_DATE_TO_TIMEZONE: "adjust-date-to-timezone" >
| < ADJUST_DATETIME_TO_TIMEZONE: "adjust-dateTime-to-timezone" >
| < ADJUST_TIME_TO_TIMEZONE: "adjust-time-to-timezone" >
| < BASE_URI: "base-uri" >
| < BOOLEAN: "boolean" >
| < CEILING: "ceiling" >
| < CODEPOINT_EQUAL: "codepoint-equal" >
| < CODEPOINTS_TO_STRING: "codepoints-to-string" >
| < COLLECTION: "collection" >
| < COMPARE: "compare" >
| < CONTAINS: "contains" >
| < DATA: "data" >
| < FALSE: "false" >
| < COUNT: "count" >
| < STRING: "string" >
| < NUMBER: "number" >
| < CONCAT: "concat" >
| < CURRENT: "current" >
| < CURRENT_GROUP: "current-group" >
| < CURRENT_GROUPING_KEY: "current-grouping-key" >
| < DOCUMENT: "document" >
| < ELEMENT_AVAILABLE: "element-available" >
| < FORMAT_DATE: "format-date" >
| < FORMAT_DATETIME: "format-dateTime" >
| < FORMAT_NUMBER: "format-number" >
| < FORMAT_TIME: "format-time" >
| < FUNCTION_AVAILABLE: "function-available" >
| < GENERATE_ID: "generate-id" >
| < KEY: "key">
| < REGEX_GROUP: "regex-group" >
| < SYSTEM_PROPERTY: "system-property" >
| < TYPE_AVAILABLE: "type-available" >
| < UNPARSED_ENTITY_PUBLIC_ID: "unparsed-entity-public-id" >
| < UNPARSED_ENTITY_URI: "unparsed-entity-URI" >
| < UNPARSED_TEXT: "unparsed-text" >
| < UNPARSED_TEXT_AVAILABLE: "unparsed-text-available" >
| < DAY_FROM_DATE: "day-from-date" >
| < DAY_FROM_DATETIME: "day-from-dateTime" >
| < DAYS_FROM_DURATION: "days-from-duration" >
| < DEEP_EQUAL: "deep-equal" >
| < DEFAULT_COLLATION: "default-collation" >
| < DISTINCT_VALUES: "distinct-values" >
| < DOC: "doc" >
| < DOC_AVAILABLE: "doc-available">
| < DOCUMENT_URI: "document-uri" >
| < EMPTY: "empty" >
| < ENCODE_FOR_URI: "encode-for-uri" >
| < ENDS_WITH: "ends-with" >
| < ERROR: "error" >
| < ESCAPE_HTML_URI: "escape-html-uri" >
| < EXACTLY_ONE: "exactly-one" >
| < EXISTS: "exists" >
| < HOURS_FROM_DATETIME: "hours-from-dateTime" >
| < HOURS_FROM_DURATION: "hours-from-duration" >
| < HOURS_FROM_TIME: "hours-from-time" >
| < ID: "id" >
| < IDREF: "idref" >
| < IMPLICIT_TIMEZONE: "implicit-timezone" >
| < IN_SCOPE_PREFIXES: "in-scope-prefixes" >
| < INDEX_OF: "index-of" >
| < INSERT_BEFORE: "insert-before" >
| < IRI_TO_URI: "iri-to-uri" >
| < LANG: "lang">
| < LAST: "last" >
| < LOCAL_NAME: "local-name" >
| < LOCAL_NAME_FROM_QNAME: "local-name-from-QName" >
| < LOWER_CASE: "lower-case" >
| < MATCHES: "matches" >
| < MAX: "max" >
| < MINUTES_FROM_DATETIME: "minutes-from-dateTime" >
| < MINUTES_FROM_DURATION: "minutes-from-duration" >
| < MINUTES_FROM_TIME: "minutes-from-time" >
| < MONTH_FROM_DATE: "month-from-date" >
| < MONTH_FROM_DATETIME: "month-from-dateTime" >
| < MONTH_FROM_DURATION: "month-from-duration" >
| < NAME: "name" >
| < NAMESPACE_URI: "namespace-uri" >
| < NAMESPACE_URI_FOR_PREFIX: "namespace-uri-for-prefix" >
| < NAMESPACE_URI_FROM_QNAME: "namespace-uri-from-QName" >
| < NILLED: "nilled" >
| < NODE_NAME: "node-name">
| < NORMALIZE_SPACE: "normalize-space">
| < NORMALIZE_UNICODE: "normalize-unicode" >
| < ONE_OR_MORE: "one-or-more" >
| < POSITION: "position" >
| < PREFIX_FROM_QNAME: "prefix-from-QName" >
| < QNAME: "QName" >
| < REMOVE: "remove" >
| < REPLACE: "replace" >
| < RESOLVE_QNAME: "resolve-QName" >
| < RESOLVE_URI: "resolve-uri" >
| < REVERSE: "reserve" >
| < ROOT: "root" >
| < ROUND: "round" >
| < ROUND_HALF_TO_EVEN: "round-half-to-even" >
| < SECONDS_FROM_DATETIME: "seconds-from-dateTime" >
| < SECONDS_FROM_DURATION: "seconds-from-duration" >
| < SECONDS_FROM_TIME: "seconds-from-time" >
| < STATIC_BASE_URI: "static-base-uri" >
| < STRING_JOIN: "string-join" >
| < STRING_LENGTH: "string-length" >
| < STRING_TO_CODEPOINTS: "string-to-codepoints" >
| < SUBSEQUENCE: "subsequence" >
| < SUBSTRING: "substring" >
| < SUM: "sum" >
| < TIMEZONE_FROM_DATE: "timezone-from-date" >
| < TIMEZONE_FROM_DATETIME: "timezone-from-dateTime" >
| < TIMEZONE_FROM_TIME: "timezone-from-time" >
| < TOKENIZE: "tokenize" >
| < TRACE: "trace" >
| < UNORDERED: "unordered" >
| < UPPER_CASE: "upper-case" >
| < YEAR_FROM_DATE: "year-from-date" >
| < YEAR_FROM_DATETIME: "year-from-dateTime" >
| < YEAR_FROM_DURATION: "year-from-duration" >
| < ZERO_OR_ONE: "zero-or-one" >
| < CURRENT_DATE: "current-date" >
| < CURRENT_DATETIME: "current-dateTime" >
| < CURRENT_TIME: "current-time" >
| < DATETIME: "dateTime" >
| < DO_XSL_TRANSFORM: "doXslTransform" >
| < NOT: "not" >
| < SUBSTRING_BEFORE: "substring-before" >
| < SUBSTRING_AFTER: "substring-after" >
| < TRANSLATE: "translate" >
| < CHILD_NODE: "child::" >
| < TEXT: "text" >
| < NULL: "null" >
}


/* LITERALS */

TOKEN :
{
  < INTEGER_LITERAL:
        <DECIMAL_LITERAL> (["l","L"])?
      | <HEX_LITERAL> (["l","L"])?
      | <OCTAL_LITERAL> (["l","L"])?
  >
|
  < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
|
  < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
|
  < #OCTAL_LITERAL: "0" (["0"-"7"])* >
|
  < FLOATING_POINT_LITERAL:
        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
      | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
      | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
      | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
  >
|
  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
|
  < CHARACTER_LITERAL:
      "'"
      (   (~["'","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\""]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )?
      "'"
  >
|
  < STRING_LITERAL:
      "\""
      (   (~["\"","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\""]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )*
      "\""
  >
}

TOKEN : /* SEPARATORS */
{
  < LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
| < DOLLARS: "$" >
| < AROBASE: "@" >
}

TOKEN : /* OPERATORS */
{
  < GT: ( ">" | "&gt;" ) >
| < LT: ( "<" | "&lt;" ) >
| < EQ: "=" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" >
| < SC_OR: "or" >
| < SC_AND: "and" >
| < INCR: "++" >
| < DECR: "--" >
| < PLUS: "+" >
| < MINUS: "-" >
| < MULT: "*" >
| < DIVIDED: "div" >
| < REM: "mod" >
| < DIV: "/" >
}


/* IDENTIFIERS */

TOKEN :
{
  < IDENTIFIER: <DOLLARS> ( <LETTER>|<DIGIT>|"-" )*  (<DOT>)? ( <LETTER>|<DIGIT>|"-" )* >
|
  < #LETTER:
      [
       "\u0024",
       "\u0041"-"\u005a",
       "\u005f",
       "\u0061"-"\u007a",
       "\u00c0"-"\u00d6",
       "\u00d8"-"\u00f6",
       "\u00f8"-"\u00ff",
       "\u0100"-"\u1fff",
       "\u3040"-"\u318f",
       "\u3300"-"\u337f",
       "\u3400"-"\u3d2d",
       "\u4e00"-"\u9fff",
       "\uf900"-"\ufaff"
      ]
  >
|
  < #DIGIT:
      [
       "\u0030"-"\u0039",
       "\u0660"-"\u0669",
       "\u06f0"-"\u06f9",
       "\u0966"-"\u096f",
       "\u09e6"-"\u09ef",
       "\u0a66"-"\u0a6f",
       "\u0ae6"-"\u0aef",
       "\u0b66"-"\u0b6f",
       "\u0be7"-"\u0bef",
       "\u0c66"-"\u0c6f",
       "\u0ce6"-"\u0cef",
       "\u0d66"-"\u0d6f",
       "\u0e50"-"\u0e59",
       "\u0ed0"-"\u0ed9",
       "\u1040"-"\u1049"
      ]
  >
|
  < PREFIX: (<LETTER> | <DIGIT> |"-")+ (":") >
|
  < ATTRIBUTE: <DIV> <AROBASE> ( (<PREFIX>)? ( <LETTER>|<DIGIT>|"-" )+ ) >
|
  < CHILD: <DIV> ( (<PREFIX>)? ( <LETTER>|<DIGIT>|"-" )+ ) >
| 
  < NAME_TOKEN: ( <LETTER>|<DIGIT>|"-" )+ >
}




/** Main production. */
ASTStart Start()  throws XPathExpressionException  #Start : {}
{
  Expression()
  { return jjtThis; }
}


/*
 * Expression syntax follows.
 */

void Expression() throws XPathExpressionException : {}
{
  ConditionalOrExpression()
}

void ConditionalOrExpression() throws XPathExpressionException  : {}
{
 (
  ConditionalAndExpression() ( <SC_OR> ConditionalAndExpression() )*
  ) #OrExpression(>1)
}

void ConditionalAndExpression() throws XPathExpressionException  : {}
{
 (
  EqualityExpression() ( <SC_AND> EqualityExpression() )*
  ) #AndExpression(>1)
}


void EqualityExpression() throws XPathExpressionException  : {}
{
 (
  InequalityExpression() ( ( <EQ> {jjtThis.setImage("=");} | <NE> {jjtThis.setImage("!=");} ) InequalityExpression() )*
  ) #EqualityExpression(>1)
}

void InequalityExpression() throws XPathExpressionException : { }
{
 (
  AdditiveExpression() ( ( <GT> {jjtThis.setImage(">");} | <LT> {jjtThis.setImage("<");} | <GE> {jjtThis.setImage(">=");} | <LE> {jjtThis.setImage("<=");} ) AdditiveExpression() )*
  ) #InequalityExpression(>1)
}



void AdditiveExpression() throws XPathExpressionException : { }
{
 (
  MultiplicativeExpression() ( ( <PLUS> {jjtThis.setImage("+");} | <MINUS> {jjtThis.setImage("-");}) MultiplicativeExpression() )*
  ) #AdditiveExpression(>1)
}

void MultiplicativeExpression() throws XPathExpressionException  : {}
{
 (
  UnaryExpression() ( (  <MULT> {jjtThis.setImage("*");} | <DIVIDED> {jjtThis.setImage("/");} | <REM> {jjtThis.setImage("%");} ) UnaryExpression() )*
  ) #MultiplicativeExpression(>1)
}


void ArrayExpression() throws XPathExpressionException  : {}
{
 (
  ChildLitteral() ( "[" Expression() "]" )* 
  ) #ArrayExpression(>1)
}


void ChildLitteral()  throws XPathExpressionException  #ChildLitteral : { Token t; }
{
  t=<CHILD>
  {
    jjtThis.setImage(t.image);
  }
}


void AttributeLitteral()  throws XPathExpressionException  #AttributeLitteral : { Token t; }
{
  t=<ATTRIBUTE>
  {
    jjtThis.setImage(t.image);
  }
}


void UnaryExpression() throws XPathExpressionException  : {}
{
(
  ( <PLUS> | <MINUS> ) UnaryExpression()
|
  PreIncrementExpression()
|
  PreDecrementExpression()
|
  PostfixExpression()
  ) #UnaryExpression(>1)
}

void PreIncrementExpression() throws XPathExpressionException  : {}
{
 (
  <INCR> PrimaryExpression()
  ) #PreIncrementExpression(>1)
}

void PreDecrementExpression() throws XPathExpressionException  : {}
{
 (
  <DECR> PrimaryExpression()
  )  #PreDecrementExpression(>1)
}


// This production is to determine lookahead only.  The LOOKAHEAD specifications
// below are not used, but they are there just to indicate that we know about
// this.

void PostfixExpression() throws XPathExpressionException  : {}
{
 (
  PrimaryExpression() [ <INCR> | <DECR> ]
  ) #PostfixExpression(>1)
}


void PrimaryExpression() throws XPathExpressionException  : {}
{
(
  LOOKAHEAD(2) Function() {}
|
  Literal() {}
|
  XpathExpression() {}
|
  "(" Expression() ")"
  ) #PrimaryExpression(>1)
}

void XpathExpression() throws XPathExpressionException : {}
{
 (
	Identifier()  (  LOOKAHEAD(2) ArrayExpression() | LOOKAHEAD(3) ChildLitteral() | LOOKAHEAD(4) AttributeLitteral() )*
 ) #XpathExpression(>1)
}


void Function() throws XPathExpressionException  : {}
{
(
  LOOKAHEAD(2) TrueFunction()
|
  LOOKAHEAD(3) FalseFunction()
|
  LOOKAHEAD(4) NotFunction()
|
  LOOKAHEAD(5) DoXslTransform()
|
  LOOKAHEAD(6) ConcatFunction()
|
  LOOKAHEAD(7) NumberFunction()
|
  LOOKAHEAD(8) StringFunction()
|
  LOOKAHEAD(9) SubstringBeforeFunction()
|
  LOOKAHEAD(10) SubstringAfterFunction()
|
  LOOKAHEAD(11) TranslateFunction()
|
  LOOKAHEAD(12) CountFunction()
|
  LOOKAHEAD(13) CurrentDateFunction()
|
  LOOKAHEAD(13) CurrentDateTimeFunction()
|
  LOOKAHEAD(13) CurrentTimeFunction()
|
  LOOKAHEAD(13) DateTimeFunction()
|
  LOOKAHEAD(16) DayFromDateFunction()
|
  LOOKAHEAD(16) DayFromDateTimeFunction()
|
  LOOKAHEAD(20) ChildNodeXpathFunction()
|
  LOOKAHEAD(21) TextXpathFunction()
| 
  LOOKAHEAD(22) AbsFunction()
|
  LOOKAHEAD(23) AdjustDateToTimezoneFunction()
|
  LOOKAHEAD(24) AdjustDateTimeToTimezoneFunction()
|
  LOOKAHEAD(25) AdjustTimeToTimezoneFunction()
|
  LOOKAHEAD(26) BaseURIFunction()
|
  LOOKAHEAD(27) BooleanFunction()
|
  LOOKAHEAD(28) CeilingFunction()
|
  LOOKAHEAD(29) CodepointEqualFunction()
|
  LOOKAHEAD(30) CodepointsToStringFunction()
|
  LOOKAHEAD(31) CollectionFunction()
|
  LOOKAHEAD(32) CompareFunction()
|
  LOOKAHEAD(33) ContainsFunction()
|
  LOOKAHEAD(34) DataFunction()
|
  LOOKAHEAD(35) DaysFromDurationFunction()
|
  LOOKAHEAD(36) DeepEqualFunction()
|
  LOOKAHEAD(37) DefaultCollationFunction()
|
  LOOKAHEAD(38) DistinctValuesFunction()
|
  LOOKAHEAD(39) DocFunction()
|
  LOOKAHEAD(40) DocAvailableFunction()
|
  LOOKAHEAD(41) DocumentURIFunction()
|
  LOOKAHEAD(42) EmptyFunction()
|
  LOOKAHEAD(43) EncodeForURIFunction()
|
  LOOKAHEAD(44) EndsWithFunction()
|
  LOOKAHEAD(45) ErrorFunction()
|
  LOOKAHEAD(46) EscapeHTMLURIFunction()
|
  LOOKAHEAD(47) ExactlyOneFunction()
|
  LOOKAHEAD(48) ExistsFunction()
|
  LOOKAHEAD(49) HoursFromDateTimeFunction()
|
  LOOKAHEAD(50) HoursFromDurationFunction()
|
  LOOKAHEAD(51) HoursFromTimeFunction()
|
  LOOKAHEAD(52) IdFunction()
|
  LOOKAHEAD(53) IdRefFunction()
|
  LOOKAHEAD(54) ImplicitTimezoneFunction()
|
  LOOKAHEAD(55) InScopePrefixesFunction()
|
  LOOKAHEAD(56) IndexOfFunction()
|
  LOOKAHEAD(57) InsertBeforeFunction()
|
  LOOKAHEAD(58) IRIToURIFunction()
|
  LOOKAHEAD(59) LangFunction()
|
  LOOKAHEAD(60) LastFunction()
|
  LOOKAHEAD(61) LocalNameFunction()
|
  LOOKAHEAD(62) LocalNameFromQNameFunction()
|
  LOOKAHEAD(63) LowerCaseFunction()
|
  LOOKAHEAD(64) MatchesFunction()
|
  LOOKAHEAD(65) MaxFunction()
|
  LOOKAHEAD(66) MinutesFromDateTimeFunction()
|
  LOOKAHEAD(66) MinutesFromDurationFunction()
|
  LOOKAHEAD(67) MinutesFromTimeFunction()
|
  LOOKAHEAD(68) MonthFromDateFunction()
|
  LOOKAHEAD(69) MonthFromDateTimeFunction()
|
  LOOKAHEAD(70) MonthFromDurationFunction()
|
  LOOKAHEAD(70) NameFunction()
|
  LOOKAHEAD(71) NamespaceURIFunction()
|
  LOOKAHEAD(72) NamespaceURIForPrefixFunction()
|
  LOOKAHEAD(73) NamespaceURIFromQNameFunction()
|
  LOOKAHEAD(74) NilledFunction()
|
  LOOKAHEAD(75) NodeNameFunction()
|
  LOOKAHEAD(76) NormalizeSpaceFunction()
|
  LOOKAHEAD(77) NormalizeSpaceFunction()
|
  LOOKAHEAD(78) NormalizeUnicodeFunction()
|
  LOOKAHEAD(79) OneOrMoreFunction()
|
  LOOKAHEAD(80) PositionFunction()
|
  LOOKAHEAD(81) PrefixFromQNameFunction()
|
  LOOKAHEAD(82) QNameFunction()
|
  LOOKAHEAD(83) RemoveFunction()
|
  LOOKAHEAD(84) ReplaceFunction()
|
  LOOKAHEAD(85) ResolveQNameFunction()
|
  LOOKAHEAD(86) ResolveURIFunction()
|
  LOOKAHEAD(87) ReverseFunction()
|
  LOOKAHEAD(88) RootFunction()
|
  LOOKAHEAD(89) RoundFunction()
|
  LOOKAHEAD(90) RoundHalfToEvenFunction()
|
  LOOKAHEAD(91) SecondsFromDateTimeFunction()
|
  LOOKAHEAD(92) SecondsFromDurationFunction()
|
  LOOKAHEAD(93) SecondsFromTimeFunction()
|
  LOOKAHEAD(94) StaticBaseURIFunction()
|
  LOOKAHEAD(95) StringJoinFunction()
|
  LOOKAHEAD(96) StringLengthFunction()
|
  LOOKAHEAD(97) StringToCodepointsFunction()
|
  LOOKAHEAD(98) SubsequenceFunction()
|
  LOOKAHEAD(99) SubstringFunction()
|
  LOOKAHEAD(102) SumFunction()
|
  LOOKAHEAD(103) TimezoneFromDateFunction()
|
  LOOKAHEAD(104) TimezoneFromDateTimeFunction()
|
  LOOKAHEAD(105) TimezoneFromTimeFunction()
|
  LOOKAHEAD(106) TokenizeFunction()
|
  LOOKAHEAD(107) TraceFunction()
|
  LOOKAHEAD(109) UnorderedFunction()
|
  LOOKAHEAD(110) UpperCaseFunction()
|
  LOOKAHEAD(111) YearFromDateFunction()
|
  LOOKAHEAD(112) YearFromDateTimeFunction()
|
  LOOKAHEAD(113) YearFromDurationFunction()
|
  LOOKAHEAD(114) ZeroOrOneFunction()
|
  LOOKAHEAD(115) CurrentFunction()
|
  LOOKAHEAD(116) CurrentGroupFunction()
|
  LOOKAHEAD(117) CurrentGroupingKeyFunction()
|
  LOOKAHEAD(118) DocumentFunction()
|
  LOOKAHEAD(118) ElementAvailableFunction()
|
  LOOKAHEAD(119) FormatDateFunction()
|
  LOOKAHEAD(120) FormatDateTimeFunction()
|
  LOOKAHEAD(121) FormatNumberFunction()
|
  LOOKAHEAD(122) FormatTimeFunction()
|
  LOOKAHEAD(123) FunctionAvailableFunction()
|
  LOOKAHEAD(124) GenerateIdFunction()
|
  LOOKAHEAD(125) KeyFunction()
|
  LOOKAHEAD(126) RegexGroupFunction()
|
  LOOKAHEAD(127) SystemPropertyFunction()
|
  LOOKAHEAD(128) TypeAvailableFunction()
|
  LOOKAHEAD(129) UnparsedEntityPublicIdFunction()
|
  LOOKAHEAD(130) UnparsedEntityURIFunction()
|
  LOOKAHEAD(131) UnparsedTextFunction()
|
  LOOKAHEAD(132) UnparsedTextAvailableFunction()
  ) #Function(>1)
}




void NotFunction() throws XPathExpressionException  #NotFunction : { Token p; }
{
	(p=<PREFIX> {jjtThis.setImage(p.image);})? "not" Arguments()
}

void TrueFunction() throws XPathExpressionException  #TrueFunction : { Token p; }
{
	(p=<PREFIX> {jjtThis.setImage(p.image);})? "true" Arguments()
}

void FalseFunction() throws XPathExpressionException  #FalseFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "false" Arguments()
}

void DoXslTransform() throws XPathExpressionException  #DoXslTransform : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "doXslTransform" Arguments()
}

void ConcatFunction() throws XPathExpressionException  #ConcatFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "concat" Arguments()
}

void NumberFunction() throws XPathExpressionException  #NumberFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "number" Arguments()
}

void StringFunction() throws XPathExpressionException  #StringFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "string" Arguments()
}

void SubstringBeforeFunction() throws XPathExpressionException  #SubstringBeforeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "substring-before" Arguments()
}

void SubstringAfterFunction() throws XPathExpressionException  #SubstringAfterFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "substring-after" Arguments()
}

void TranslateFunction() throws XPathExpressionException  #TranslateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "translate" Arguments()
}

void CountFunction() throws XPathExpressionException  #CountFunction : { Token p; }
{
    (<PREFIX>)? "count" Arguments()
}

void CurrentDateFunction() throws XPathExpressionException  #CurrentDateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "current-date" Arguments()
}

void CurrentDateTimeFunction() throws XPathExpressionException  #CurrentDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "current-dateTime" Arguments()
}

void CurrentTimeFunction() throws XPathExpressionException  #CurrentTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "current-time" Arguments()
}

void DateTimeFunction() throws XPathExpressionException  #DateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "dateTime" Arguments()
}

void DayFromDateFunction() throws XPathExpressionException  #DayFromDateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "day-from-date" Arguments()
}

void DayFromDateTimeFunction() throws XPathExpressionException  #DayFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "day-from-dateTime" Arguments()
}

void ChildNodeXpathFunction() throws XPathExpressionException  #ChildNodeXpathFunction : { Token p; }
{
    "child::" ChildNodeNameXpathFunction() (Arguments())? ( "[" Expression() "]" )?
}

void ChildNodeNameXpathFunction() throws XPathExpressionException  #ChildNodeNameXpathFunction : { Token s;  }
{
 ( s=<NAME_TOKEN> {
              jjtThis.setImage(s.image);
            }
    | "*"   {
              jjtThis.setImage("*");
            }
 )
}


void TextXpathFunction() throws XPathExpressionException  #TextXpathFunction : {}
{
    "text" Arguments() 
}


void AbsFunction() throws XPathExpressionException  #AbsFunction : { Token p; }
{
    (<PREFIX>)? "abs" Arguments()
}


void AdjustDateToTimezoneFunction() throws XPathExpressionException  #AdjustDateToTimezoneFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "adjust-date-to-timezone" Arguments()
}

void AdjustDateTimeToTimezoneFunction() throws XPathExpressionException  #AdjustDateTimeToTimezoneFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "adjust-dateTime-to-timezone" Arguments()
}

void AdjustTimeToTimezoneFunction() throws XPathExpressionException  #AdjustTimeToTimezoneFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "adjust-time-to-timezone" Arguments()
}

void BaseURIFunction() throws XPathExpressionException  #BaseURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "base-uri" Arguments()
}

void BooleanFunction() throws XPathExpressionException  #BooleanFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "boolean" Arguments()
}

void CeilingFunction() throws XPathExpressionException  #CeilingFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "ceiling" Arguments()
}

void CodepointEqualFunction() throws XPathExpressionException  #CodepointEqualFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "codepoint-equal" Arguments()
}

void CodepointsToStringFunction() throws XPathExpressionException  #CodepointsToStringFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "codepoints-to-string" Arguments()
}

void CollectionFunction() throws XPathExpressionException  #CollectionFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "collection" Arguments()
}

void CompareFunction() throws XPathExpressionException  #CompareFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "compare" Arguments()
}

void ContainsFunction() throws XPathExpressionException  #ContainsFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "contains" Arguments()
}

void DataFunction() throws XPathExpressionException  #DataFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "data" Arguments()
}


void DaysFromDurationFunction() throws XPathExpressionException  #DaysFromDurationFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "days-from-duration" Arguments()
}


void DeepEqualFunction() throws XPathExpressionException  #DeepEqualFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "deep-equal" Arguments()
}


void DefaultCollationFunction() throws XPathExpressionException  #DeepEqualFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "deep-equal" Arguments()
}


void DistinctValuesFunction() throws XPathExpressionException  #DistinctValuesFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "distinct-values" Arguments()
}

void DocFunction() throws XPathExpressionException  #DocFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "doc" Arguments()
}


void DocAvailableFunction() throws XPathExpressionException  #DocAvailableFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "doc-available" Arguments()
}


void DocumentURIFunction() throws XPathExpressionException  #DocumentURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "document-uri" Arguments()
}

void EmptyFunction() throws XPathExpressionException  #EmptyFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "empty" Arguments()
}

void EncodeForURIFunction() throws XPathExpressionException  #EncodeForURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "encode-for-uri" Arguments()
}

void EndsWithFunction() throws XPathExpressionException  #EndsWithFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "ends-with" Arguments()
}

void ErrorFunction() throws XPathExpressionException  #ErrorFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "error" Arguments()
}


void EscapeHTMLURIFunction() throws XPathExpressionException  #EscapeHTMLURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "escape-html-uri" Arguments()
}


void ExactlyOneFunction() throws XPathExpressionException  #ExactlyOneFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "exactly-one" Arguments()
}

void ExistsFunction() throws XPathExpressionException  #ExistsFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "exists" Arguments()
}

void HoursFromDateTimeFunction() throws XPathExpressionException  #HoursFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "hours-from-dateTime" Arguments()
}


void HoursFromDurationFunction() throws XPathExpressionException  #HoursFromDurationFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "hours-from-duration" Arguments()
}

void HoursFromTimeFunction() throws XPathExpressionException  #HoursFromTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "hours-from-time" Arguments()
}

void IdFunction() throws XPathExpressionException  #IdFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "id" Arguments()
}

void IdRefFunction() throws XPathExpressionException  #IdRefFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "idref" Arguments()
}

void ImplicitTimezoneFunction() throws XPathExpressionException  #ImplicitTimezoneFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "implicit-timezone" Arguments()
}


void InScopePrefixesFunction() throws XPathExpressionException  #InScopePrefixesFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "in-scope-prefixes" Arguments()
}

void IndexOfFunction() throws XPathExpressionException  #IndexOfFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "index-of" Arguments()
}

void InsertBeforeFunction() throws XPathExpressionException  #InsertBeforeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "insert-before" Arguments()
}

void IRIToURIFunction() throws XPathExpressionException  #IRIToURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "iri-to-uri" Arguments()
}

void LangFunction() throws XPathExpressionException  #LangFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "lang" Arguments()
}

void LastFunction() throws XPathExpressionException  #LastFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "last" Arguments()
}


void LocalNameFunction() throws XPathExpressionException  #LocalNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "local-name" Arguments()
}

void LocalNameFromQNameFunction() throws XPathExpressionException  #LocalNameFromQNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "local-name-from-QName" Arguments()
}


void LowerCaseFunction() throws XPathExpressionException  #LowerCaseFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "lower-case" Arguments()
}


void MatchesFunction() throws XPathExpressionException  #MatchesFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "matches" Arguments()
}


void MaxFunction() throws XPathExpressionException  #MaxFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "max" Arguments()
}

void MinutesFromDateTimeFunction() throws XPathExpressionException  #MinutesFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "minutes-from-dateTime" Arguments()
}


void MinutesFromDurationFunction() throws XPathExpressionException  #MinutesFromDurationFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "minutes-from-duration" Arguments()
}


void MinutesFromTimeFunction() throws XPathExpressionException  #MinutesFromTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "minutes-from-time" Arguments()
}


void MonthFromDateFunction() throws XPathExpressionException  #MonthFromDateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "month-from-date" Arguments()
}


void MonthFromDateTimeFunction() throws XPathExpressionException  #MonthFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "month-from-dateTime" Arguments()
}

void MonthFromDurationFunction() throws XPathExpressionException  #MonthFromDurationFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "month-from-duration" Arguments()
}


void NameFunction() throws XPathExpressionException  #NameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "name" Arguments()
}



void NamespaceURIFunction() throws XPathExpressionException  #NamespaceURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "namespace-uri" Arguments()
}


void NamespaceURIForPrefixFunction() throws XPathExpressionException  #NamespaceURIForPrefixFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "namespace-uri-for-prefix" Arguments()
}


void NamespaceURIFromQNameFunction() throws XPathExpressionException  #NamespaceURIFromQNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "namespace-uri-from-QName" Arguments()
}

void NilledFunction() throws XPathExpressionException  #NilledFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "nilled" Arguments()
}

void NodeNameFunction() throws XPathExpressionException  #NodeNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "node-name" Arguments()
}

void NormalizeSpaceFunction() throws XPathExpressionException  #NormalizeSpaceFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "normalize-space" Arguments()
}

void NormalizeUnicodeFunction() throws XPathExpressionException  #NormalizeUnicodeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "normalize-unicode" Arguments()
}


void OneOrMoreFunction() throws XPathExpressionException  #OneOrMoreFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "one-or-more" Arguments()
}

void PositionFunction() throws XPathExpressionException  #PositionFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "position" Arguments()
}

void PrefixFromQNameFunction() throws XPathExpressionException  #PrefixFromQNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "prefix-from-QName" Arguments()
}

void QNameFunction() throws XPathExpressionException  #QNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "QName" Arguments()
}

void RemoveFunction() throws XPathExpressionException  #RemoveFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "remove" Arguments()
}

void ReplaceFunction() throws XPathExpressionException  #ReplaceFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "replace" Arguments()
}

void ResolveQNameFunction() throws XPathExpressionException  #ResolveQNameFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "resolve-QName" Arguments()
}

void ResolveURIFunction() throws XPathExpressionException  #ResolveURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "resolve-uri" Arguments()
}

void ReverseFunction() throws XPathExpressionException  #ReverseFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "reverse" Arguments()
}

void RootFunction() throws XPathExpressionException  #RootFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "root" Arguments()
}

void RoundFunction() throws XPathExpressionException  #RoundFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "round" Arguments()
}


void RoundHalfToEvenFunction() throws XPathExpressionException  #RoundHalfToEvenFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "round-half-to-even" Arguments()
}


void SecondsFromDateTimeFunction() throws XPathExpressionException  #SecondsFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "seconds-from-dateTime" Arguments()
}


void SecondsFromDurationFunction() throws XPathExpressionException  #SecondsFromDurationFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "seconds-from-duration" Arguments()
}


void SecondsFromTimeFunction() throws XPathExpressionException  #SecondsFromTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "seconds-from-time" Arguments()
}


void StaticBaseURIFunction() throws XPathExpressionException  #StaticBaseURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "static-base-uri" Arguments()
}


void StringJoinFunction() throws XPathExpressionException  #StringJoinFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "string-join" Arguments()
}

void StringLengthFunction() throws XPathExpressionException  #StringLengthFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "string-length" Arguments()
}

void StringToCodepointsFunction() throws XPathExpressionException  #StringToCodepointsFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "string-to-codepoints" Arguments()
}

void SubsequenceFunction() throws XPathExpressionException  #SubsequenceFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "subsequence" Arguments()
}

void SubstringFunction() throws XPathExpressionException  #SubstringFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "substring" Arguments()
}


void SumFunction() throws XPathExpressionException  #SumFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "sum" Arguments()
}


void TimezoneFromDateFunction() throws XPathExpressionException  #TimeZoneFromDateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "timezone-from-date" Arguments()
}

void TimezoneFromDateTimeFunction() throws XPathExpressionException  #TimeZoneFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "timezone-from-dateTime" Arguments()
}

void TimezoneFromTimeFunction() throws XPathExpressionException  #TimeZoneFromTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "timezone-from-time" Arguments()
}

void TokenizeFunction() throws XPathExpressionException  #TokenizeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "tokenize" Arguments()
}


void TraceFunction() throws XPathExpressionException  #TraceFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "trace" Arguments()
}



void UnorderedFunction() throws XPathExpressionException  #UnorderedFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "unordered" Arguments()
}


void UpperCaseFunction() throws XPathExpressionException  #UpperCaseFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "upper-case" Arguments()
}

void YearFromDateFunction() throws XPathExpressionException  #YearFromDateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "year-from-date" Arguments()
}

void YearFromDateTimeFunction() throws XPathExpressionException  #YearFromDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "year-from-dateTime" Arguments()
}

void YearFromDurationFunction() throws XPathExpressionException  #YearFromDurationFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "year-from-duration" Arguments()
}

void ZeroOrOneFunction() throws XPathExpressionException  #ZeroOrOneFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "zero-or-one" Arguments()
}


void CurrentFunction() throws XPathExpressionException  #CurrentFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "current" Arguments()
}


void CurrentGroupFunction() throws XPathExpressionException  #CurrentGroupFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "current-group" Arguments()
}

void CurrentGroupingKeyFunction() throws XPathExpressionException  #CurrentGroupingKeyFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "current-grouping-key" Arguments()
}

void DocumentFunction() throws XPathExpressionException  #DocumentFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "document" Arguments()
}

void ElementAvailableFunction() throws XPathExpressionException  #ElementAvailableFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "element-available" Arguments()
}


void FormatDateFunction() throws XPathExpressionException  #FormatDateFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "format-date" Arguments()
}

void FormatDateTimeFunction() throws XPathExpressionException  #FormatDateTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "format-dateTime" Arguments()
}


void FormatNumberFunction() throws XPathExpressionException  #FormatNumberFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "format-number" Arguments()
}

void FormatTimeFunction() throws XPathExpressionException  #FormatTimeFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "format-time" Arguments()
}

void FunctionAvailableFunction() throws XPathExpressionException  #FunctionAvailableFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "function-available" Arguments()
}

void GenerateIdFunction() throws XPathExpressionException  #GenerateIdFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "generate-id" Arguments()
}

void KeyFunction() throws XPathExpressionException  #KeyFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "key" Arguments()
}

void RegexGroupFunction() throws XPathExpressionException  #RegexGroupFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "regex-group" Arguments()
}

void SystemPropertyFunction() throws XPathExpressionException  #SystemPropertyFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "system-property" Arguments()
}

void TypeAvailableFunction() throws XPathExpressionException  #TypeAvailableFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "type-available" Arguments()
}

void UnparsedEntityPublicIdFunction() throws XPathExpressionException  #UnparsedEntityPublicIdFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "unparsed-entity-public-id" Arguments()
}


void UnparsedEntityURIFunction() throws XPathExpressionException  #UnparsedEntityURIFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "unparsed-entity-uri" Arguments()
}

void UnparsedTextFunction() throws XPathExpressionException  #UnparsedTextFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "unparsed-text" Arguments()
}

void UnparsedTextAvailableFunction() throws XPathExpressionException  #UnparsedTextAvailableFunction : { Token p; }
{
    (p=<PREFIX> {jjtThis.setImage(p.image);})? "unparsed-text-available" Arguments()
}




















void Literal() throws XPathExpressionException  : {} 
{
  Integer()
|
  Float()
|
  Caracter()
|
  String()
|
  BooleanLiteral()
|
  NullLiteral()
}


/** An Integer. */
void Integer() throws XPathExpressionException  #Integer : { Token i; }
{
  	i=<INTEGER_LITERAL>
  	{
    jjtThis.setImage(i.image);
    }
}

void Float() throws XPathExpressionException  #Float : { Token f; }
{
	f=<FLOATING_POINT_LITERAL>
	{
    jjtThis.setImage(f.image);
    }
}

void Caracter() throws XPathExpressionException  #Caracter : { Token c; }
{
	c=<CHARACTER_LITERAL>
	{
    jjtThis.setImage(c.image);
    }
}

void String() throws XPathExpressionException  #String : { Token s; }
{
	s=<STRING_LITERAL>
	{
    jjtThis.setImage(s.image);
    }
}

void BooleanLiteral() throws XPathExpressionException  #BooleanLiteral : {}
{
  "true" { jjtThis.setImage("true"); }
|
  "false" { jjtThis.setImage("false"); }
}

void NullLiteral() throws XPathExpressionException  #NullLiteral : {}
{
  "null"
}

void Arguments() throws XPathExpressionException  : {}
{
  "("  [ ArgumentList() ]  ")"
}

void ArgumentList() throws XPathExpressionException  : {}
{
   Expression() ( "," Expression() )*
}

/** An Identifier. */
void Identifier()  throws XPathExpressionException  #Variable : { Token t; }
{
  t=<IDENTIFIER>
  {
    jjtThis.setImage(t.image);
  }
}