/*
 *    GeoTools - The Open Source Java GIS Tookit
 *    http://geotools.orgLITERAL
 *
 *    (C) 2002-2008, Open Source Geospatial Foundation (OSGeo)SpatialRelateLikeSpatialRelateLike
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 */
 
options {
   STATIC=false;
   NODE_SCOPE_HOOK=true;
   NODE_DEFAULT_VOID=true;
   MULTI=false;
   BUILD_NODE_FILES=false; // Generates sample implementations for SimpleNode and any other nodes used in the grammar   	

   NODE_PACKAGE="org.geotools.filter.text.generated.parsers";
 
   SANITY_CHECK=true;
   VISITOR=false;
   
   FORCE_LA_CHECK=false; // force lookahead ambiguity checking in such instances. This option don't take into account the locak lookagead

   	// debug
   DEBUG_TOKEN_MANAGER=false;
   DEBUG_PARSER=false;
}

PARSER_BEGIN(ECQLParser)

package org.geotools.filter.text.generated.parsers;
        
import java.util.HashSet;
import java.util.Set;



/**
 * ECQLParser is the result of a javacc jjtree grammar.
 * 
 * @author  Mauricio Pazos - Axios Engineering
 * @since 2.6
 */
public class ECQLParser {
  public void jjtreeOpenNodeScope(Node n) throws ParseException {
 
  }

  public void jjtreeCloseNodeScope(Node n) throws ParseException {

  }

  // initialize geooperations
  protected static final Set GEOOP = new HashSet();
  static {
		GEOOP.add("EQUALS");
		GEOOP.add("DISJOINT");
		GEOOP.add("INTERSECTS");
		GEOOP.add("TOUCHES");
		GEOOP.add("CROSSES");
		GEOOP.add("WITHIN");
		GEOOP.add("CONTAINS");
		GEOOP.add("OVERLAPS");
		GEOOP.add("RELATE");
		GEOOP.add("BBOX");
  }
  protected boolean isGeoOp() {
  
        return "(".equals(getToken(2).image)
            && GEOOP.contains(getToken(1).image.toUpperCase());
  }
  
  protected static final Set RELGEOOP = new HashSet();
  static {
  	RELGEOOP.add("DWITHIN");
  	RELGEOOP.add("BEYOND"); 
  	
  }
  protected boolean isRelGeoOp() {
  
        return "(".equals(getToken(2).image)
            && RELGEOOP.contains(getToken(1).image.toUpperCase());
  }
  
}

PARSER_END(ECQLParser)


SKIP : /* WHITE SPACE */
{
  		" "
	| 	"\t"
	| 	"\n"
	| 	"\r"
	| 	"\f"
}


/*
 * <character string literal>
 */
TOKEN:
{
	  < STRING_LITERAL: "'" ( "''" | ~["'"] )* "'" > : DEFAULT
}

/*
 * keywords
 */
TOKEN [IGNORE_CASE]:  /* keywords */
{
   < AND: "and" | "&&"> |
   < OR: "or"> |
   < NOT: "not" | "!"> |
   < EQ: "eq" | "==" | "="> |
   < NEQ: "neq" | "<>" > |
   < GT: "gt" | ">" > |
   < LT: "lt" | "<" > |
   < GTE: "gte" | ">="> |
   < LTE: "lte" | "<="> |
   < TRUE: "true"> |
   < FALSE: "false"> |
   < UNKNOWN: "unknown"> |
   < LIKE: "like" > |
   < BETWEEN: "between"> |
   < ID: "id" > |
   < IN: "in" > |
   < IS: "is" > |
   < NULL: "null" > 

}

TOKEN [IGNORE_CASE]: /* include all and exclude all filters */
{
  < INCLUDE: "include"> |
  < EXCLUDE: "exclude">
}
  
TOKEN [IGNORE_CASE]: /* geometry markers */
{
  < POINT: "point"> |
  < LINESTRING: "linestring"> |
  < POLYGON: "polygon"> |
  < MULTIPOINT: "multipoint"> |
  < MULTILINESTRING: "multilinestring"> |
  < MULTIPOLYGON: "multipolygon"> |
  < GEOMETRYCOLLECTION: "geometrycollection"> |
  < ENVELOPE: "envelope">
}

