// ARQ/SPARQL Grammar - native syntax for the query engine
// Experimental grammar
//#define NEW_GRAMMAR

//
// Author:  Andy Seaborne andy.seaborne@hp.com
// (c) Copyright 2004, 2005 Hewlett-Packard Development Company, LP
// All rights reserved.
// See end of file for details.
//
// Constraint expression is derived from Java : 
// example java1.2-a.jj grammer in JavaCC distribution
// Much modifed over time.

options
{
  // Use \ u escapes in streams AND use a reader for the query
  // => get both raw and escaped unicode

  JAVA_UNICODE_ESCAPE = true;
  UNICODE_INPUT = false ;
  STATIC = false ;
//  DEBUG_PARSER          = true ;
//  DEBUG_TOKEN_MANAGER   = true ;
}

PARSER_BEGIN(ARQParser)
/*
 * (c) Copyright 2004, 2005 Hewlett-Packard Development Company, LP
 * All rights reserved.
 */

package com.hp.hpl.jena.query.parser.arq ;

import java.util.* ;
import com.hp.hpl.jena.graph.* ;
import com.hp.hpl.jena.query.* ;
import com.hp.hpl.jena.query.core.* ;
import com.hp.hpl.jena.query.expr.* ;

public class ARQParser extends ARQParserBase
{
}
PARSER_END(ARQParser)

void CompilationUnit(): { }
{
  Query() <EOF>
}

void Query() : { }
{
  Prolog()
  ( SelectQuery() | ConstructQuery() | DescribeQuery() | AskQuery() )
}

void Prolog() : {}
{
  ( BaseDecl() ) ?
  ( PrefixDecl() )*
}

void BaseDecl() : { Node n ; }
{
  <BASE> n = QuotedIRIref()
  { getQuery().setBaseURI(n.getURI()) ; }
}


void PrefixDecl() : { Token t ; Node n ; }
{
    <PREFIX> t = <QNAME_NS> n = QuotedIRIref()
      { String s = fixupPrefix(t.image, t.beginLine, t.beginColumn) ;
        getQuery().setPrefix(s, n.getURI()) ; }
}

// ---- Query type clauses

void SelectQuery() : { Node v ; Token t = null ;}
{
  <SELECT>
    { getQuery().setQueryType(Query.QueryTypeSelect) ; }
  (t = <DISTINCT>)?
    { getQuery().setDistinct( t != null ) ; }
  (
    ( v = Var() { getQuery().addResultVar(v) ; } )+
    { getQuery().setQueryResultStar(false) ; }
  |
    <STAR> { getQuery().setQueryResultStar(true) ; }
  )

  ( DatasetClause() )*
  WhereClause()
  SolutionModifier()
}

void ConstructQuery() : { Template t ; }
{
  <CONSTRUCT>
    { getQuery().setQueryType(Query.QueryTypeConstruct) ;
      setInConstructTemplate(true) ; }
  t = ConstructTemplate()
    { setInConstructTemplate(false) ;
      getQuery().setQueryResultStar(false) ;
      getQuery().setConstructTemplate(t) ; }
  ( DatasetClause() )*
  WhereClause()
  SolutionModifier()
}

void DescribeQuery() : { Node n ; }
{
  <DESCRIBE>
    { getQuery().setQueryType(Query.QueryTypeDescribe) ; }
  (
    ( n = VarOrIRIref() { getQuery().addDescribeNode(n) ; } )+
    { getQuery().setQueryResultStar(false) ; }
  |
    <STAR>
    { getQuery().setQueryResultStar(true) ; }
  )
  ( DatasetClause() )*
  ( WhereClause() )?
  SolutionModifier()
}

void AskQuery() : {}
{
  <ASK> { getQuery().setQueryType(Query.QueryTypeAsk) ; }
  ( DatasetClause() )*
  WhereClause()
}

// ----

void DatasetClause() : {}
{
  <FROM>
  ( DefaultGraphClause() | NamedGraphClause() )
}

