DOCUMENT START
NON-TERMINALS
	CompilationUnit	:=	Query <EOF>
	Query	:=	Prologue ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )
	Prologue	:=	( BaseDecl )? ( PrefixDecl )*
	BaseDecl	:=	<BASE> IRI_REF
	PrefixDecl	:=	<PREFIX> <PNAME_NS> IRI_REF
// ---- Query type clauses
	SelectQuery	:=	<SELECT> ( <DISTINCT> | <REDUCED> )? ( ( Var )+ | <STAR> ) ( DatasetClause )* WhereClause SolutionModifier
	ConstructQuery	:=	<CONSTRUCT> ConstructTemplate ( DatasetClause )* WhereClause SolutionModifier
	DescribeQuery	:=	<DESCRIBE> ( ( VarOrIRIref )+ | <STAR> ) ( DatasetClause )* ( WhereClause )? SolutionModifier
	AskQuery	:=	<ASK> ( DatasetClause )* WhereClause
// ----
	DatasetClause	:=	<FROM> ( DefaultGraphClause | NamedGraphClause )
	DefaultGraphClause	:=	SourceSelector
	NamedGraphClause	:=	<NAMED> SourceSelector
	SourceSelector	:=	IRIref
	WhereClause	:=	( <WHERE> )? GroupGraphPattern
	SolutionModifier	:=	( OrderClause )? ( LimitOffsetClauses )?
	LimitOffsetClauses	:=	( LimitClause ( OffsetClause )? | OffsetClause ( LimitClause )? )
	OrderClause	:=	<ORDER> <BY> ( OrderCondition )+
	OrderCondition	:=	( ( ( <ASC> | <DESC> ) BrackettedExpression ) | ( Constraint | Var ) )
	LimitClause	:=	<LIMIT> <INTEGER>
	OffsetClause	:=	<OFFSET> <INTEGER>
// ---- General Graph Pattern 
	GroupGraphPattern	:=	<LBRACE> ( TriplesBlock )? ( ( GraphPatternNotTriples | Filter ) ( <DOT> )? ( TriplesBlock )? )* <RBRACE>
	TriplesBlock	:=	TriplesSameSubject ( <DOT> ( TriplesBlock )? )?
// @@ Ready to be deleted
// Element GroupGraphPattern() : { Element el = null ; ElementTriplesBlock acc = null ; }
// {
//     { ElementGroup elg = new ElementGroup() ; }
//   <LBRACE>
//       { startGroup(elg) ; }
//   // Ensure two BGP's can't be next to each other
//   // Done by seeing if there is a non-BGP and recursing
//   // if there is an intermediate
//   (
//     { acc = new ElementTriplesBlock() ;
//       startTriplesBlock(acc) ;
//     }
//     el = TriplesBlock(acc)
//     { endTriplesBlock(acc) ;
//       elg.addElement(el) ; } 
//   )?
//   (
//     ( el = GraphPatternNotTriples() | el = Filter() )
//     { elg.addElement(el) ; }
//     (<DOT>)?
// 
//     (
//       { acc = new ElementTriplesBlock() ;
//         startTriplesBlock(acc) ;
//       }
//       el = TriplesBlock(acc)
//       { endTriplesBlock(acc) ;
//         elg.addElement(el) ; } 
//     )?
//   )*
//       { endGroup(elg) ; }
//   <RBRACE>
//     { return elg ; }
// }

// Element GroupGraphPattern() : {}
// {
//     { ElementGroup elg = new ElementGroup() ; }
//   <LBRACE>
//       { startGroup(elg) ; }
//     GraphPatternElement(elg)
//       { endGroup(elg) ; }
//   <RBRACE>
//     { return elg ; }
// }
// 
// 
// // Without {}
// // If the recusion is removed can roll GraphPatternElement into GroupGraphPattern()
// 
// void GraphPatternElement(ElementGroup elg) : 
//     { Element el = null ; ElementTriplesBlock acc = null ; }
// {
//   // Ensure two BGP's can't be next to each other
//   // Done by seeing if there is a non-BGP and recursing
//   // if there is an intermediate
//   (
//     { acc = new ElementTriplesBlock() ;
//       startTriplesBlock(acc) ;
//     }
//     el = TriplesBlock(acc)
//     { endTriplesBlock(acc) ;
//       elg.addElement(el) ; } 
//   )?
//   (
//     ( el = GraphPatternNotTriples()
//     | el = Filter()                 
//     )
//     { elg.addElement(el) ; }
//     (<DOT>)?
//     GraphPatternElement(elg)
//   )?
// }
// 
// 
// Element TriplesBlock(ElementTriplesBlock acc) : { }
// {
//   { if ( acc == null )
//       acc = new ElementTriplesBlock() ;
//   }
//   TriplesSameSubject(acc)
//   ( <DOT> (TriplesBlock(acc))? )?
//     { return acc ; }
// }


// -----
	GraphPatternNotTriples	:=	( OptionalGraphPattern | GroupOrUnionGraphPattern | GraphGraphPattern )
// ---- Definitions of each pattern element
	OptionalGraphPattern	:=	<OPTIONAL> GroupGraphPattern
	GraphGraphPattern	:=	<GRAPH> VarOrIRIref GroupGraphPattern
// G (union G)* can be a single group pattern
// or a group pattern as part of an union.
	GroupOrUnionGraphPattern	:=	GroupGraphPattern ( <UNION> GroupGraphPattern )*
	Filter	:=	<FILTER> Constraint
	Constraint	:=	( BrackettedExpression | BuiltInCall | FunctionCall )
	FunctionCall	:=	IRIref ArgList
	ArgList	:=	( <NIL> | <LPAREN> Expression ( <COMMA> Expression )* <RPAREN> )
