// ARQ/SPARQL Grammar - native syntax for the query engine
//
// 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(SPARQLParser)
/*
 * (c) Copyright 2004, 2005 Hewlett-Packard Development Company, LP
 * All rights reserved.
 */

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

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 SPARQLParser extends SPARQLParserBase
{
}
PARSER_END(SPARQLParser)

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

void Query() : { }
{
  Prolog()
  ( SelectClause() | ConstructClause() | DescribeClause() | AskClause() )



  ( WhereClause() ) ?
  ( LimitClause() ) ?
}

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

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


void PrefixDecl() : { Token t ; Node n ; }
{
  ( LOOKAHEAD(2)
    <PREFIX> t = <QNAME_NS> n = QuotedURIref()
    // Has the trailing ":"
      { getQuery().setPrefix(fixupPrefix(t), n.getURI()) ; }
  |
    <PREFIX> <COLON> n = QuotedURIref()
      { getQuery().setPrefix("", n.getURI()) ; }
  )
}

// ---- Query type clauses

void SelectClause() :
{ Node v ; Token t = null ;}
{
  (
    LOOKAHEAD(3) // Need to hop "SELECT" and DISTINCT to look at ?var or STAR
    <SELECT> (t = <DISTINCT>)? { getQuery().setQueryResultStar(false) ; }
      ( v = Var() { getQuery().addResultVar(v) ; } )+
  |
    <SELECT> (t = <DISTINCT>)? <STAR> { getQuery().setQueryResultStar(true) ; }
  )
    { getQuery().setType(Query.QueryTypeSelect) ;
      getQuery().setDistinct( t != null ) ;
    }
}

void DescribeClause() : { Node n ; }
{
    { getQuery().setType(Query.QueryTypeDescribe) ; }
  ( LOOKAHEAD(2)
  // Extra lookahead needs for URIs or Vars.
    <DESCRIBE> ( n = VarOrURI() { getQuery().addDescribeNode(n) ; } )+
    { getQuery().setQueryResultStar(false) ; }
  |
    <DESCRIBE> <STAR>
    { getQuery().setQueryResultStar(true) ; }
  )
}

void ConstructClause() :
{ Template t ; }
{
    { getQuery().setType(Query.QueryTypeConstruct) ; }
//  ( LOOKAHEAD(2)
    <CONSTRUCT> t = ConstructTemplate()
      { getQuery().setQueryResultStar(false) ;
        getQuery().setConstructTemplate(t) ; }
//   |
//     <CONSTRUCT> <STAR>
//       { getQuery().setQueryResultStar(true) ; }
//   )
}

void AskClause() : {}
{
  <ASK> { getQuery().setType(Query.QueryTypeAsk) ; }
}
void WhereClause() : { Element el ; }
{
  (<WHERE>)? el = GraphPattern() { getQuery().setQueryElement(el) ; }
}

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

// ---- General Graph Pattern 
// Basic building block.

Element GraphPattern() : { Element el ; }
{
    { ElementGroup elg = new ElementGroup() ; }
  <LBRACE>
    PatternElement(elg)
    ( LOOKAHEAD(2) <DOT> PatternElement(elg) )*
    (<DOT>)?
  <RBRACE>
    {return elg ; }
}

// ---- All the elements that can make up a pattern

void PatternElement(ElementGroup elg) :
{ Element el = null ; Constraint c = null ; }
{
 (
   Triples(elg)
 |
   el = OptionalGraphPattern() { elg.addElement(el) ; }
 | LOOKAHEAD(3)
   // LOOKAHEAD needed to distinguish nested graph patterns
   // (plain {} in a group) {} UNION {}
   el = UnionGraphPattern() { elg.addElement(el) ; }
 |
   el = GraphPattern() { elg.addElement(el) ; }
 |
   el = GraphGraphPattern() { elg.addElement(el) ; }




 |
   el = Constraint() { elg.addElement(el) ; }
 )
}

