// (c) Copyright 2007 Hewlett-Packard Development Company, LP

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(SSE_Parser)

/*
 * (c) Copyright 2007 Hewlett-Packard Development Company, LP
 * All rights reserved.
 */

package com.hp.hpl.jena.sparql.sse.parser ;

import com.hp.hpl.jena.sparql.sse.* ;
import com.hp.hpl.jena.graph.* ;
import com.hp.hpl.jena.sparql.core.Var;   
    

public class SSE_Parser extends ParserSSEBase
{
}

PARSER_END(SSE_Parser)

// Now has explicit WS control in the grammar.
// Policy - eat trailing WS

// ---- Entry points

Item parse() : { Item list ; Item elt ; }
{
    (<WS>)*
    elt = TermOrList()
    <EOF>
    { return elt ; }
}

Node node() : { Node n ; }
{
    n = GraphTerm()
    <EOF>
    { return n ; }
}

String word() : { String str ; Token t ; }
{
    ( t = <WORD> | t = <OP> )
    <EOF>
    { return t.image ; }
}

// ---- 

Item List() : { Token t ; Item list ; }
{
    // The OP token must exclude these
(    t = <LPAREN> 
    (<WS>)*
    { list = Item.createList(t.beginLine, t.beginColumn) ; }
    list = BareList(list) 
    <RPAREN>
 |  t = <LBRACKET> 
    (<WS>)*
    { list = Item.createList(t.beginLine, t.beginColumn) ; }
    list = BareList(list)
    <RBRACKET>
)
    (<WS>)*
    { return list ; }
}

Item BareList(Item list) : { Item elt ; }
{
    ( 
      elt = TermOrList()
      { list.getList().add(elt) ; }
      // White space swallowed
    )*
    { return list ; }
}

Item Term() : { Token t ; Node node ; Item item ; }
{
  ( t = <WORD> | t = <OP> )
    { return Item.createWord(t.image, t.beginLine, t.beginColumn) ; }
 | node = GraphTerm()
    // Not quite right for line/col - this is the last token
    { return Item.createNode(node, token.beginLine, token.beginColumn) ; }
 | 
   t = <PNAME>
   { return Item.createWord(t.image, t.beginLine, t.beginColumn) ; }
}

Item TermOrList() : { Item item ; }
{
  ( item = Term() (<WS>)* |  item = List() )
  { return item ; }
    
}


// Abstract terminals (wrapped in grammar rules)

Node GraphTerm() : { Node n ; }
{
  n = IRIref()          { return n ; }
| n = Var()             { 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 ; }
}


Node Var() : { Token t ; Var v ; }
{
  ( t = <VAR1> | t = <VAR2> )
  { return createVariable(t.image, t.beginLine, t.beginColumn) ; }
|
  t = <HOOK>
  { return createVariable() ; }
}

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

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

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



String String() : { Token t ; String lex ; }
{
  ( t = <STRING_LITERAL1> { lex = stripQuotes(t.image) ; }
  | t = <STRING_LITERAL2> { lex = stripQuotes(t.image) ; }
  | t = <STRING_LITERAL_LONG1> { lex = stripQuotes3(t.image) ; }
  | t = <STRING_LITERAL_LONG2> { lex = stripQuotes3(t.image) ; }
  )
    {
      lex = unescapeStr(lex,  t.beginLine, t.beginColumn) ;
      return lex ;
    }
}

Node IRIref() : { Node n ; }
{
  n = IRI_REF() { return n ; }
}

// Node IRIref() : { Node n ; }
// {
//   n = IRI_REF() { return n ; }
// | n = PrefixedName() { return n ; }
// }
// 
// String PrefixedName() : { Token t ; Node n ; }
// {
//   t = <PNAME>
//     { return createNodeFromPrefixedName(t.image, t.beginLine, t.beginColumn) ; }
// }

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

}

Node IRI_REF() : { Token t ; }
{
  t = <IRIref>
  { return createNodeFromURI(t.image, t.beginLine, t.beginColumn) ; }
}

// No whitespace skipping.
#undef SKIP
#include "tokens.inc"
#include "copyright.inc"

/*
# Local Variables:
# tab-width: 4
# indent-tabs-mode: nil
# comment-default-style: "//"
# End:
*/