void DefaultGraphClause() : { Node n ; }
{
  n = SourceSelector()
  { getQuery().addGraphURI(n.getURI()) ; }
}

void NamedGraphClause() : { Node n ; }
{
  <NAMED>
  n = SourceSelector()
  { getQuery().addNamedGraphURI(n.getURI()) ; }
}

Node SourceSelector() : { Node n ; }
{
  n = IRIref()
  { if ( ! n.isURI() )
        throw new QueryException("Not an URI: "+n.toString()) ;
    return n ;
  }
}


void WhereClause() : { Element el ; }
{
   (<WHERE>)? el = GroupGraphPattern() { getQuery().setQueryElement(el) ; }
}

void SolutionModifier() : { }
{
  ( OrderClause() )?
  ( LimitClause() )?
  ( OffsetClause() )?
}


void OrderClause() : { }
{
  <ORDER> <BY> ( OrderCondition() )+
}

void OrderCondition() :
{ int direction = Query.ASCENDING ; Expr expr = null ; Node v = null ; }
{
  { direction = Query.ASCENDING ; }
  (
    ( // These are for clarity in the HTML
      ( <ASC> | <DESC> { direction = Query.DESCENDING ; } )
      expr = BrackettedExpression()
    )
  |
    ( // Unbracketted function call, plain variable.
      // Or bracketted expression
      expr = FunctionCall()
    | v = Var() //{ expr = asExpr(v) ; } 
    | expr = BrackettedExpression()
    )
  )
  { if ( v == null )
          getQuery().addOrderBy(expr, direction) ;
      else
          getQuery().addOrderBy(v, direction) ; }
}

void LimitClause() : { Token t ; }
{
  <LIMIT> t = <INTEGER>
    { getQuery().setLimit(integerValue(t.image)) ; }
}

void OffsetClause() : { Token t ; }
{
  <OFFSET> t = <INTEGER>
    { getQuery().setOffset(integerValue(t.image)) ; }
}

// ---- General Graph Pattern 

// Basic building block.
// -- June 28 DAWG Grammar.
// Needs Triples()
Element GroupGraphPattern() : {}
{
    { ElementGroup elg = new ElementGroup() ; }
  <LBRACE>
    GraphPattern(elg)
  <RBRACE>
    {return elg ; }
}

void GraphPattern(ElementGroup elg) : { Element el = null ; }
{
  (Triples(elg) (<DOT>)? )?
  (
    el = GraphPatternNotTriples() { elg.addElement(el) ; }
    (<DOT>)?
    GraphPattern(elg)
  )?
}
// -- June 28 DAWG Grammar.


Element GraphPatternNotTriples() : { Element el = null ; }
{
   el = OptionalGraphPattern() { return el ; }
 |
   // "GroupPattern" or "GroupPattern" union "GroupPattern"
   el = GroupOrUnionGraphPattern() { return el ; }
 |
   el = GraphGraphPattern() { return el ; }

 |
   el = UnsaidGraphPattern() { return el ; }
 |
   el = GraphMatchExtension() { return el ; }

 |
   el = Constraint() { return el ; }
}

// ---- Definitions of each pattern element

Element OptionalGraphPattern() : { Element el ; }
{ <OPTIONAL> el = GroupGraphPattern()
    { return new ElementOptional(el) ; }
}

Element GraphGraphPattern() : { Element el ; Node n ;}
{
  <GRAPH> n = VarOrBlankNodeOrIRIref() el = GroupGraphPattern()
    { return new ElementNamedGraph(n, el) ; }
}

// G (union G)* can be a single group pattern
// or a group pattern as part of an union.
Element GroupOrUnionGraphPattern() :
{ Element el = null ; ElementUnion el2 = null ; }
{
  el = GroupGraphPattern()
  ( <UNION>
    { if ( el2 == null )
      {
        el2 = new ElementUnion() ;
        el2.addElement(el) ;
      }
    }
  el = GroupGraphPattern()
    { el2.addElement(el) ; }
  )*
    { return (el2==null)? el : el2 ; }
}