TOKEN [IGNORE_CASE]: /* temporal expression*/
{
	<BEFORE: "before"> 	| 
	<DURING: "during"> 	|
	<AFTER:  "after">  	|
	<UTC: "T">			
}
TOKEN [IGNORE_CASE]: /* existence predicate*/
{
	<EXISTS: "exists"> |
	<DOES_NOT_EXIST: "does-not-exist">
}

TOKEN [IGNORE_CASE]:  
{
  < EQUALS: "equals"> |
  < DISJOINT: "disjoint"> |
  < INTERSECTS: "intersects"> |
  < TOUCHES: "touches"> |
  < CROSSES: "crosses"> |
  < WITHIN: "within"> |
  < CONTAINS: "contains"> |
  < OVERLAPS: "overlaps"> |
  < RELATE: "relate"> |
  < BBOX: "bbox"> 
}

TOKEN [IGNORE_CASE]: /* relgeoop name */
{
  < DWITHIN: "dwithin"> |
  < BEYOND: "beyond"> 
}

TOKEN [IGNORE_CASE]:
{
	<FEET: "feet" > | 
	<METERS: "meters"> | 
	<STATUTE_MILES: "statute miles"> | 
	<NAUTICAL_MILES: "nautical miles"> | 
	<KILOMETERS: "kilometers">
}


TOKEN:
{
  < LP: "("> |
  < RP: ")"> |
  < LSP: "["> |
  < RSP: "]"> |
  < COMMA: ","> |
  < SENTENCE_SEPARATOR: ";"> |
  < PERIOD: "."> |
  < SLASH: "/"> |
//  < PERIOD_SEP: <SLASH> > |
//  < DIV: <SLASH> > |
  < COLON: ":">	|
  < MULT: "*"> |
  < PLUS: "+"> |
  < MINUS: "-" > 
}


// Note, because float and int can technically have the same grammar,
// put int first to make token manager have preference for it...
// The same case occurs between identifier and duration tokens, 
// then DURATION has preference over IDENTIFIER
TOKEN [IGNORE_CASE]: /* Literals */
{

  	< INTEGER_LITERAL: (<DIGIT>)+ > |
  	< FLOATING_LITERAL:
    	( ( <DIGIT> )* "." ( <DIGIT> )+ (<EXPONENT>)? ) |
    	( ( <DIGIT> )+ ("." ( <DIGIT> )*)? (<EXPONENT>)? )
  	> |

	< #DUR_DAY:	  (<DIGIT>)+ "D" > |
	< #DUR_MONTH: (<DIGIT>)+ "M" (<DUR_DAY>)? > |
	< #DUR_YEAR:  (<DIGIT>)+ "Y" (<DUR_MONTH>)? > |	
	< #DUR_DATE:  (<DUR_DAY> | <DUR_MONTH> | <DUR_YEAR>) ("T" <DUR_TIME>)?> | 

	< #DUR_HOUR:  (<DIGIT>)+ "H" (<DUR_MINUTE>)?> |
	< #DUR_MINUTE:(<DIGIT>)+ "M" (<DUR_SECOND>)? > |
	< #DUR_SECOND:(<DIGIT>)+ "S" > |	
	< #DUR_TIME:  (<DUR_HOUR> | <DUR_MINUTE> | <DUR_SECOND>) > | 
	
	< DURATION:  ("P" <DUR_DATE> |  "T" <DUR_TIME>) > |
	
	< #FULL_DATE: <DIGIT><DIGIT><DIGIT><DIGIT> "-" <DIGIT><DIGIT> "-" <DIGIT><DIGIT> > |
	< #UTC_TIME: <DIGIT><DIGIT> ":" <DIGIT><DIGIT> ":" <DIGIT><DIGIT> ("." (<DIGIT>)+)? "Z" > |
	< DATE_TIME : <FULL_DATE>"T"<UTC_TIME> > |

    < IDENTIFIER: (<LETTER> (<LETTER>|<DIGIT>)*) > |

  	< LETTER: [ "a"-"z", "A"-"Z" , "_"] > |
  	< DIGIT: [ "0"-"9"] > |
  	< #EXPONENT: ["e","E"] (["+","-"])? (<DIGIT>)+ > 
}