// ---- Definitions of each pattern element

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


Element GraphGraphPattern() : { Element el ; Node n ;}
{
  (
    LOOKAHEAD(2)
    <GRAPH> <STAR> el = GraphPattern()
      { el = new ElementNamedGraph(el) ; }
  |
    <GRAPH> n = VarOrURI() el = GraphPattern()
      { el = new ElementNamedGraph(n, el) ; }
  )
    { return el ; }
}


Element UnionGraphPattern() : { Element el = null ;
                                ElementUnion el2 = null ; }
{
  el = GraphPattern()
  ( <UNION>
    { if ( el2 == null )
      {
        el2 = new ElementUnion() ;
        el2.addElement(el) ;
      }
    }
  el = GraphPattern()
    { el2.addElement(el) ; }
  )*
    { return (el2==null)? el : el2 ; }
}
Element Constraint() : { Constraint c ; }
{
  <FILTER>
  c = Expression()
  {
    ElementConstraints ec = new ElementConstraints() ;
    ec.addConstraint(c) ;
    return ec ;
  }
}


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

Template ConstructTemplate() : { Template t ; }
{
    { TemplateGroup g = new TemplateGroup() ; }
  <LBRACE>
    Triples(g)
    ( LOOKAHEAD(2) <DOT> Triples(g) )*
    (<DOT>)?
  <RBRACE>
    { return g ; }
}


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

// The grammar construct between the DOTs
void Triples(TripleCollector acc) : { Node s ; }
{
  LOOKAHEAD(2) // Find []
  s = VarOrTerm()
  PropertyList(s, acc)
|
  // Any of the tripe generating syntax elements
  s = TriplesNode(acc)
  (PropertyList(s, acc))?
}

void PropertyList(Node s, TripleCollector acc) : { Node p ; }
{
  ( p = VarOrURI() | <KW_A> { p = nRDFtype ; } )
  ObjectList(s, p, acc)
  ( LOOKAHEAD(2) <SEMICOLON> PropertyList(s, acc) )*
|
  Reification(s, acc)
}

void ObjectList(Node s, Node p, TripleCollector acc): { Node o ; }
{
  // The mark ensures that tripless end up in a nicer order
  // with t
  { int mark = acc.mark() ; }
 ( LOOKAHEAD(2) // [] or [ :p :q ]
  o = VarOrTerm()
 |
  o = TriplesNode(acc)
 )
  { Triple t = new Triple(s,p,o) ; acc.addTriple(mark, t) ; }
  ( LOOKAHEAD(2) <COMMA> ObjectList(s, p, acc ) ) *
}

// -------- 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() ; }
  PropertyList(n, acc)
  <RBRACKET>
    { return n ; }
}

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

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

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

  ">>"
    { return id ; }
}

// ------- RDF collections

Node Collection(TripleCollector acc) : { Node n ; }
{
  <LPAREN>
    n = CollectionTail(acc)
      { return n ; }
}

Node CollectionTail(TripleCollector acc) :
    { Node n ; int mark ; }
{
  (
     { mark = acc.mark() ; }
   n = GraphNode(acc)
     { Node item = createBNode() ;
       insert(acc, mark, item, nRDFfirst, n) ;
       mark = acc.mark() ; }
   n = CollectionTail(acc)
     { insert(acc, mark, item, nRDFrest, n) ;
       return item ; }
  |
    <RPAREN> { return nRDFnil ; }
  )
}

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

Node GraphNode(TripleCollector acc) : { Node n ; }
{
  LOOKAHEAD(2) // [] or [ :p :q ]
  n = VarOrTerm() { return n ; }
 |
  n = TriplesNode(acc) { return n ; }
}

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

// Property + DESCRIBE
Node VarOrURI() : {Node n = null ; }
{
  ( n = Var() | n = URI() )
  { return n ; }
}

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