Element UnsaidGraphPattern() : { Element el ; }
{
  <UNSAID> el = GroupGraphPattern()
    { el = new ElementUnsaid(el) ;
      return el ;
    }
}

Element GraphMatchExtension() : { Element el = null ; Node n ; List a = null ; }
{
    // Need a syntax that is delimiting.  This isn't.
    <EXT>
    n = IRIref()
    a = ArgList()
    // Ambiguity here - may be followed by a group.
    //(el = GroupGraphPattern())?
    { return new ElementExtension(n.getURI(), a, el) ; }
}



Element Constraint() : { Constraint c ; }
{
  <FILTER>
  ( c = BrackettedExpression()
  | c = BuiltInCall()
  | c = FunctionCall()
  )

  //c = Expression()
  {
    ElementFilter ec = new ElementFilter(c) ;
    return ec ;
  }
}

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

Template ConstructTemplate() : { }
{
    { TemplateGroup g = new TemplateGroup() ; }
  <LBRACE>
    ConstructTriples(g)
  <RBRACE>
    { return g ; }
}

void ConstructTriples(TemplateGroup acc) : { }
{
  (
    Triples1(acc)
    (<DOT> ConstructTriples(acc))?
  )?
//    (Triples(acc))? (<DOT>)?
}

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

void Triples(TripleCollector acc) : { }
{
  // Collect adjacent triples
  // Lookahead because <DOT> can be followed by non-triples pattern.
  Triples1(acc) (LOOKAHEAD(2) <DOT> Triples(acc))?
}

void Triples1(TripleCollector acc) : { Node s ; }
{
  s = VarOrTerm()
  PropertyListNotEmpty(s, acc)
|
  // Any of the triple generating syntax elements
  s = TriplesNode(acc)
  PropertyList(s, acc)
}

void PropertyList(Node s, TripleCollector acc) : { }
{
  ( PropertyListNotEmpty(s, acc) ) ?
}

void PropertyListNotEmpty(Node s, TripleCollector acc) : { Node p ; }
{
  p = Verb()
    ObjectList(s, p, acc)
  (<SEMICOLON> PropertyList(s, acc) ) ?

|
    Reification(s, acc)

}

void ObjectList(Node s, Node p, TripleCollector acc): { Node o ; }
{
  // The mark ensures that triples end up in a nicer order
  o = Object(acc)
   { Triple t = new Triple(s,p,o) ; acc.addTriple(t) ; }
  ( <COMMA> ObjectList(s, p , acc) )?
}

Node Verb() : {Node p ;}
{
//  ( p = VarOrIRIref() | <KW_A> { p = nRDFtype ; } )
  // NB this excludes: ":x (1 2 3) :y" 
  // that is, a bNode generating thing for predicate
  // Coudl do via _:b labelling
  ( p = VarOrBlankNodeOrIRIref() | <KW_A> { p = nRDFtype ; } )

  { return p ; }
}

Node Object(TripleCollector acc) : { Node o ; }
{
  ( o = VarOrTerm()
  | o = TriplesNode(acc)
  )
    { return o ; }
}

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

// Anything that can stand in a node slot and which is
// a number of triples

Node TriplesNode(TripleCollector acc) : { Node n ; }
{
  n = Collection(acc) { return n ; }
 |
  n = BlankNodePropertyList(acc) { return n ; }

 |
  n = Reification(null, acc) { return n ; }

}

Node BlankNodePropertyList(TripleCollector acc) : { }
{
  <LBRACKET>
    { Node n = createBNode() ; }
  PropertyListNotEmpty(n, acc)
  <RBRACKET>
    { return n ; }
}