/*
 * Program structuring syntax to parse a single filter.
 */
Node FilterCompilationUnit() :
{}
{
   SearchCondition()
   <EOF>
   {return jjtree.rootNode();}
}

/*
 * Program structuring syntax to parse a single expression.
 */
Node ExpressionCompilationUnit() :
{}
{
    ECQLExpression()
   <EOF>
   {return jjtree.rootNode();}
}

void ECQLExpression()#void:
{}
{
    	Expression()
}

/*
 * Program structuring syntax to parse a list of filters.
 */
Node FilterListCompilationUnit() :
{}
{
   SequenceOfSearchConditions()
   <EOF>
   {return jjtree.rootNode();}
}


/*
 * <SequenceOfSearchConditions> ::= 
 * 			<search condition>
 * 		|	<SequenceOfSearchConditions> ; <search condition>
 */ 
void SequenceOfSearchConditions() #void:
{}
{
		SearchCondition() (<SENTENCE_SEPARATOR> SearchCondition())*
}

void SearchCondition() #void:
{}
{
	 BooleanValueExpression()
}

/*
 * <boolean value expression> ::= 
 *			<boolean term>
 * 		| 	<boolean value expression> OR <boolean term>
 */
void BooleanValueExpression() #void:
{}
{
		BooleanTerm()( <OR> BooleanTerm() #Boolean_Or_Node )*
}

/*
 * <boolean term> ::= 
 *            <boolean factor>
 *          | <boolean term> AND <boolean factor>
 */
void BooleanTerm() #void :
{}
{
	 BooleanFactor()( <AND> BooleanFactor() #Boolean_And_Node )*
}


void BooleanFactor() #void:
{}
{
	  <NOT> BooleanPrimary() #Boolean_Not_Node
	| BooleanPrimary()

}

void BooleanPrimary() #void:
{}
{
	   LOOKAHEAD(Predicate()) Predicate() 
	|  IncludeExcludePredicate()
	|  <LP>SearchCondition()<RP> 
	|  <LSP>SearchCondition()<RSP> 
	|  RoutineInvocation() 
}

/*
 * <predicate> ::= <comparison predicate>
 * 	| <text predicate>
 * 	| <null predicate>
 * 	| <temporal predicate>
 * 	| <classification predicate> (*not supported*)
 * 	| <existence predicate> 
 * 	| <between predicate> (*extension*)
 *  | <includeexclude predicate> (*extesion*)
 *  | <id predicate>
 */
void Predicate() #void:
{}
{
		LOOKAHEAD(3) Expression()  
		(
				LOOKAHEAD(2) TextPredicate()
			| 	LOOKAHEAD(2) ExistencePredicate() 
			|  	LOOKAHEAD(2) NullPredicate() 
			|   LOOKAHEAD(2) BetweenPredicate()		
			| 	LOOKAHEAD(2) TemporalPredicate() 
			| 	ComparisonPredicate() 
		)
	|	LOOKAHEAD(3) IdPredicate()
	|	InPredicate() 
		 
}

/* ---------------------------------------- *
 *   	<id predicate>
 * ---------------------------------------- *
/*
 * <id predicate> ::= "ID" "IN" <id list> 
 * <id list> ::= <id value>, {"," id value}
 */
void IdPredicate() #void:
{}
{
  	 	 LOOKAHEAD(3) <ID> <NOT> <IN> IdList() 	#Not_Id_Predicate_Node
  	|	  			  <ID> <IN> IdList() 		#Id_Predicate_Node
  	
}
void IdList() #void:
{}
{
	<LP> IdValue()( <COMMA>  IdValue() )* <RP> 
	
} 

void IdValue() #FEATURE_ID_NODE:
{}
{
		<STRING_LITERAL>	
	| 	<INTEGER_LITERAL>

}

/* ---------------------------------------- *
 *   	<in predicate>
 * ---------------------------------------- *
/*
/* <in predicate>    	::=   <attribute-name> [  "NOT"  ]  "IN"  <in predicate value>
 * <in predicate value>    ::=   "(" <in value list> ")"
 * <in value list>         ::=   <expression> {"," <expression>} 
 */
void InPredicate() #void:
{}
{
  	 	  LOOKAHEAD(4) 	Attribute() <NOT> <IN> InPredicateList() 	#Not_In_Predicate_Node
  	|	   				Attribute() <IN> InPredicateList() 		#In_Predicate_Node
  	
}

void InPredicateList() #void:
{}
{
	<LP> ExpressionInList()( <COMMA>  ExpressionInList() )* <RP>	
} 

void ExpressionInList() #Expression_In_List_Node:
{}
{
	Expression()
}


/* ---------------------------------------- *
 *   	<routine invocation>
 * ---------------------------------------- *
/*
 * <routine invocation> ::= 
 *	 <geoop name><georoutine argument list>
 * | <relgeoop name><relgeoop argument list>
 * | <routine name><argument list>
 */
void RoutineInvocation() #void:
{}
{
		LOOKAHEAD({ isGeoOp() })   		RoutineInvocationGeoOp()
	|	LOOKAHEAD({ isRelGeoOp() })		RoutineInvocationRelGeoOp()
	|	RoutineInvocationGeneric()
}

void RoutineInvocationGeoOp() #void:
{}
{
  	<EQUALS> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Equal_Node
  |	<DISJOINT> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Disjoint_Node
  |	<INTERSECTS> GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Intersect_Node
  |	<TOUCHES> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Touch_Node
  |	<CROSSES> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Cross_Node
  |	<WITHIN> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Within_Node
  |	<CONTAINS> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Contain_Node
  |	<OVERLAPS> 	GeoRoutineArgumentList() #RoutineInvocation_GeoOp_Overlap_Node
  |	<RELATE> 	GeoRoutineArgumentList() RelateTail() 
  | <BBOX> 		BBoxArgumentList()		 
}

void RelateTail() #void:
{}
{
	    <EOF> #Relate_Node
// FIXME	  | SpatialRelateLike()  
}

/*
void SpatialRelateLike() #void:
{}
{
  	 	LOOKAHEAD(2)  <NOT> <LIKE> CharacterPattern() 	#Not_SpatialRelateLike_Node
  	|	              <LIKE> Pattern9IM() 				#SpatialRelateLike_Node
}

*
 *<relate pattern> ::=  <quote>
 *                        <relate flag><relate flag><relate flag><relate flag>
 *                        <relate flag><relate flag><relate flag><relate flag>
 *                        <relate flag>
 *                       <quote>
 * <relate flag> ::= "T" | "F" | "*" | "0" | "1" | "2"
 *
void Pattern9IM() #Pattern9IM_Node:
{}
{
	CharacterPattern()
}
*/

/*
 * <georoutine argument list> ::=
 *		<left paren><Expression><comma><Expression><right paren>
 *
 */
void GeoRoutineArgumentList() #void:
{}
{
	<LP> Expression() <COMMA> Expression() <RP>
}

/*
 * <bbox argument list>::= 
 * 	  "(" <expression> "," <bounding box> ")" 
 * 	| "(" <expression> "," 
 * 		<min X> ","
 * 		<min Y> ","
 * 		<max X> ","
 * 		<max Y> 
 * 		[, srs] ")"
 * 
 * <min X> ::= <signed numerical literal> 
 * <min Y> ::= <signed numerical literal> 
 * <max X> ::= <signed numerical literal> 
 * <max Y> ::= <signed numerical literal> 
 * <srs> ::= <character string literal>
*/
void BBoxArgumentList() #void:
{}
{
		<LP> Expression() <COMMA> BBoxArgListTail() 
}

void BBoxArgListTail() #void:
{}
{
		BoundingBox()
	| 	(Function() | GeometryLiteral()) <RP>
	
} 

void BoundingBox() #void:
{}
{
	 	NumericLiteral() <COMMA>
 		NumericLiteral() <COMMA>
 		NumericLiteral() <COMMA>
 		NumericLiteral() 
 	( 		<RP> 						#RoutineInvocation_GeoOp_BBOX_Node
  		| 	<COMMA> StringLiteral()<RP> #RoutineInvocation_GeoOp_BBOX_SRS_Node)
}

/*
 * <relgeoop name> ::= DWITHIN | BEYOND
 */
void RoutineInvocationRelGeoOp() #void:
{}
{
  	<DWITHIN> 	RelGeoRoutineArgumentList() #RoutineInvocation_RelOp_DWITHIN_Node
  |	<BEYOND> 	RelGeoRoutineArgumentList() #RoutineInvocation_RelOp_BEYOND_Node
}

/*
 * <relgeoop argument list> ::= 
 *		<left paren><attribute name><comma><geometry literal><comma><tolerance><right paren>
 */
void RelGeoRoutineArgumentList() #void:
{}
{
	<LP> Expression() <COMMA> Expression() <COMMA> Tolerance() <RP>
	
//	<LP> Attribute() <COMMA> GeometryLiteral() <COMMA> Tolerance() <RP>
}
/*
 * <tolerance> ::= <unsigned numeric literal><comma><distance units>
 */
void Tolerance() :
{}
{
	UnsignedNumericLiteral() #Tolerance_Node <COMMA> DistanceUnits()
}

/**
 * <distance units> ::=
 *	 'feet' | 'meters' | 'statute miles' |
 *   'nautical miles' | 'kilometers'
 * 
 * TODO this set of units is just an example. The real list of distance unit must be developed
 */ 
void DistanceUnits() #DistanceUnits_Node:
{}
{
	<FEET> | <METERS> | <STATUTE_MILES> | <NAUTICAL_MILES> | <KILOMETERS>
}


/*
 * <geometry literal> ::= 
 *	  <Point Tagged Text>
 * 	| <LineString Tagged Text>
 * 	| <Polygon Tagged Text>
 *	| <MultiPoint Tagged Text>
 *  | <MultiLineString Tagged Text>
 * 	| <MultiPolygon Tagged Text>
 * 	| <GeometryCollection Tagged Text>
 *	| <Envelope Tagged Text>
 */
void GeometryLiteral() #GeometryLiteral:
{}
{
  PointTaggedText() |
  LineStringTaggedText() |
  PolygonTaggedText() |
  MultiPointTaggedText() |
  MultiLineStringTaggedText() |
  MultiPolygonTaggedText() |
  GeometryCollectionTaggedText() |
  EnvelopeTaggedText()
}
/*
 *  <routine invocation > ::= 
 *  |   <routine name > <argument list > 
 *                                           
 * <argument list&gt ::=    
 *      <left paren> [<positional arguments>] <right paren>
 * <positional arguments> ::=
 *      <argument> [ { <comma&gt <argument> }... ]
 *           
 * <argument>  ::= 
 *      <literal>  
 *  |   <attribute name>                                            
 *  |   <function>           (*Extension*)                                            
 *  |   <binary expression>  (*Extension*)                            
 */
void RoutineInvocationGeneric() #void:
{}
{
	Function()
}

/* ---------------------------------------- *
 *   	End <routine invocation>
 * ---------------------------------------- *


/* ---------------------------------------- *
 *   	<includeexclude predicate>
 * ---------------------------------------- *
/*
 * <includeexclude predicate> ::= 
 *		  <INCLUDE> | <EXCLUDE>
 */
void IncludeExcludePredicate() #void:
{}
{
   <INCLUDE> 	#Include_Node
   | <EXCLUDE> 	#Exclude_Node
}

/* ---------------------------------------- *
 *   	<comparison predicate>
 * ---------------------------------------- *
/*
 * <comparison predicate> ::= 
 *		  <attribute name> <comp op> <literal>
 */
void ComparisonPredicate() :
{}
{
   	 <EQ> 	Expression() #ComparisonPredicate_EQ_Node
   | <GT> 	Expression() #ComparisonPredicate_GT_Node
   | <LT> 	Expression() #ComparisonPredicate_LT_Node
   | <GTE> 	Expression() #ComparisonPredicate_GTE_Node
   | <LTE>	Expression() #ComparisonPredicate_LTE_Node
   | <NEQ> 	Expression() #ComparisonPredicate_Not_Equal_Node
}

/*
 * <null predicate> ::= <attribute name> IS [ NOT ] NULL 
 */
void NullPredicate() :
{}
{
	  LOOKAHEAD(3) 	<IS> <NULL> 		#NullPredicateNode
	|  				<IS> <NOT> <NULL> 	#NotNullPredicateNode
}


/* ---------------------------------------- *
 *   	<temporal predicate>
 * ---------------------------------------- *
 * <temporal predicate> ::= 
 *    <attribute_name> BEFORE <date-time expression>
 *	| <attribute_name> BEFORE OR DURING <period>
 *	| <attribute_name> DURING <period>
 *	| <attribute_name> DURING OR AFTER <period>
 *	| <attribute_name> AFTER <date-time expression>
 */
void TemporalPredicate() #void:
{}
{
		<BEFORE> TemporalPredicateBefore() 	
	|   <AFTER>	 TemporalPredicateAfter()	
	|	<DURING> TemporalPredicateDuring()	
	
}

void TemporalPredicateBefore()#void:
{}
{
		DateTimeExpression() 	#TPBefore_DateTime_Node
	|	<OR> <DURING> Period()	#TPBefore_Or_During_Period_Node 
}

void TemporalPredicateAfter() #TPAfter_DateTime_Node:
{}
{
		DateTimeExpression()
}

void TemporalPredicateDuring()#void:
{}
{
		Period() 				#TPDuring_Period_Node
	| 	<OR> <AFTER> Period()	#TPDuring_Or_After_Period_Node
}

/*
 * <date-time expression ::= <date-time> | <period>
 */
void DateTimeExpression()#void:
{}
{
		LOOKAHEAD(2) Period() 	
	| 	DateTime()						
}

/*
 *<period> ::= 
 *	  <date-time> "/" <date-time>
 * 	| <date-time> "/" <duration>
 * 	| <duration> "/" <date-time>
 */
void Period() #void:
{}
{
		LOOKAHEAD(2)
		DateTime() <SLASH> PeriodTail() 	
	|	Duration() <SLASH> DateTime()	#Period_With_Duration_Date_Node
}

void PeriodTail()#void:
{}
{
		Duration()	#Period_With_Date_Duration_Node
	|	DateTime()	#Period_Between_Dates_Node	
}

void DateTime()#DateTime_Node: 
{}
{
	<DATE_TIME> 
}

/*
 * <duration> ::= "P" <dur-date> | <dur-time>
 * <dur-date> ::= <dur-day> | <dur-month> | <dur-year> [<dur-time>]
 * <dur-day> ::= <digit>... "D"
 * <dur-month> ::= <digit>... "M" [<dur-day>]
 * <dur-year> ::= <didit>... "Y" [<dur-month>]
 */
void Duration()#void:
{}
{
 		<DURATION> #Duration_Date_Node
}

/* ---------------------------------------- *
 *  End <temporal predicate>
 * ---------------------------------------- */

/* ---------------------------------------- *
 *  <existence predicate>
 * ---------------------------------------- */
/*
 * <existence_predicate> ::= <attribute_name> EXISTS
 * | <attribute_name> DOES-NOT-EXIST
 */
void ExistencePredicate() #void:
{}
{
		<EXISTS>			#Existence_Predicate_Exists_Node
	|	<DOES_NOT_EXIST>	#Existence_Predicate_DoesNotExist_Node
}
/* ---------------------------------------- *
 *  end <existence predicate>
 * ---------------------------------------- */

void TextPredicate() #void:
{}
{
  	 	LOOKAHEAD(2)  <NOT> <LIKE> CharacterPattern() 	#Not_Like_Node
  	|	              <LIKE> CharacterPattern() 		#Like_Node
}


void CharacterPattern() #void:
{}
{
  	StringLiteral() 
}

/*
 * Cql Extension
 * 
 *	<beween predicate>::= ["NOT"] "BETWEEN" expression "AND" expression
 */
void BetweenPredicate() #void:
{}
{
	LOOKAHEAD(2) <NOT> <BETWEEN> Expression() <AND> Expression()	#Not_Between_Node
  	|			 <BETWEEN> Expression() <AND> Expression()			#Between_Node
}

/*
 * cql extension
 *	<expression> ::= 
 */
void Expression() #void:
{}
{
   		BinaryExpression()
   	|  	GeometryLiteral()
}

void BinaryExpression() #void:
{}
{
  MultiplicativeExpression()
  (
    <PLUS> MultiplicativeExpression() #AddNode
   |
    <MINUS> MultiplicativeExpression() #SubtractNode
  )*
}
 


void MultiplicativeExpression() #void :
{}
{
  
  UnaryExpression()
  (
    <MULT> UnaryExpression() #MulNode
   |
    <SLASH> UnaryExpression() #DivNode
  )*
}

void UnaryExpression() #void:
{}
{
	  LOOKAHEAD(2)<LP> Expression()<RP>
	| LOOKAHEAD(2)<LSP> Expression()<RSP>
	| LOOKAHEAD(2) Function() 
	| Literal()
	| Attribute()
}

void Evaluate() #void:
{}
{
  	LOOKAHEAD(2) Function() 
  |	Attribute()
}

/*
 * <identifier> ::= <identifier part [ { <colon> | <identifier part> }... ]
 */
void Identifier() #Identifier_Node:
{}
{
	IdentifierPart() ( <COLON> | IdentifierPart() )*	
}
void IdentifierPart() #Identifier_Part_Node:
 {}
 {
	<IDENTIFIER>
 }
 
   
/*
 * <attribute name> ::= 
 *  	  <simple attribute name> 
 * 		| <compound attribute name>
 * 
 * <compound attribute name> ::= 
 * 		<identifier><period> [{<identifier><period>}*] <simple attribute name>
 *
 * <simple attribute name> ::= <identifier>
 */ 
void Attribute() #void:
{}
{
	 	SimpleAttributeName() AttributeTail() 
}

/*
 * <simple attribute name> ::= <identifier>
 */
void SimpleAttributeName() #Simple_Attribute_Node:
{}
{
	Identifier()	
}

void AttributeTail() #Compound_Attribute_Node:
{}
{
 	 (  <PERIOD> SimpleAttributeName() )* 
}

/*
 * <literal> ::= 
 *			<signed numeric literal>
 * 		| 	<general literal>
 */
void Literal() #void :
{}
{
		NumericLiteral()
	| 	GeneralLiteral()	
}
void NumericLiteral() #void :
{}
{
		(("-") UnsignedNumericLiteral())  #NegativeNumber_Node 
	| 	UnsignedNumericLiteral() 

}
void UnsignedNumericLiteral() #void :
{}
{
		IntegerLiteral() 
  	| 	FloatingLiteral() 
}

/*
 *<general literal> ::= 
 * 			<character string literal>
 * 		| 	<datetime literal>
 * 		| 	<boolean literal>
 * 		| 	<geography literal
 */   
void GeneralLiteral() #void:
{}
{
  	StringLiteral()
//  | DatetimeLiteral()   TODO	
  |	BooleanLiteral() 
//  | GeographyLiteral()  TODO
}

void IntegerLiteral() #IntegerNode:
{}
{
  <INTEGER_LITERAL>
}

void FloatingLiteral() #FloatingNode:
{}
{
  <FLOATING_LITERAL>
}

void BooleanLiteral() #void :
{}
{
  <TRUE> #TrueNode |
  <FALSE> #FalseNode
}

void StringLiteral() #StringNode :
{}
{
    <STRING_LITERAL> 
}

/* ---------------------------------------- *
 *  <function>
 * ---------------------------------------- */
/*
 * <function> ::= <identifier> "("<function arg> [,<function arg>]*)
 */
void Function() #Function_Node:
{}
{
  		 FunctionName()
  			<LP>( FunctionArg() (<COMMA> FunctionArg() )* )? <RP>
}


void FunctionName() #FunctionName_Node:
{}
{
    <IDENTIFIER>
}

/*
 * <argument>  ::= 
 *      <literal>  
 *  |   <attribute name>                                            
 * 	|	<expression> (*extension: expresion inclue literal and attributes*) 
 */
void FunctionArg() #FunctionArg_Node:
{}
{
		Expression()
}
/* ---------------------------------------- *
 *  end <function>
 * ---------------------------------------- */

/*
 * <Point> := <x><space><y>
 */
void Point() #Point_Node:
{}
{
  NumericLiteral() NumericLiteral()
}

/*
 * <LineString Text> := EMPTY
 * | <left paren><Point>{<comma><Point >} ... <right paren>
 */
void LineStringText() #LineStringText_Node:
{}
{
  (<LP> Point() ( <COMMA> Point() )* <RP>)?
}

void PointTaggedText() #WKTNode:
{} 
{
   <POINT> PointText()
}
/*
 * <Point Text> := EMPTY | <left paren> <Point> <right paren>
 */
void PointText() #PointText_Node:
{}
{
	(<LP> Point() <RP>)?
}

void LineStringTaggedText() #WKTNode:
{}
{
   <LINESTRING> LineStringText() 
}
/*
 * <Polygon Tagged Text> := POLYGON <Polygon Text>
 */
void PolygonTaggedText() #WKTNode:
{}
{
  <POLYGON> PolygonText()
}


/*
 * <Polygon Text> := EMPTY
 *  	| <left paren><LineString Text>{<comma><LineString Text>}*<right paren>
 */
void PolygonText()#PolygonText_Node:
{}
{
	(<LP> LineStringText() (<COMMA> LineStringText())* <RP>)?
}

/*
 * <MultiPoint Tagged Text> ::= MULTIPOINT <Multipoint Text>
 */
void MultiPointTaggedText() #WKTNode:
{}
{
  <MULTIPOINT> MultiPointText()
}
/*
 * <Multipoint Text> := EMPTY
 * 	| ( <Point Text > {, <Point Text > }* )
 */
void MultiPointText() #MultiPointText_Node:
{}
{
 	(<LP> PointText() (<COMMA> PointText() )* <RP>)?
}

/*
 * <MultiLineString Tagged Text> := MULTILINESTRING <MultiLineString Text>
 */
void MultiLineStringTaggedText() #WKTNode:
{}
{
  <MULTILINESTRING> MultiLineStringText()
}
/*
 * <MultiLineString Text> := 
 *		EMPTY
 * 		| ( <LineString Text > {, < LineString Text > }* )
 */
void MultiLineStringText() #MultiLineStringText_Node:
{}
{
	( <LP> LineStringText() (<COMMA> LineStringText())* <RP> )?
}
/*
 * <MultiPolygon Tagged Text> :: =MULTIPOLYGON <MultiPolygon Text>
 */
void MultiPolygonTaggedText() #WKTNode:
{}
{
  <MULTIPOLYGON> MultiPolygonText()
}
/*
 * <MultiPolygon Text> := EMPTY
 * 	| <left paren><Polygon Text>{<comma><Polygon Text>}* <right paren>
 */
void MultiPolygonText() #MultiPolygonText_Node:
{}
{
	( <LP> PolygonText() ( <COMMA> PolygonText() )* <RP> )?
}

void GeometryCollectionTaggedText() #WKTNode:
{}
{
  <GEOMETRYCOLLECTION> GeometryCollectionText()
}

/*
 * <GeometryCollection Text> := EMPTY
 * | ( <Geometry Tagged Text> {, <Geometry Tagged Text> }* )
 */
 void GeometryCollectionText() #GeometryCollectionText_Node:
 {}
 {
 	( <LP> GeometryLiteral() ( <COMMA> GeometryLiteral() )* <RP>)?
 }
 
/*
 * <Envelope Tagged Text> ::= ENVELOPE <Envelope Text>
 */
 void EnvelopeTaggedText() #EnvelopeTaggedText_Node:
 {}
 {
 	jjtThis.token = <ENVELOPE> EnvelopText()
 }

/*
 * <Envelope Text> := EMPTY
 * | <left paren>
 *		<WestBoundLongitude><comma>
 *   	<EastBoundLongitude><comma>
 *   	<NorthBoundLatitude><comma>
 *   	<SouthBoundLatitude>
 *	<right paren>
 * <WestBoundLongitude> := numeric literal
 * <EastBoundLongitude> := numeric literal
 * <NorthBoundLatitude> := numeric literal
 * <SouthBoundLatitude> := numeric literal
 */
 void EnvelopText() #void:
 {}
 {
 	( <LP> 
 		NumericLiteral() <COMMA>
 		NumericLiteral() <COMMA>
 		NumericLiteral() <COMMA>
 		NumericLiteral() 
 	 <RP> )?
 }