Node GraphTerm() : { Node n ; }
{
  n = RDFTerm() { return n ; }
|
  <LPAREN> <RPAREN> { return nRDFnil ; }
// Maybe could move BlankNode() here from RDFTerm.
}

// Constraint syntax follows.

// **** Debug point

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

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

}

Expr ConditionalXorExpression() : { Expr n ; }
{
  n = ConditionalAndExpression()
  // Skip this
  //( <SC_XOR> ConditionalAndExpression()
    { return n ; }
}

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 ; }
}

// **** Debug point

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 ; }
{
  ( <TILDE> | <BANG> ) n = CallExpression()
    { return new E_LogicalNot(n) ; }
  | <PLUS> n = CallExpression() { return new E_UnaryPlus(n) ; }
  | <MINUS> n = CallExpression() { return new E_UnaryMinus(n) ; }
  | n = CallExpression() { return n ; }
}

Expr CallExpression() : { Expr expr ; Node gn ; }
{
     // STR
    <STR> <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) ; }

  | // Regular expression matcher
    { String s1 = null ; String s2 = null ; }
     <REGEX> <LPAREN>
         expr = Expression()
         <COMMA>
         s1 = String()
         ( <COMMA> s2 = String() )?
       <RPAREN>
       { return new E_Regex(expr, s1, s2) ; }

  | <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) ; }



//   | <IS_URI> <LPAREN> gn = Var() <RPAREN>
//     { return new E_IsURI(asExpr(gn)) ; }
// 
//   | <IS_BNODE> <LPAREN> gn = Var() <RPAREN>
//     { return new E_IsBlank(asExpr(gn)) ; }
// 
//   | <IS_LITERAL> <LPAREN> gn = Var() <RPAREN>
//     { return new E_IsLiteral(asExpr(gn)) ; }

  | //Casts and functions
    LOOKAHEAD(2) // Differentiate "q:name()"  and "q:name"
    expr = FunctionCall() { return expr ; }
  | expr = PrimaryExpression()
    { return expr ; }
}

Expr PrimaryExpression() : { Expr expr ; Node gn ; }
{
  ( gn = Var() { return asExpr(gn) ; }
  | gn = RDFTerm() { return asExpr(gn) ; }
  | <LPAREN> expr = Expression() <RPAREN> { return expr ; }
  )
}


Expr FunctionCall() : { Node fname ; List a ; }
{

  fname = URI() <LPAREN> a = ArgList() <RPAREN>
    { Expr e = new E_Function(fname.getURI(), a) ;
      return e ;
    }
}

List ArgList() : { Expr expr ; }
{
    { List args = new ArrayList() ; }
  ( expr = Expression() { args.add(expr) ; }
     (<COMMA> expr = Expression() { args.add(expr) ; } )*
  )?
    { return args ; }
}

// Term as used in expressions 

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

}

Node NumericLiteral() : { Node n ; }
{
  n = Integer() { return n ; }
|
  n = FloatingPoint() { return n ; }
}

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 = URI() )?
    { 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>
  )
    { lex = stripQuotes(t.image) ;
      lex = unescape(lex) ;
      return lex ;
    }
}

Node URI() : { Node n ; }
{
  n = QuotedURIref() { return n ; }
|
  n = QName() { return n ; }
}

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

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

}

Node QuotedURIref() : { Token t ; }
{
  t = <Q_URIref>
  { String s = stripQuotes(t.image) ;
    s = fixupURI(s) ;
    return Node.createURI(s) ; }
}

Node Integer() : { Token t ; }
{
  t = <INTEGER_10> { return makeNodeInteger(t.image) ; }
//   |
     // Looses the lexical form.
//   t = <INTEGER_16> { return makeNodeInteger(integerValue(t.image)) ; }
}

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

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

// Comments and whitespace

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

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

// Main tokens */