Node Reification(Node id, TripleCollector acc) :
    { Node s , p , o ; int mark ; }
{
  // For generality, should be AndNode for s/p/o
  // Insert reification triple before the resulting subtriples (if any)
  "<<"
    { if ( id == null )
        id = createBNode() ;
      mark = acc.mark() ; }
  s = GraphNode(acc)
    { insert(acc, mark, id, nRDFsubject, s) ; }

    { mark = acc.mark() ; }
  p = GraphNode(acc)
    { insert(acc, mark, id, nRDFpredicate, p) ; }

    { mark = acc.mark() ; }
  o = GraphNode(acc)
    { insert(acc, mark, id, nRDFobject, o) ; }

  ">>"
    { return id ; }
}


// ------- RDF collections

Node Collection(TripleCollector acc) :
    { Node listHead = nRDFnil ; Node lastCell = null ; int mark ; Node n ; }
{
  <LPAREN>
  (
    { Node cell = createBNode() ;
      if ( listHead == nRDFnil )
         listHead = cell ;
      if ( lastCell != null )
        insert(acc, lastCell, nRDFrest, cell) ;
      mark = acc.mark() ;
    }
    n = GraphNode(acc)
    {
      insert(acc, mark, cell, nRDFfirst, n) ;
      lastCell = cell ;
    }
  ) +
  // Not * here - "()" is handled separately.
  <RPAREN>
   { if ( lastCell != null )
       insert(acc, lastCell, nRDFrest, nRDFnil) ;
     return listHead ; }
}

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

Node GraphNode(TripleCollector acc) : { Node n ; }
{
  n = VarOrTerm() { return n ; }
 |
  n = TriplesNode(acc) { return n ; }
}

Node VarOrTerm() : {Node n = null ; }
{
  ( n = Var() | n = GraphTerm() )
  { return n ; }
}

// Property (if no bNodes) + DESCRIBE
Node VarOrIRIref() : {Node n = null ; }
{
  ( n = Var() | n = IRIref() )
  { return n ; }
}

// GRAPH and property if including blank nodes are properties.
Node VarOrBlankNodeOrIRIref() : {Node n = null ; }
{
  ( n = Var() | n = BlankNode() | n = IRIref() )
  { return n ; }
}

Node Var() : { Token t ;}
{
    ( t = <VAR1> | t = <VAR2> )
    { return Node.createVariable(t.image.substring(1)) ; }
}

Node GraphTerm() : { Node n ; }
{
  n = IRIref() { return n ; }
|
  n = RDFLiteral() { return n ; }
|
  n = NumericLiteral() { return n ; }
|
  n = BooleanLiteral() { return n ; }
|
  n = BlankNode() { return n ; }
|
//  <LPAREN> <RPAREN>     { return nRDFnil ; }
  <NIL> { return nRDFnil ; }
}

// Constraint syntax follows.

Expr Expression() : { Expr n ; }
{
  n = ConditionalOrExpression()
  { return n ; }
}

Expr ConditionalOrExpression() : { Expr n1, n2 ; }
{
  n1 = ConditionalAndExpression()
  ( <SC_OR> n2 = ConditionalAndExpression()
    { n1 = new E_LogicalOr(n1,n2) ; }
  )*
    { return n1 ; }

}

Expr ConditionalAndExpression() : { Expr n1, n2 ;}
{
  n1 = ValueLogical()
  ( <SC_AND> n2 = ValueLogical()
    { n1 = new E_LogicalAnd(n1,n2) ; }
  )*
    { return n1 ; }
}


// End of boolean expressions

Expr ValueLogical() : { Expr n ; }
{
  n = RelationalExpression()
    { return n ; }
}

Expr RelationalExpression() : { Expr n1, n2 ; }
{
  n1 = NumericExpression()
  (
    <EQ> n2 = NumericExpression()
      { n1 = new E_Equal(n1,n2) ; }
  | <NE> n2 = NumericExpression()
      { n1 = new E_NotEqual(n1,n2) ; }
  | <LT> n2 = NumericExpression()
      { n1 = new E_LessThan(n1,n2) ; }
  | <GT> n2 = NumericExpression()
      { n1 = new E_GreaterThan(n1,n2) ; }
  | <LE> n2 = NumericExpression()
      { n1 = new E_LessThanOrEqual(n1,n2) ; }
  | <GE> n2 = NumericExpression()
      { n1 = new E_GreaterThanOrEqual(n1,n2) ; }

  )?
    { return n1 ; }
}

