/************************************************************************************************************************/
/*				Corese Grammar - 26/10/2006								*/
/************************************************************************************************************************/


Start			::=	Query? <EOF> 
Query			::= 	Prolog ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery | DeleteQuery )
Prolog 			::=	BaseDecl? PrefixDecl*
BaseDecl 		::=	<BASE> Q_IRI_ref
PrefixDecl		::=	<PREFIX> <QNAME_NS> Q_IRI_ref

// ---- Query type clauses

SelectQuery		::= 	( <SELECT> <DEBUG>? <NOSORT>? OneMoreListMerge GroupCountSortDisplayVar Max DatasetClause* )? WhereClause SolutionModifier
ConstructQuery 		::= 	<CONSTRUCT> ConstructTemplate DatasetClause* WhereClause SolutionModifier
DescribeQuery		::=	<DESCRIBE> ( ( Var | IRIref )+ | <STAR> ) DatasetClause* WhereClause? SolutionModifier
AskQuery 		::=	<ASK> DatasetClause* WhereClause
DeleteQuery		::= 	<DELETE> SelectVar WhereClause

// ---- Attributes in the select clause

// one more list merge in any order and without list and merge being together
OneMoreListMerge	::=	One ( More ( List | Merge )? | List More? | Merge More? )?
  				| More ( One ( List | Merge )? | List One? | Merge One? )?
				| ( ( List | Merge ) ( One More? | More One? )? )?
One			::=	<ONE>
More			::=	<S_MORE>
List			::=	<LIST>
Merge			::=	<MERGE>
GroupCountSortDisplayVar::=	GroupCountSortDisplay ( <DISTINCT> <SORTED>? )? ( SelectVar GroupCountSortDisplay )?
SelectVar		::=	( Var+ | <STAR> )
GroupCountSortDisplay	::=	( Group | Count | Sort | Display )* 
Group			::=	<GROUP> Var
Count			::=	<COUNT> Var
Sort			::=	<SORT> <REVERSE>? ( Var | FunctionCorese | <COUNT> | <DISTANCE> | BrackettedExpression | FunctionCall )
Display			::=	<DISPLAY> ( <D_FLAT> | <D_ASQUERY> | <INTEGER> | <QNAME> | <D_XML> | <D_BLANK> )
// projection threshold result in any order
Max			::=	Projection ( Result Threshold? | Threshold Result? )?
				| Result ( Projection Threshold? | Threshold Projection? )? 
				| ( Threshold ( Projection Result? | Result Projection? )? )?
Projection		::=	<PROJECTION> ( <INTEGER> | <QNAME> )
Result			::=	<RESULT> ( <INTEGER> | <QNAME> )
Threshold		::=	<THRESHOLD> ( <INTEGER> | <QNAME> )
Define			::=	Pref*
Pref			::=	<SIMPLE_STRING> <AS> Q_IRI_ref_without

// ----

DatasetClause		::=	<FROM> ( DefaultGraphClause | NamedGraphClause )
DefaultGraphClause 	::= 	SourceSelector
NamedGraphClause 	::=	<NAMED> SourceSelector
SourceSelector		::=	IRIref
WhereClause		::=	<WHERE>? GroupGraphPattern
// order limit offset in any order
SolutionModifier	::=	OrderClause ( LimitClause OffsetClause? | OffsetClause LimitClause? )?
				| LimitClause ( OrderClause OffsetClause? | OffsetClause OrderClause? )? 
				| ( OffsetClause ( OrderClause LimitClause? | LimitClause OrderClause? )? )?
OrderClause		::=	<ORDER> <BY> OrderCondition+
OrderCondition		::=	( ( <ASC> | <DESC> )? ( BrackettedExpression | <DISTANCE> ) ) | FunctionCall | tm = FunctionCorese | Var
LimitClause		::=	<LIMIT> <INTEGER>
OffsetClause		::=	<OFFSET> <INTEGER>

