jena-core/Grammar/turtle-strict.jj - jena - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 // Turtle & N3 for Jena

 // N3 compatible:
 // Projection to Turtle is done by filtering non-Trutle forms.
 // A consequence is that where Turtle and N3 are incompatible (e.g.
 // whitespace processing) if follows N3.
 //
 // All legal Turtle documents are acceped by this grammar.

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

    JAVA_UNICODE_ESCAPE   = true ;
     // We use a UTF-8 encoded stream anyway so the setting of
     // this is not important.
     // and it does not make any difference to the code generated!
     // One a warning is issued if true.
    UNICODE_INPUT         = false ;

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

 PARSER_BEGIN(TurtleParser)
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.hp.hpl.jena.n3.turtle.parser ;

 import com.hp.hpl.jena.n3.turtle.ParserBase ;
 import com.hp.hpl.jena.graph.* ;

 public class TurtleParser extends ParserBase
 {
 }
 PARSER_END(TurtleParser)

 // --- Entry point

 void parse() : {}
 {
   (Statement())* <EOF>
 }

 void Statement() : {}
 {
   (Directive() | TriplesSameSubject() )
   <DOT>
 }

 void Directive() : { Token t ; Node n ; }
 {
     // Need a token for @prefix?
     // Looks like a LANTAG
     <PREFIX> t = <QNAME_NS> n = Q_IRI_REF()
     { String s = fixupPrefix(t.image, t.beginLine, t.beginColumn) ;
       setPrefix(t.beginLine, t.beginColumn, s, n.getURI()) ; }
 }

 // -------- PATH
 TOKEN:
 {
    < PLING:    "!" >
  | < VBAR:     "|" >
  | < CARROT:   "^" >
  | < FPATH:    "->" >
  | < RPATH:    "<-" >

 }

 // N3

 // ---- TRIPLES
 // <<<<< SPARQL extract

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


 void PropertyList(Node s) : { }
 {
   ( PropertyListNotEmpty(s) ) ?
 }
 // >>>>> SPARQL extract

 // Non-recursive for Turtle long PropertyList tests
 void PropertyListNotEmpty(Node s) : { Node p ; }
 {
   p = Verb()
   ObjectList(s, p)
   (<SEMICOLON> (p = Verb() ObjectList(s, p))? )*
 }

 // Non-recursive for Turtle long PropertyList tests
 void ObjectList(Node s, Node p): { Node o ; }
 {
   Object(s, p)
   ( <COMMA> Object(s, p) )*
 }

 void Object(Node s, Node p): { Node o ; }
 {
   o = GraphNode()
   { Triple t = new Triple(s,p,o) ;
     emitTriple(token.beginLine, token.beginColumn, t) ; }
 }

 // <<<<< SPARQL extract
 Node Verb() : {Node p ;}
 {
   ( p = IRIref() | <KW_A> { p = nRDFtype ; } |
     <ARROW>
       { p = nLogImplies ;
         if ( strictTurtle )
           raiseException("=> (log:implies) not legalin Turtle",
                           token.beginLine, token.beginColumn ) ;
       }
   )
   { return p ; }
 }

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

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

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

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


 // ------- RDF collections

 // Code not as SPARQL/ARQ because of output ordering.
 Node Collection() :
     { Node listHead = nRDFnil ; Node lastCell = null ; Node n ; }
 {
   <LPAREN>
   (
     { Node cell = createBNode() ;
       if ( listHead == nRDFnil )
          listHead = cell ;
       if ( lastCell != null )
         emitTriple(token.beginLine, token.beginColumn,
                    new Triple(lastCell, nRDFrest,  cell)) ;
     }
     n = GraphNode()
     {
       emitTriple(token.beginLine, token.beginColumn,
                  new Triple(cell, nRDFfirst,  n)) ;
       lastCell = cell ;
     }
   ) +
   // Not * here - "()" is handled separately.
   <RPAREN>
    { if ( lastCell != null )
        emitTriple(token.beginLine, token.beginColumn,
                   new Triple(lastCell, nRDFrest,  nRDFnil)) ;
      return listHead ; }
 }

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

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

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

 Node Formula() : {Token t ; }
 {
     t = <LBRACE> { startFormula(t.beginLine, t.beginColumn) ; }
     // Need to sort this out and merge with Statement above
     TriplesSameSubject()
     ( <DOT> (TriplesSameSubject())? )*
     t = <RBRACE> { endFormula(t.beginLine, t.beginColumn) ; }
       { return null ; }
 }

 // >>>>> SPARQL extract

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

 Node GraphTerm() : { Node n ; }
 {
   n = IRIref()          { return n ; }
 |
   n = RDFLiteral()      { return n ; }
 |
   // Cleaner sign handling in Turtle.
   n = NumericLiteral()  { return n ; }
 // |
 //   n = BooleanLiteral()  { return n ; }
 |
   n = BlankNode()       { return n ; }
 |
 //  <LPAREN> <RPAREN>     { return nRDFnil ; }
   <NIL>  { return nRDFnil ; }
 }
 // ---- Basic terms

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

 // >>>>> SPARQL extract
 // Langtag oddity.
 Node RDFLiteral() : { Token t ; String lex = null ; }
 {
   lex = String()
   // Optional lang tag and datatype.
   { String lang = null ; Node uri = null ; }
   (
     lang = Langtag()
   |
     ( <DATATYPE> uri = IRIref() )
   )?
     { return makeNode(lex, lang, uri) ; }
 }

 String Langtag() : { Token t ; }
 {
   // Enumerate the directives here
   ( t = <LANGTAG> | t = <PREFIX> )
   { String lang = stripChars(t.image, 1) ; return lang ; }
 }
 // >>>>> SPARQL extract
 // Node BooleanLiteral() : {}
 // {
 //   <TRUE> { return XSD_TRUE ; }
 //  |
 //   <FALSE> { return XSD_FALSE ; }
 // }

 // <<<<< SPARQL extract

 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 = Q_IRI_REF() { return n ; }
 |
   n = QName() { return n ; }
 }

 Node QName() : { Token t ; }
 {
   ( t = <QNAME>
     { return createURIfromQName(t.image, t.beginLine, t.beginColumn) ; }
   |
     t = <QNAME_NS>
     { return createURIfromQName(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 Q_IRI_REF() : { Token t ; }
 {
   t = <Q_IRIref>
   { return createNodeFromURI(t.image, t.beginLine, t.beginColumn) ; }
 }

 // ------------------------------------------
 // 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")? > }

 // -------------------------------------------------
 // Keyworks : directives before LANGTAG

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

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

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

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

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

 // | <UCHAR: ("u" <HEX> <HEX> <HEX> <HEX> )
 //             | ("U" <HEX> <HEX> <HEX> <HEX> <HEX> <HEX> <HEX> <HEX>)>

 //   <ECHAR: ("t"|"b"|"n"|"r"|"f"|"\\"|"\""|"'")>
 //
 // |
 //    <XCHAR: "\\" ( <ECHAR> | <UCHAR> ) >

 | <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:
 {
    // Includes # for relative URIs
    <Q_IRIref: "<" (~[">","<","\u0000"-"\u0020"])* ">" >

 |  <QNAME_NS: (<NCNAME_PREFIX>)? ":" >
 |  <QNAME: (<NCNAME_PREFIX>)? ":" (<NCNAME>)? >
 |  <BLANK_NODE_LABEL: "_:" <NCNAME> >
 //|  <BLANK_NODE_ID: "_!:" <NCNAME> >

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


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

 | <NIL:        <LPAREN> (<WS>|<SINGLE_LINE_COMMENT>)* <RPAREN> >

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

 | < LBRACKET:  "[" >
 | < RBRACKET:  "]" >
 | < ANON:      <LBRACKET> (<WS>|<SINGLE_LINE_COMMENT>)* <RBRACKET> >

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

 // Operator

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

 | <ARROW:    "=>">

 | < DOLLAR:  "$">
 | < QMARK:   "?">

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

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

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

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

 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"] )* >
 }
 /*
 # Local Variables:
 # tab-width: 4
 # indent-tabs-mode: nil
 # comment-default-style: "//"
 # End:
 */
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	// Turtle & N3 for Jena

	// N3 compatible:
	// Projection to Turtle is done by filtering non-Trutle forms.
	// A consequence is that where Turtle and N3 are incompatible (e.g.
	// whitespace processing) if follows N3.
	//
	// All legal Turtle documents are acceped by this grammar.

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

	JAVA_UNICODE_ESCAPE = true ;
	// We use a UTF-8 encoded stream anyway so the setting of
	// this is not important.
	// and it does not make any difference to the code generated!
	// One a warning is issued if true.
	UNICODE_INPUT = false ;

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

	PARSER_BEGIN(TurtleParser)
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.hp.hpl.jena.n3.turtle.parser ;

	import com.hp.hpl.jena.n3.turtle.ParserBase ;
	import com.hp.hpl.jena.graph.* ;

	public class TurtleParser extends ParserBase
	{
	}
	PARSER_END(TurtleParser)

	// --- Entry point

	void parse() : {}
	{
	(Statement())* <EOF>
	}

	void Statement() : {}
	{
	(Directive() \| TriplesSameSubject() )
	<DOT>
	}

	void Directive() : { Token t ; Node n ; }
	{
	// Need a token for @prefix?
	// Looks like a LANTAG
	<PREFIX> t = <QNAME_NS> n = Q_IRI_REF()
	{ String s = fixupPrefix(t.image, t.beginLine, t.beginColumn) ;
	setPrefix(t.beginLine, t.beginColumn, s, n.getURI()) ; }
	}

	// -------- PATH
	TOKEN:
	{
	< PLING: "!" >
	\| < VBAR: "\|" >
	\| < CARROT: "^" >
	\| < FPATH: "->" >
	\| < RPATH: "<-" >

	}

	// N3

	// ---- TRIPLES
	// <<<<< SPARQL extract

	void TriplesSameSubject() : { Node s ; }
	{
	s = VarOrTerm()
	PropertyListNotEmpty(s)
	\|
	// Any of the triple generating syntax elements
	s = TriplesNode()
	PropertyList(s)
	}


	void PropertyList(Node s) : { }
	{
	( PropertyListNotEmpty(s) ) ?
	}
	// >>>>> SPARQL extract

	// Non-recursive for Turtle long PropertyList tests
	void PropertyListNotEmpty(Node s) : { Node p ; }
	{
	p = Verb()
	ObjectList(s, p)
	(<SEMICOLON> (p = Verb() ObjectList(s, p))? )*
	}

	// Non-recursive for Turtle long PropertyList tests
	void ObjectList(Node s, Node p): { Node o ; }
	{
	Object(s, p)
	( <COMMA> Object(s, p) )*
	}

	void Object(Node s, Node p): { Node o ; }
	{
	o = GraphNode()
	{ Triple t = new Triple(s,p,o) ;
	emitTriple(token.beginLine, token.beginColumn, t) ; }
	}

	// <<<<< SPARQL extract
	Node Verb() : {Node p ;}
	{
	( p = IRIref() \| <KW_A> { p = nRDFtype ; } \|
	<ARROW>
	{ p = nLogImplies ;
	if ( strictTurtle )
	raiseException("=> (log:implies) not legalin Turtle",
	token.beginLine, token.beginColumn ) ;
	}
	)
	{ return p ; }
	}

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

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

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

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


	// ------- RDF collections

	// Code not as SPARQL/ARQ because of output ordering.
	Node Collection() :
	{ Node listHead = nRDFnil ; Node lastCell = null ; Node n ; }
	{
	<LPAREN>
	(
	{ Node cell = createBNode() ;
	if ( listHead == nRDFnil )
	listHead = cell ;
	if ( lastCell != null )
	emitTriple(token.beginLine, token.beginColumn,
	new Triple(lastCell, nRDFrest, cell)) ;
	}
	n = GraphNode()
	{
	emitTriple(token.beginLine, token.beginColumn,
	new Triple(cell, nRDFfirst, n)) ;
	lastCell = cell ;
	}
	) +
	// Not * here - "()" is handled separately.
	<RPAREN>
	{ if ( lastCell != null )
	emitTriple(token.beginLine, token.beginColumn,
	new Triple(lastCell, nRDFrest, nRDFnil)) ;
	return listHead ; }
	}

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

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

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

	Node Formula() : {Token t ; }
	{
	t = <LBRACE> { startFormula(t.beginLine, t.beginColumn) ; }
	// Need to sort this out and merge with Statement above
	TriplesSameSubject()
	( <DOT> (TriplesSameSubject())? )*
	t = <RBRACE> { endFormula(t.beginLine, t.beginColumn) ; }
	{ return null ; }
	}

	// >>>>> SPARQL extract

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

	Node GraphTerm() : { Node n ; }
	{
	n = IRIref() { return n ; }
	\|
	n = RDFLiteral() { return n ; }
	\|
	// Cleaner sign handling in Turtle.
	n = NumericLiteral() { return n ; }
	// \|
	// n = BooleanLiteral() { return n ; }
	\|
	n = BlankNode() { return n ; }
	\|
	// <LPAREN> <RPAREN> { return nRDFnil ; }
	<NIL> { return nRDFnil ; }
	}
	// ---- Basic terms

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

	// >>>>> SPARQL extract
	// Langtag oddity.
	Node RDFLiteral() : { Token t ; String lex = null ; }
	{
	lex = String()
	// Optional lang tag and datatype.
	{ String lang = null ; Node uri = null ; }
	(
	lang = Langtag()
	\|
	( <DATATYPE> uri = IRIref() )
	)?
	{ return makeNode(lex, lang, uri) ; }
	}

	String Langtag() : { Token t ; }
	{
	// Enumerate the directives here
	( t = <LANGTAG> \| t = <PREFIX> )
	{ String lang = stripChars(t.image, 1) ; return lang ; }
	}
	// >>>>> SPARQL extract
	// Node BooleanLiteral() : {}
	// {
	// <TRUE> { return XSD_TRUE ; }
	// \|
	// <FALSE> { return XSD_FALSE ; }
	// }

	// <<<<< SPARQL extract

	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 = Q_IRI_REF() { return n ; }
	\|
	n = QName() { return n ; }
	}

	Node QName() : { Token t ; }
	{
	( t = <QNAME>
	{ return createURIfromQName(t.image, t.beginLine, t.beginColumn) ; }
	\|
	t = <QNAME_NS>
	{ return createURIfromQName(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 Q_IRI_REF() : { Token t ; }
	{
	t = <Q_IRIref>
	{ return createNodeFromURI(t.image, t.beginLine, t.beginColumn) ; }
	}

	// ------------------------------------------
	// 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")? > }

	// -------------------------------------------------
	// Keyworks : directives before LANGTAG

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

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

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

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

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

	// \| <UCHAR: ("u" <HEX> <HEX> <HEX> <HEX> )
	// \| ("U" <HEX> <HEX> <HEX> <HEX> <HEX> <HEX> <HEX> <HEX>)>

	// <ECHAR: ("t"\|"b"\|"n"\|"r"\|"f"\|"\\"\|"\""\|"'")>
	//
	// \|
	// <XCHAR: "\\" ( <ECHAR> \| <UCHAR> ) >

	\| <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:
	{
	// Includes # for relative URIs
	<Q_IRIref: "<" (~[">","<","\u0000"-"\u0020"])* ">" >

	\| <QNAME_NS: (<NCNAME_PREFIX>)? ":" >
	\| <QNAME: (<NCNAME_PREFIX>)? ":" (<NCNAME>)? >
	\| <BLANK_NODE_LABEL: "_:" <NCNAME> >
	//\| <BLANK_NODE_ID: "_!:" <NCNAME> >

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


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

	\| <NIL: <LPAREN> (<WS>\|<SINGLE_LINE_COMMENT>)* <RPAREN> >

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

	\| < LBRACKET: "[" >
	\| < RBRACKET: "]" >
	\| < ANON: <LBRACKET> (<WS>\|<SINGLE_LINE_COMMENT>)* <RBRACKET> >

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

	// Operator

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

	\| <ARROW: "=>">

	\| < DOLLAR: "$">
	\| < QMARK: "?">

	\| < TILDE: "~" >
	\| < COLON: ":" >

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

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

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

	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"] )* >
	}
	/*
	# Local Variables:
	# tab-width: 4
	# indent-tabs-mode: nil
	# comment-default-style: "//"
	# End:
	*/