Expr NumericExpression () : { Expr n ; }
{
  n = AdditiveExpression()
    { return n ; }
}

Expr AdditiveExpression() : { Expr n1,n2 ; }
{
  n1 = MultiplicativeExpression()
  ( <PLUS> n2 = MultiplicativeExpression()
    { n1 = new E_Add(n1, n2) ; }
  | <MINUS> n2 = MultiplicativeExpression()
    { n1 = new E_Subtract(n1, n2) ; }
  )*
    { return n1 ; }
}

Expr MultiplicativeExpression() : { Expr n1,n2 ; }
{
  n1 = UnaryExpression()
  ( <STAR> n2 = UnaryExpression()
    { n1 = new E_Multiply(n1, n2) ; }
  | <SLASH> n2 = UnaryExpression()
    { n1 = new E_Divide(n1, n2) ; }
//   | <REM>   n2 = UnaryExpression()
//     { n1 = new E_Modulus(n1, n2) ; }
  )*
    { return n1 ; }
}

Expr UnaryExpression() : { Expr n ; }
{
  <BANG> n = PrimaryExpression()
    { return new E_LogicalNot(n) ; }
  | <PLUS> n = PrimaryExpression() { return new E_UnaryPlus(n) ; }
  | <MINUS> n = PrimaryExpression() { return new E_UnaryMinus(n) ; }
  | n = PrimaryExpression() { return n ; }
}

Expr BuiltInCall() : { Expr expr ; Node gn ; }
{
    // STR
    <STR> <LPAREN> expr = Expression() <RPAREN>
    { return new E_Str(expr) ; }
//   | 
//     // URI
//     <URI> <LPAREN> expr = Expression() <RPAREN>
//     { return new E_Str(expr) ; }
  | // Lang
    <LANG> <LPAREN> expr = Expression() <RPAREN>
    { return new E_Lang(expr) ; }

  | // Datatype
    <DTYPE> <LPAREN> expr = Expression() <RPAREN>
    { return new E_Datatype(expr) ; }

  | <BOUND> <LPAREN> gn = Var() <RPAREN>
    { return new E_Bound(new NodeVar(gn)) ; }

  | <IS_URI> <LPAREN> expr = Expression() <RPAREN>
    { return new E_IsURI(expr) ; }

  | <IS_BNODE> <LPAREN> expr = Expression() <RPAREN>
    { return new E_IsBlank(expr) ; }

  | <IS_LITERAL> <LPAREN> expr = Expression() <RPAREN>
    { return new E_IsLiteral(expr) ; }

  | // Regular expression matcher
    expr = RegexExpression() { return expr ; }
}

Expr RegexExpression() :
{ Expr expr ; Expr patExpr = null ; Expr flagsExpr = null ; }
{
    <REGEX> <LPAREN>
      expr = Expression()
      <COMMA>
      patExpr = Expression()
      ( <COMMA> flagsExpr = Expression() ) ?
    <RPAREN>
      { return new E_Regex(expr, patExpr, flagsExpr) ; }
}

Expr FunctionCall() : { Node fname ; List a ; }
{
  fname = IRIref() a = ArgList()
    { return new E_Function(fname.getURI(), a) ; }
}

List ArgList() : { Expr expr ; List args = new ArrayList() ; }
{
  (
    <NIL>
  |
   // Was <LPAREN> ( Expression() (<COMMA> Expression() )* )? <RPAREN>
    <LPAREN>
      expr = Expression() { args.add(expr) ; }
      (<COMMA> expr = Expression() { args.add(expr) ; } )*
    <RPAREN>
   )
    { return args ; }
}

Expr BrackettedExpression() : { Expr expr ; }
{
    <LPAREN> expr = Expression() <RPAREN> { return expr ; }
}