// ---- General Graph Pattern 

GroupGraphPattern	::=	<LBRACE> Define GraphPattern <RBRACE>
GraphPattern		:==	FilteredBasicGraphPattern ( GraphPatternNotTriples <DOT>? GraphPattern )?  	 
FilteredBasicGraphPattern::=	BlockOfTriples? ( Constraint <DOT>? FilteredBasicGraphPattern )?
BlockOfTriples		::=	TriplesSameSubject ( <DOT> | TriplesSameSubject	)*
GraphPatternNotTriples	::=	OptionalGraphPattern | GroupOrUnionGraphPattern	| GraphGraphPattern | ScoreGraphPattern

// ---- Definitions of each pattern element

OptionalGraphPattern	::=	( <OPTIONAL> | <OPTION> ) GroupGraphPattern
GraphGraphPattern	::=	( <GRAPH> | <SOURCE> VarOrBlankNodeOrIRIref GroupGraphPattern
ScoreGraphPattern	::=	<SCORE> VarOrBlankNodeOrIRIref GroupGraphPattern
GroupOrUnionGraphPattern::=	GroupGraphPattern ( ( <UNION> | <OR> ) GroupGraphPattern )*  
Constraint		::=	<FILTER> ( BrackettedExpression | BuiltInCall | FunctionCall )

// -------- Construct patterns

ConstructTemplate	::=	<LBRACE> ConstructTriples <RBRACE>
ConstructTriples	::=	( TriplesSameSubject <DOT>? ConstructTriples )?

// -------- Triple lists with property and object lists

TriplesSameSubject	::=	( VarOrTerm PropertyListNotEmpty | TriplesNode PropertyList )
PropertyList		::=	PropertyListNotEmpty?
PropertyListNotEmpty	::=	Verb2 ObjectList ( <SEMICOLON> PropertyList )?
Verb2			::=	PQualifier Verb ( <LBRACE> <INTEGER> <RBRACE> | <LBRACKET> <INTEGER> <RBRACKET> )?
PQualifier		::=	( One2 ( All2 Direct2? | Direct2 All2? )?
				| All2 ( One2 Direct2? | Direct2 One2? )? 
				| ( Direct2 ( One2 All2? | All2 One2? )? )?
One2			::=	<ONE2>
All2			::=	<ALL2>
Direct2			::=	<DIRECT2>
ObjectList		::=	GraphNode ( <COMMA> ObjectList )?
Verb			::=	( PropertyVarOrIRIref | <KW_A> )
PropertyVarOrIRIref	::=	( <QNAME> ( <COLON2> Var )? | Var | Q_IRI_ref_without | QNAME_NS> )
Soper			::=	( <EQ> | <NE> | <LT> | <GT> | <LE> | <GE> | <EQ2> | <NE2> | <TILDE> | <CONTAINED> | <BEGIN_WITH> )
Toper			::=	( <STRICT_SPEC> | <SPEC> | <SAME> | <GENERALISATION> | <STRICT_GENERALISATION> )

// -------- Triple expansions

TriplesNode		::=	( Collection | BlankNodePropertyList )
BlankNodePropertyList	::=	<LBRACKET> PropertyListNotEmpty <RBRACKET>

// ------- RDF collections

Collection		::=	<LPAREN> GraphNode+ <RPAREN>

// -------- Nodes in a graph pattern or template

GraphNode		::=	VarOrTerm | TriplesNode
VarOrTerm		::=	Var | GraphTerm
VarOrBlankNodeOrIRIref	::=	( Var | BlankNode | IRIref )
Var			::=	<VAR1> | <VAR2> 
GraphTerm		::=	( ( Q_IRI_ref_without | <QNAME> ( <COLON2> Var )? | <QNAME_NS> | RDFLiteral ( <MINUS> | <PLUS> )? NumericLiteral | 						BooleanLiteral | <NIL> ) | BlankNode )

// -------- Constraint syntax

Expression		::=	ConditionalOrExpression
ConditionalOrExpression	::=	ConditionalAndExpression ( <SC_OR> ConditionalAndExpression )* 
ConditionalAndExpression::=	ValueLogical ( <SC_AND> ValueLogical )*
ValueLogical		::=	RelationalExpression
RelationalExpression	::=	NumericExpression ( <EQ_LANG> NumericExpression | Soper NumericExpression | NumericExpression )?
NumericExpression	::=	AdditiveExpression
AdditiveExpression	::=	MultiplicativeExpression ( <PLUS> MultiplicativeExpression | <MINUS> MultiplicativeExpression )*
MultiplicativeExpression::=	UnaryExpression ( <STAR> UnaryExpression | <SLASH> UnaryExpression )*
UnaryExpression		::=	( <BANG> PrimaryExpression | <PLUS> PrimaryExpression | <MINUS> PrimaryExpression | PrimaryExpression )
BuiltInCall		::=	( ( <STR> | <DTYPE> | <LANG> | <IS_IRI> | <IS_URI> | <IS_BLANK> | <IS_LITERAL> ) <LPAREN> Expression <RPAREN> )
				| <BOUND> <LPAREN> Var <RPAREN>
				| <LANGMATCHES> <LPAREN> Expression <COMMA> Expression <RPAREN>
				| RegexExpression
				| FunctionCorese
RegexExpression		::=	<REGEX> <LPAREN> Expression <COMMA> Expression ( <COMMA> Expression )? <RPAREN>
FunctionCall		::=	IRIref ArgList
FunctionCorese		::=	( <SIMPLE_STRING> | <DISTANCE> | <SCORE> | <COUNT> ) ArgList 
IRIrefOrFunction	::=	IRIref ArgList?
ArgList			::=	( <NIL> | <LPAREN> Expression ( <COMMA> Expression )* <RPAREN> )
BrackettedExpression	::=	<LPAREN> Expression <RPAREN>
PrimaryExpression	::=	( BrackettedExpression | BuiltInCall | Var | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | IRIrefOrFunction )
NumericLiteral		::=	( <INTEGER> | <DECIMAL> | <DOUBLE> )
RDFLiteral		::=	String ( <LANGTAG> | ( <DATATYPE> IRIref ) )?
BooleanLiteral		::=	<TRUE> | <FALSE>
String			::=	( <STRING_LITERAL1> | <STRING_LITERAL2> | <STRING_LITERAL_LONG1> | <STRING_LITERAL_LONG2> )
IRIref			::=	Q_IRI_ref_without | QName 
QName			::=	<QNAME> | <QNAME_NS>
BlankNode		::=	<BLANK_NODE_LABEL> | <ANON> 
Q_IRI_ref		::=	<Q_IRIref>
Q_IRI_ref_without	::=	<Q_IRIref>


// ------------------------------------------
// Tokens
// ------------------------------------------

// Comments and whitespace

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

TOKEN: { <#WS: " " | "\t" | "\n" | "\r" | "\f"> }

SPECIAL_TOKEN :
{ <SINGLE_LINE_COMMENT: "#" (~["\n","\r"])* ("\n"|"\r"|"\r\n")? > }

// Main tokens */

TOKEN:
{
   // Includes # for relative URIs
   <Q_IRIref: "<" (~[">","<","\u0000"-"\u0020"])* ">" > 
   
| <QNAME_NS: (<NCNAME_PREFIX>)? ":" >
| <QNAME: (<NCNAME_PREFIX>)? ":" (<NCNAME>)? >
| <BLANK_NODE_LABEL: "_:" <NCNAME> >
| <VAR1: "?" <VARNAME> >
| <VAR2: "$" <VARNAME> >
| <LANGTAG: <AT> (<A2Z>)+(("-"|":") (<A2ZN>)+)* >	// pour accepter @get:lang
| <#A2Z: ["a"-"z","A"-"Z"]>
| <#A2ZN: ["a"-"z","A"-"Z","0"-"9"]>
}

// -------------------------------------------------
// Keyworks : includes operators that are words and should be
// before general things like IDENTIFIER which swallow almost
// anything

TOKEN : { <KW_A: "a" > } // Before HEX rule!

TOKEN [IGNORE_CASE] :
{
// Prologue
   < BASE: "base" >
| < PREFIX: "prefix" >

// Result forms
| < SELECT: "select" >
| < DISTINCT: "distinct" >
| < DESCRIBE: "describe" >
| < CONSTRUCT: "construct" >
| < ASK: "ask" >
| < DELETE: "delete" >

| < LIMIT: "limit" >
| < OFFSET: "offset" >
| < ORDER: "order" >
| < BY: "by" >

| < ASC: "asc" >
| < DESC: "desc" >

// Dataset
| < NAMED: "named" >
| < FROM: "from" >

// Graph pattern operators 
| < WHERE: "where" >
| < AND: "and" >
| < GRAPH: "graph" >
| < OPTIONAL: "optional" >
| < UNION: "union" >

| < FILTER: "filter" >

// Expression operators
| < BOUND: "bound" >
| < STR: "str" >
| < DTYPE: "datatype" >
| < LANG: "lang" >
| < LANGMATCHES: "langmatches" >
| < IS_URI: "isURI" >
| < IS_IRI: "isIRI" >
| < IS_BLANK: "isBlank" >
| < IS_LITERAL: "isLiteral" >
| < REGEX: "regex" >

| <TRUE: "true" >
| <FALSE: "false" >
}

// -------------------------------------------------
// Rajouts pour CORESE
// -------------------------------------------------

TOKEN [IGNORE_CASE] :
{
  <ONE: "one" >
| <S_MORE: "more" >
| <LIST: "list" >
| <MERGE: "merge" >
| <DISPLAY: "display" >
| <D_FLAT: "flat" >
| <D_ASQUERY: "asquery" >
| <D_XML: "xml" >
| <D_BLANK: "blank" >
| <THRESHOLD: "threshold" >
| <RESULT: "result" >
| <PROJECTION: "projection" >
| <GROUP: "group" >
| <COUNT: "count" >
| <SOURCE: "source" >
| <SCORE: "score" >
| <AS: "as" >
| <SORT: "sort" >
| <REVERSE: "reverse" >
| <OR: "or" >
| <OPTION: "option" >
| <SORTED: "sorted" >
| <ALL2: "all::" >
| <ONE2: "one::">
| <DIRECT2: "direct::" >
| <COLON2: "::" >
| <DISTANCE: "distance">
| <DEBUG: "debug">
| <NOSORT: "nosort">
}

TOKEN [IGNORE_CASE] :
{
  <CONTAINED: "in">
}

TOKEN :
{
  <EQ2: "==">
| <NE2: "!==">
| <BEGIN_WITH: "^">
| <STRICT_SPEC: "<:">
| <SPEC: "<=:">
| <SAME: "=:">
| <GENERALISATION: ">=:">
| <STRICT_GENERALISATION: ">:">
| <EQ_LANG: "~=">
}

TOKEN [IGNORE_CASE] :
{
  <SIMPLE_STRING: <NCNAME> >  
}

// -------------------------------------------------

TOKEN :
{
   < INTEGER: /*(["-","+"])?*/ <DIGITS> >
|
   < DECIMAL: /*(["-","+"])?*/ (<DIGITS>)+ "." (<DIGITS>)* | "." (<DIGITS>)+ >
      // Required exponent.
| < DOUBLE:
      //(["+","-"])?
      (["0"-"9"])+ "." (["0"-"9"])* <EXPONENT>
      | "." (["0"-"9"])+ (<EXPONENT>)
      | (["0"-"9"])+ <EXPONENT>
      >
   // Optional exponent.
| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
| < #QUOTE_3D: "\"\"\"">
| < #QUOTE_3S: "'''">
| <ECHAR: "\\" ("t"|"b"|"n"|"r"|"f"|"\\"|"\""|"'")>

| < STRING_LITERAL1:
      // Single quoted string
      "'" ( (~["'","\\","\n","\r"]) | <ECHAR> )* "'" >
| < STRING_LITERAL2:
    // Double quoted string
      "\"" ( (~["\"","\\","\n","\r"]) | <ECHAR> )* "\"" >
| < STRING_LITERAL_LONG1:
     <QUOTE_3S>
      ( ~["'","\\"] | <ECHAR> | ("'" ~["'"]) | ("''" ~["'"]))*
     <QUOTE_3S> >
| < STRING_LITERAL_LONG2:
     <QUOTE_3D>
      ( ~["\"","\\"] | <ECHAR> | ("\"" ~["\""]) | ("\"\"" ~["\""]))*
     <QUOTE_3D> >
| < DIGITS: (["0"-"9"])+>
| <HEX: ["0"-"9"] | ["A"-"F"] | ["a"-"f"]>
}

TOKEN :
{
  < LPAREN: "(" >
| < RPAREN: ")" >

// I don't know why white space is needed to be included here but not ANON
| <NIL: <LPAREN> (<WS>)* <RPAREN> >

| < LBRACE: "{" >
| < RBRACE: "}" >

| < LBRACKET: "[" >
| < RBRACKET: "]" >
// (<WS>)* is not needed but is in NIL
| < ANON: <LBRACKET> (<WS>)* <RBRACKET> >

| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
}

// Operator

TOKEN :
{
  < EQ: "=" >
| < NE: "!=" >
| < GT: ">" >
| < LT: "<" >
| < LE: "<=" > // Maybe: | "=>" >
| < GE: ">=" > // Maybe: | "=<" >

| < BANG: "!" >
| <TILDE: "~">
| < COLON: ":" >

| < SC_OR: "||" >
| < SC_AND: "&&" >

| < PLUS: "+" >
| < MINUS: "-" >
| < STAR: "*" >
| < SLASH: "/" >

| < DATATYPE: "^^">
| < AT: "@">
}

// See XML chars.txt for notes

TOKEN:
{
  // XML 1.1 NCNameStartChar without "_"
  <#NCCHAR1p:
          ["A"-"Z"] | ["a"-"z"] |
          ["\u00C0"-"\u00D6"] | ["\u00D8"-"\u00F6"] | ["\u00F8"-"\u02FF"] |
          ["\u0370"-"\u037D"] | ["\u037F"-"\u1FFF"] |
          ["\u200C"-"\u200D"] | ["\u2070"-"\u218F"] | ["\u2C00"-"\u2FEF"] |
          ["\u3001"-"\uD7FF"] | ["\uF900"-"\uFFFD"] >
          // [#x10000-#xEFFFF]
|
  <#NCCHAR1: <NCCHAR1p> | "_" >

// No trailing DOTs in qnames.
|
  // #NCCHAR without "."
  <#NCCHAR: (<NCCHAR1> | "-" | ["0"-"9"] | "\u00B7" |
              ["\u0300"-"\u036F"] | ["\u203F"-"\u2040"] ) >
|
  // NCNAME but no leading "_", no trailing ".", can have dot inside prefix name.
  <#NCNAME_PREFIX: <NCCHAR1p> ((<NCCHAR>|".")* <NCCHAR>)? >
|
  // With a leading "_", no dot at end of local name.
  <#NCNAME: <NCCHAR1> ((<NCCHAR>|".")* <NCCHAR>)? >
|
  // NCNAME without "-" and ".", allowing leading digits.
  <#VARNAME: ( <NCCHAR1> | ["0"-"9"] )
             ( <NCCHAR1> | ["0"-"9"] | "\u00B7" |
               ["\u0300"-"\u036F"] | ["\u203F"-"\u2040"] )* >
}