TOKEN:
{
   // Includes # for relative URIs
   <Q_URIref: "<" (<NCCHAR1>|"#"|"_"|"/"|"&") (~[">"," "])* ">" >

   // The QName() rule uses both of these - PrefixDecl() just the first
| <QNAME_NS: (<NCNAME_PREFIX>)? ":" >
| <QNAME: (<NCNAME_PREFIX>)? ":" (<NCNAME1>|<NCNAME2>)? >
| <BNODE_LABEL: "_:" (<NCNAME1>|<NCNAME2>) >

| <VAR: ("?"|"$") (<NCNAME2>|<NCNAME1>) >
| <LANGTAG: <AT> (<A2Z>)+("-" (<A2ZN>)+)? >
| <#A2Z: ["a"-"z","A"-"Z"]>
| <#A2ZN: ["a"-"z","A"-"Z","0"-"9"]>
}

// -------------------------------------------------
// LITERALS

TOKEN :
{ // No sign - that is done in the grammar.

   < INTEGER_10: /*(["-","+"])?*/ <DIGITS> >
// |  < INTEGER_16: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >

| < FLOATING_POINT:
      //(["+","-"])?
      (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
      | "." (["0"-"9"])+ (<EXPONENT>)?
      | (["0"-"9"])+ <EXPONENT> //NB Must have exponent for this case.
      >
| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
| < STRING_LITERAL1:
      // Single quoted string
      "'" ( (~["'","\\","\n","\r"]) | ("\\" ~["\n","\r"]) )* "'" >
| < STRING_LITERAL2:
    // Double quoted string
      "\"" ( (~["\"","\\","\n","\r"]) | ("\\" ~["\n","\r"]) )* "\"" >
| < DIGITS: (["0"-"9"])+>
}

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

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

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







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



| < FILTER: "filter" >

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

| < REGEX: "regex" >





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


TOKEN :
{
  < LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
}

// Operator

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

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

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

// | < INCR: "++" >
// | < DECR: "--" >

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

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

//| < LSHIFT:  "<<" >
//| < RSIGNEDSHIFT: ">>" >

// | < STR_MATCH: ("=~"|"~~") >
// | < STR_NMATCH: "!~">

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

// Notes:
// XML 1.1              http://www.w3.org/TR/xml11/
// XML Namespces 1.1    http://www.w3.org/TR/xml-names11/
//     Prefix ':' LocalPart
//     Prefix is an NCName
//     LocalPart is an NCName
// 
//     // An XML Name, minus the ":"
//     NCName    ::=    NCNameStartChar NCNameChar*
//     NCNameChar         ::=    NameChar - ':' 
//     NCNameStartChar    ::=    NameStartChar - ':' 

//     NameChar and NameSartChar defined in XML 1.1
//     NameStartChar := ":" | [A-Z] | "_" | [a-z] |
//                      was: [#xC0-#x2FF] |
//                      now: [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] |
//                      [#x370-#x37D] | [#x37F-#x1FFF] |
//                      [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] |
//                      [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
//                      [#x3001-#xD7FF] | [#xF900-#xEFFFF]
//     NameChar      := NameStartChar | "-" | "." | [0-9] | #xB7 |
//                         [#x0300-#x036F] | [#x203F-#x2040]

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"-"\uFFFF"] >
|
  // #NCCHAR without a dot.
  <#NCCHAR_END: (<NCCHAR1> | "_" | "-" | ["0"-"9"] | "\u00B7" )>
|
  // Full NCNAME, putting back the "."
  <#NCCHAR_FULL: (<NCCHAR_END> | "." ) >
|
  // NCNAME but no leading "_", no trailing "."
  <#NCNAME1: <NCCHAR1> ((<NCCHAR_FULL>)* <NCCHAR_END>)? >
|
  // With a leading "_", no trailing "."
  <#NCNAME2: "_" ((<NCCHAR_FULL>)* <NCCHAR_END>)? >
|
  // With trailing dot, no "_" to start
  <#NCNAME_PREFIX: <NCCHAR1> (<NCCHAR_FULL>)* >
}


/*
 * (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:
*/