Expr PrimaryExpression() : { Expr expr ; Node gn ; List a = null ; }
{
  ( expr = BrackettedExpression() { return expr ; }
  |
    expr = BuiltInCall() { return expr ; }

//   // More descriptive way of writing it.
//   |  LOOKAHEAD(2) // Differentiate "q:name()" and "q:name"
//      expr = FunctionCall()       { return expr ; } 
//   |  gn = IRIref()          { return asExpr(gn) ; }

  // Avoid lookahead for "q:name()" and "q:name"
  // by expanding out FunctionCall()

  | gn = IRIref()
     ( a = ArgList() )?
     { if ( a == null ) return asExpr(gn) ;
       return new E_Function(gn.getURI(), a) ;
     }

  | gn = RDFLiteral() { return asExpr(gn) ; }
  | gn = NumericLiteral() { return asExpr(gn) ; }
  | gn = BooleanLiteral() { return asExpr(gn) ; }
  | gn = BlankNode() { return asExpr(gn) ; }
  | gn = Var() { return asExpr(gn) ; }
  )
}


// Term as used in expressions 

Node RDFTerm() : { Node n ; }
{
  n = IRIref() { return n ; }
|
  n = RDFLiteral() { return n ; }
|
  n = NumericLiteral() { return n ; }
|
  n = BooleanLiteral() { return n ; }
|
  n = BlankNode() { return n ; }

}

Node NumericLiteral() : { Token t ; }
{
  t = <INTEGER> { return makeNodeInteger(t.image) ; }
|
  t = <FLOATING_POINT> { return makeNodeDouble(t.image) ; }
// | 
//   t = <DECIMAL>        { return makeNodeDouble(t.image) ; }
}

Node RDFLiteral() : { Token t ; String lex = null ; }
{
  lex = String()
  // Optional lang tag and datatype.
  { String lang = null ; Node uri = null ; }
  (
    ( t = <LANGTAG> { lang = stripChars(t.image, 1) ; } )
  |
    ( <DATATYPE> uri = IRIref() )
  )?
    { return makeNode(lex, lang, uri) ; }
}

Node BooleanLiteral() : {}
{
  <TRUE> { return XSD_TRUE ; }
 |
  <FALSE> { return XSD_FALSE ; }
}



String String() : { Token t ; String lex = null ; }
{
  ( t = <STRING_LITERAL1>
  | t = <STRING_LITERAL2>
  | t = <STRING_LITERAL_LONG1>
  | t = <STRING_LITERAL_LONG2>
  )
    { lex = stripQuotes(t.image) ;
      lex = unescape(lex) ;
      return lex ;
    }
}

Node IRIref() : { Node n ; }
{
  n = QuotedIRIref() { return n ; }
|
  n = QName() { return n ; }
}

Node QName() : { Token t ; }
{
  ( t = <QNAME>
    { return Node.createURI(fixupQName(t.image, t.beginLine, t.beginColumn)) ; }
  |
    t = <QNAME_NS>
    { return Node.createURI(fixupQName(t.image, t.beginLine, t.beginColumn)) ; }
  )
}

Node BlankNode() : { Token t = null ; }
{
  t = <BNODE_LABEL> { return createBNode(t.image) ; }
|
//  <LBRACKET> <RBRACKET> { return createBNode() ; }
  <ANON> { return createBNode() ; }

}

Node QuotedIRIref() : { Token t ; }
{
  t = <Q_IRIref>
  { String s = stripQuotes(t.image) ;
    return createNodeFromURI(s, t.beginLine, t.beginColumn) ; }
}

// Node Integer() : { Token t ; }
// {
//   t = <INTEGER> { return makeNodeInteger(t.image) ; }
// }
// 
// Node FloatingPoint() : { Token t ; }
// {
//   t = <FLOATING_POINT> { return makeNodeDouble(t.image) ; }
// }

// ------------------------------------------
// 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: "<" (<NCCHAR1>|"#"|"_"|"/"|"&") (~[">"," "])* ">" >
   <Q_IRIref: "<" (~[">"," "])* ">" >