// -------- Construct patterns
	ConstructTemplate	:=	<LBRACE> ( ConstructTriples )? <RBRACE>
	ConstructTriples	:=	TriplesSameSubject ( <DOT> ( ConstructTriples )? )?
// -------- Triple lists with property and object lists
	TriplesSameSubject	:=	VarOrTerm PropertyListNotEmpty
		|	TriplesNode PropertyList
	PropertyListNotEmpty	:=	Verb ObjectList ( <SEMICOLON> ( Verb ObjectList )? )*
	PropertyList	:=	( PropertyListNotEmpty )?
// // Recursive
// void PropertyListNotEmpty(Node s, TripleCollector acc) : { Node p ; }
// {
//   p = Verb()
//   ObjectList(s, p, acc)
//   (<SEMICOLON> PropertyList(s, acc) ) ?
// #ifdef ARQ
//   |
//   Reification(s, acc)
// #endif
// }

// // Recursive
// void ObjectList(Node s, Node p, TripleCollector acc): { Node o ; } 
// {
//     { int mark = acc.mark() ; }
//   o = GraphNode(acc) 
//     { insert(acc, mark, s, p, o) ; }
//   ( <COMMA> ObjectList(s, p , acc) )?
// }
	ObjectList	:=	Object ( <COMMA> Object )*
	Object	:=	GraphNode
	Verb	:=	( VarOrIRIref | <KW_A> )
// -------- Triple expansions

// Anything that can stand in a node slot and which is
// a number of triples
	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 )
// Property (if no bNodes) + DESCRIBE
	VarOrIRIref	:=	( Var | IRIref )
// // GRAPH and property if including blank nodes are properties.
// Node VarOrBlankNodeOrIRIref() : {Node n = null ; }
// {
//   ( n = Var() | n = BlankNode() | n = IRIref() )
//   { return n ; }
// }
	Var	:=	( <VAR1> | <VAR2> )
	GraphTerm	:=	IRIref
		|	RDFLiteral
		|	NumericLiteral
		|	BooleanLiteral
		|	BlankNode
		|	<NIL>
// -------- Constraint syntax
	Expression	:=	ConditionalOrExpression
	ConditionalOrExpression	:=	ConditionalAndExpression ( <SC_OR> ConditionalAndExpression )*
	ConditionalAndExpression	:=	ValueLogical ( <SC_AND> ValueLogical )*
	ValueLogical	:=	RelationalExpression
	RelationalExpression	:=	NumericExpression ( <EQ> NumericExpression | <NE> NumericExpression | <LT> NumericExpression | <GT> NumericExpression | <LE> NumericExpression | <GE> NumericExpression )?
	NumericExpression	:=	AdditiveExpression
	AdditiveExpression	:=	MultiplicativeExpression ( <PLUS> MultiplicativeExpression | <MINUS> MultiplicativeExpression | NumericLiteralPositive | NumericLiteralNegative )*
	MultiplicativeExpression	:=	UnaryExpression ( <STAR> UnaryExpression | <SLASH> UnaryExpression )*
	UnaryExpression	:=	<BANG> PrimaryExpression
		|	<PLUS> PrimaryExpression
		|	<MINUS> PrimaryExpression
		|	PrimaryExpression
	PrimaryExpression	:=	( BrackettedExpression | BuiltInCall | IRIrefOrFunction | RDFLiteral | NumericLiteral | BooleanLiteral | Var )
	BrackettedExpression	:=	<LPAREN> Expression <RPAREN>
	BuiltInCall	:=	<STR> <LPAREN> Expression <RPAREN>
		|	<LANG> <LPAREN> Expression <RPAREN>
		|	<LANGMATCHES> <LPAREN> Expression <COMMA> Expression <RPAREN>
		|	<DTYPE> <LPAREN> Expression <RPAREN>
		|	<BOUND> <LPAREN> Var <RPAREN>
		|	<SAME_TERM> <LPAREN> Expression <COMMA> Expression <RPAREN>
		|	<IS_IRI> <LPAREN> Expression <RPAREN>
		|	<IS_URI> <LPAREN> Expression <RPAREN>
		|	<IS_BLANK> <LPAREN> Expression <RPAREN>
		|	<IS_LITERAL> <LPAREN> Expression <RPAREN>
		|	RegexExpression
	RegexExpression	:=	<REGEX> <LPAREN> Expression <COMMA> Expression ( <COMMA> Expression )? <RPAREN>
// The case of "q:name()" or just "q:name"
// by expanding out FunctionCall()
	IRIrefOrFunction	:=	IRIref ( ArgList )?
	RDFLiteral	:=	String ( ( <LANGTAG> ) | ( <DATATYPE> IRIref ) )?
	NumericLiteral	:=	( NumericLiteralUnsigned | NumericLiteralPositive | NumericLiteralNegative )
	NumericLiteralUnsigned	:=	<INTEGER>
		|	<DECIMAL>
		|	<DOUBLE>
	NumericLiteralPositive	:=	<INTEGER_POSITIVE>
		|	<DECIMAL_POSITIVE>
		|	<DOUBLE_POSITIVE>
	NumericLiteralNegative	:=	<INTEGER_NEGATIVE>
		|	<DECIMAL_NEGATIVE>
		|	<DOUBLE_NEGATIVE>
	BooleanLiteral	:=	<TRUE>
		|	<FALSE>
	String	:=	( <STRING_LITERAL1> | <STRING_LITERAL2> | <STRING_LITERAL_LONG1> | <STRING_LITERAL_LONG2> )
	IRIref	:=	IRI_REF
		|	PrefixedName
	PrefixedName	:=	( <PNAME_LN> | <PNAME_NS> )
	BlankNode	:=	<BLANK_NODE_LABEL>
		|	<ANON>
	IRI_REF	:=	<IRIref>

DOCUMENT END