| <QNAME_NS: (<NCNAME_PREFIX>)? ":" >
| <QNAME: (<NCNAME_PREFIX>)? ":" (<NCNAME>)? >
| <BNODE_LABEL: "_:" <NCNAME> >
| <BNODE_ID: "_!:" <NCNAME> >

| <VAR1: "?" <VARNAME> >
| <VAR2: "$" <VARNAME> >
| <LANGTAG: <AT> (<A2Z>)+("-" (<A2ZN>)+)* >
| <#A2Z: ["a"-"z","A"-"Z"]>
| <#A2ZN: ["a"-"z","A"-"Z","0"-"9"]>
}

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

TOKEN :
{
   < INTEGER: /*(["-","+"])?*/ <DIGITS> >
// |
//    < DECIMAL: /*(["-","+"])?*/ (<DIGITS>)+ "." (<DIGITS>)* | "." (<DIGITS>)+ >
      // Required exponent.
// |  < FLOATING_POINT:
//       //(["+","-"])?
//       (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)
//       | "." (["0"-"9"])+ (<EXPONENT>)
//       | (["0"-"9"])+ <EXPONENT>
//       >
| < FLOATING_POINT:
      //(["+","-"])?
      (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
      | "." (["0"-"9"])+ (<EXPONENT>)?
      | (["0"-"9"])+ <EXPONENT>
      >
| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
| < #QUOTE_3D: "\"\"\"">
| < #QUOTE_3S: "'''">

| < STRING_LITERAL1:
      // Single quoted string
      "'" ( (~["'","\\","\n","\r"]) | ("\\" ~["\n","\r"]) )* "'" >

| < STRING_LITERAL2:
    // Double quoted string
      "\"" ( (~["\"","\\","\n","\r"]) | ("\\" ~["\n","\r"]) )* "\"" >

| < STRING_LITERAL_LONG1:
     <QUOTE_3S>
      ( ~["'","\\"] | ("\\" ~["\n","\r"]) | ("'" ~["'"]) | ("''" ~["'"]))*
     <QUOTE_3S> >

| < STRING_LITERAL_LONG2:
   <QUOTE_3D>
    ( ~["\"","\\"] | ("\\" ~["\n","\r"]) | ("\"" ~["\""]) | ("\"\"" ~["\""]))*
   <QUOTE_3D> >

| < DIGITS: (["0"-"9"])+>
}

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

TOKEN : { <KW_A: "a" > }


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

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

| < 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" >


| < UNSAID: "unsaid" >
| < EXT: "ext" >


| < FILTER: "filter" >

// Expression operators
| < BOUND: "bound" >
| < STR: "str" >
// |  < URI:         "uri" >
| < DTYPE: "datatype" >
| < LANG: "lang" >
| < IS_URI: "isURI" >
| < IS_BNODE: "isBlank" >
| < IS_LITERAL: "isLiteral" >
| < REGEX: "regex" >

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


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: "/" >

//| < AMP: "&" >
//| < REM: "%" >

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

// See XML chars.txt for notes

TOKEN:
{
  // XML 1.1 NCNameStartChar without "_"
  <#NCCHAR1:
          ["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]

// With trailing dots

// |
//   // #NCCHAR
//   <#NCCHAR: (<NCCHAR1> | "_" | "-" | "." | ["0"-"9"] | "\u00B7" |
//               ["\u0300"-"\u036F"] | ["\u203F"-"\u2040"] ) >
// |
//   // NCNAME but no leading "_"
//   <#NCNAME_PREFIX: <NCCHAR1> (<NCCHAR>)*  >
// |
//   // With a leading "_"
//   <#NCNAME: ("_"|<NCCHAR1>) (<NCCHAR>)*>

// 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: <NCCHAR1> ((<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"] )* >
}


/*
 * (c) Copyright 2004, 2005 Hewlett-Packard Development Company, LP
 *
 * 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.
 */
/*
# Local Variables:
# tab-width: 4
# indent-tabs-mode: nil
# comment-default-style: "//"
# End:
*/