• Home
• com.blazegraph
• sparql-grammar
• 2.0.1
• source code
• sparql.jjt

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.bigdata.rdf.sail.sparql.ast.sparql.jjt Maven / Gradle / Ivy

/**

Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016.  All rights reserved.

Contact:
     SYSTAP, LLC DBA Blazegraph
     2501 Calvert ST NW #106
     Washington, DC 20008
     [email protected]

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
/* @author: Bryan Thompson
 * @openrdf
 *
 * "make javacc" to rebuild.  Be sure to first remove the sparql.jj file
 * so it will generate a new one.
 * 
 * Updated 6/7/14 by Mike Personick.  Updated to capture the delta between the 
 * Sesame 2.6.10/2.7.12 sparql.jjt files.
 */
 
/*
 * Copyright Aduna (http://www.aduna-software.com/) (c) 1997-2007.
 *
 * Licensed under the Aduna BSD-style license.
 */

/*
 * SPARQL JJTree input file for JavaCC, a Java Compiler Compiler. JavaCC can be
 * downloaded from https://javacc.dev.java.net/
 *
 * author: Arjohn Kampman
 */

options {
    MULTI=true;
    VISITOR=true;
    VISITOR_EXCEPTION="VisitorException";
    STATIC=false;
    UNICODE_INPUT=true;
    JAVA_UNICODE_ESCAPE=true; // pre-process unicode escapes, see section A.2 of spec
}

PARSER_BEGIN(SyntaxTreeBuilder)

package com.bigdata.rdf.sail.sparql.ast;

import java.io.StringReader;

import org.openrdf.model.URI;
import org.openrdf.model.vocabulary.RDF;
import org.openrdf.model.vocabulary.XMLSchema;
import org.openrdf.query.algebra.Compare.CompareOp;
import org.openrdf.query.algebra.MathExpr.MathOp;
import org.openrdf.rio.RDFParser.DatatypeHandling;

public class SyntaxTreeBuilder {

    /**
     * Parses the supplied SPARQL query and builds a syntax tree from it.
     *
     * @param query A SPARQL query string.
     * @return The root of the syntax tree.
     * @throws TokenMgrError If the query was syntactically incorrect.
     * @throws ParseException If the query was syntactically incorrect.
     */
    public static ASTQueryContainer parseQuery(final String query)
        throws TokenMgrError, ParseException
    {
        final SyntaxTreeBuilder stb = new SyntaxTreeBuilder( new StringReader(query) );

        // Set size of tab to 1 to force tokenmanager to report correct column
        // index for substring splitting of service graph pattern.
        stb.jj_input_stream.setTabSize(1);

        final ASTQueryContainer container = stb.QueryContainer();
        container.setSourceString(query);
        return container;
    }

    /**
     * Parses the supplied SPARQL update sequence and builds a syntax tree from it.
     *
     * @param sequence A SPARQL update sequence string.
     * @return The root of the syntax tree.
     * @throws TokenMgrError If the update sequence was syntactically incorrect.
     * @throws ParseException If the update sequence was syntactically incorrect.
     */
    public static ASTUpdateSequence parseUpdateSequence(final String sequence)
        throws TokenMgrError, ParseException
    {
        final SyntaxTreeBuilder stb = new SyntaxTreeBuilder( new StringReader(sequence) );
        final ASTUpdateSequence seq = stb.UpdateSequence();
        seq.setSourceString(sequence);
        return seq;
    }
    
    /**
     * Trims n character from the start and end of the supplied string.
     */
    private static String _trimString(String s, int n) {
        if (s.length() >= 2 * n) {
            s = s.substring(n, s.length() - n);
        }
        return s;
    }

	private String readToMatchingBrace() {
	    StringBuilder sb = new StringBuilder();
	    Token tok;
	    int nesting = 1;
	    boolean previousTokenDtSep = false;
	    while (true) {
		tok = getToken(1);
		if (!previousTokenDtSep && ! tok.image.equals("^^") && !tok.image.startsWith("@")) {
		    sb.append(" ");
		}
		if (tok.kind == LBRACE) nesting++;
		if (tok.kind == RBRACE) {
		    nesting--;
		    if (nesting == 0) break;
		}
		// To provide correct line numbers (see https://jira.blazegraph.com/browse/BLZG-1397)
		// we should keep line breaks and one-line comments. So, we are adding special tokens
		// (comments and and new line char) per https://javacc.java.net/doc/tokenmanager.html

		if (tok.specialToken != null) {
			// The above statement determines that there is a special token
			Token tmp_t = tok.specialToken;
			while (tmp_t.specialToken != null)
				tmp_t = tmp_t.specialToken;
			// The above line walks back the special token chain until it
			// reaches the first special token after the previous regular
			// token.
			while (tmp_t != null) {
				sb.append(tmp_t.image);
				tmp_t = tmp_t.next;
			}
			// The above loop now walks the special token chain in the forward
			// direction printing them in the process.
		}
		sb.append(tok.image);
		previousTokenDtSep = tok.image.equals("^^");

		tok = getNextToken();

	    }
	    return sb.toString();
	}
}
PARSER_END(SyntaxTreeBuilder)

//
// tokens
//

TOKEN :
{
    // Whitespace characters
    <#WS_CHAR: " " | "\t" | "\r" | "\f">
}

SKIP :
{
    >
}

SPECIAL_TOKEN :
{
    
|   
}

// Special characters
TOKEN :
{
    
|   
|   
|   
|   
|   
|   
|   
|   
|   ">
|   
|   =">
|   
|   
|   
|   
|   
|   
|   
|   
|       
|   
|   
|    (|)* >
|    (|)* >
}

TOKEN :
{
     // Note: case-sensitive!
}

TOKEN [IGNORE_CASE] :
{
    
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|	
|	
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|	
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
}

TOKEN [IGNORE_CASE] :   // Bigdata extension specific tokens
{
    
|   
|   >
|   
|   
|   
|   
|   >">
// RDFParserOptions (for LOAD)
|   
|   
|   
|   
|   
|   
|   
// Managing Truth Maintenance
|   
|   
|   
|   
}

TOKEN [IGNORE_CASE] :   // SPARQL 1.1 Update-specific tokens
{
    
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
|   
}

TOKEN:
{
    ", "\"", "{", "}", "|", "^", "`", "\\", "\u0000"-"\u0020"])* ">">

|   )? ":">
|   )? ":" > // Note: PN_LOCAL not optional, case handled by PNAME_NS
|	 | ) ((|".")* )? >
|   >
|   >
|   )+ ("-" (|)+)*>
|   )+>
|   >
|   >
|   |)>
|   <#DECIMAL1: ()+ "." ()*>
|   <#DECIMAL2: "." ()+>
|   >
|   >
|   ||)>
|   <#DOUBLE1: ()+ "." ()* >
|   <#DOUBLE2: "." ()+ >
|   <#DOUBLE3: ()+ >
|   <#EXPONENT: ["e","E"] (["+","-"])? ()+>
|   >
|   >
|   |)* "'">
|   |)* "\"">
|   |) )* "'''">
|   |) )* "\"\"\"">
|   <#SAFE_CHAR1: (~["'", "\\", "\r", "\n"])>
|   <#SAFE_CHAR2: (~["\"", "\\", "\r", "\n"])>
|   <#SAFE_CHAR_LONG1: (~["'","\\"])>
|   <#SAFE_CHAR_LONG2: (~["\"","\\"])>
|   <#ECHAR: "\\" ["t", "b", "n", "r", "f", "\\", "\"", "'"]>
|   <#HEX: ["0"-"9"] | ["A"-"F"] | ["a"-"f"]>
|   <#ALPHA: ["a"-"z","A"-"Z"]>
|   <#NUM: ["0"-"9"]>
}

TOKEN:
{
    <#PN_CHARS_BASE:
         | ["\u00C0"-"\u00D6"] | ["\u00D8"-"\u00F6"] | ["\u00F8"-"\u02FF"] | ["\u0370"-"\u037D"]
      | ["\u037F"-"\u1FFF"] | ["\u200C"-"\u200D"] | ["\u2070"-"\u218F"] | ["\u2C00"-"\u2FEF"]
      | ["\u3001"-"\uD7FF"] | ["\uF900"-"\uFDCF"] | ["\uFDF0"-"\uFFFD"]
      // | ["\u10000"-"\uEFFFF"] FIXME: JavaCC/Java can't handle this?
    >
|   <#PN_CHARS_U:  | "_">
|	<#VAR_CHAR:  |  | "\u00B7" | ["\u0300"-"\u036F"] | ["\u203F"-"\u2040"]>
|	<#PN_CHARS:  | "-" |  | "\u00B7" | ["\u0300"-"\u036F"] | ["\u203F"-"\u2040"]> 
|	<#PN_PREFIX:  ( ( | ".")* )?>
|	<#PN_LOCAL: ( | ":" |  |  ) ( ( | "." | ":" | )* (  | ":" | ) )?>
|   <#PLX:  | >
|   <#PERCENT: "%"  >
|	<#PN_LOCAL_ESC: "\\" [ "_", "~", ".", "-", "!", "$", "&", "\"", "(", ")", "*", "+", ",", ";", "=", "/", "?", "#", "@", "%" ]>
|	<#VARNAME: ( |  ) ()*>
}

//
// grammar
//

ASTUpdateSequence UpdateSequence():
{}
{
    UpdateContainer() [  UpdateSequence() ] 
    { return jjtThis; }
}

ASTUpdateContainer UpdateContainer():
{}
{
    Prolog() [ Update() ]
    { return jjtThis; }
}

ASTQueryContainer QueryContainer():
{}
{
    Prolog() Query() 
    { return jjtThis; }
}

void Prolog() #void :
{}
{
    ( PrefixDecl() | BaseDecl() )*
}

void BaseDecl() :
{ Token t; }
{
     t =  {jjtThis.setIRI(_trimString(t.image, 1));}
}

void PrefixDecl() :
{ Token prefix; }
{
     prefix =  IRI()
    {
        // Remove trailing colon from prefix
        String prefixStr = prefix.image;
        prefixStr = prefixStr.substring(0, prefixStr.length() - 1);

        jjtThis.setPrefix(prefixStr);
    }
}


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

void SelectQuery() :
{}
{
    Select()
    ( DatasetClause() )*
    ( NamedSubquery() )*
    WhereClause()
    SolutionModifier()
    [BindingsClause()]
}

void SubSelect() #SelectQuery : // subselect does not accept dataset clauses
{}
{
    Select()
    WhereClause()
    SolutionModifier()
    [BindingsClause()]
}

void Select() :
{}
{
    
    
    [
         {jjtThis.setDistinct(true);}
    |
         {jjtThis.setReduced(true);}
    ]

    (
         { jjtThis.setWildcard(true); }
    |
        ( ProjectionElem() )+ 
    )
}

void ProjectionElem() :
{}
{
    Var() 
    |
     Expression()  Var() 
}

void ConstructQuery() :
{}
{
    Construct()
    ( DatasetClause() )*
    ( NamedSubquery() )*
    WhereClause()
    SolutionModifier()
    [BindingsClause()]
}

void Construct() :
{}
{   
     [ LOOKAHEAD(2) ConstructClause() ]
    
}

void ConstructClause() #void :
{}
{
    // Note: replaced ConstructTriples ref with equivalent TriplesBlock ref
     [ TriplesBlock() ] 
}

void DescribeQuery() :
{}
{
    Describe()
    ( DatasetClause() )*
    ( NamedSubquery() )*
    [ WhereClause() ]
    SolutionModifier()
    [BindingsClause()]
}

void Describe() :
{}
{
    
    (
         { jjtThis.setWildcard(true); }
    |
        ( VarOrIRIref() )+
    )
}

void AskQuery() :
{}
{
    
    ( DatasetClause() )*
    ( NamedSubquery() )*
    WhereClause()
    [BindingsClause()]
}

void NamedSubquery() :
{Token t;}
{
      SelectQuery()   t = 
    {
      jjtThis.setName(t.image);
    }
} 

void DatasetClause() :
{}
{
    
    (
      (
        [ {jjtThis.setNamed(true);}]
        [ {jjtThis.setVirtual(true);}]
        IRIref()
      )
      // Note: This appears to be an openrdf specific extension whose
      // semantics are to query the default graph.  That is what we do
      // anyway if nothing is specified. E.g., "SELECT * FROM DEFAULT"
      // and "SELECT *" will do the same thing for bigdata.
      |  
    )
}

void WhereClause() :
{}
{
     [] GroupGraphPattern()
}

void BindingsClause() :
{}
{
     DataBlock()
    // Keeping deprecated BINDINGS keyword for backward compatibility purposes
    |  (Var())*  (BindingSet())* 
}

void InlineData():
{}
{
     DataBlock()
}

void DataBlock() #void :
{}
{
     InlineDataOneVar()
   | InlineDataFull()
}

void InlineDataOneVar() #void :
{}
{
    Var()  (SimpleBindingSet())* 
}

void InlineDataFull() #void :
{}
{
    (  |  (Var())*  )  ( BindingSet())* 
}

void SimpleBindingSet() #BindingSet :
{}
{
    BindingValue() 
}

void BindingSet() :
{}
{
     ( BindingValue() )*  |  
}

void BindingValue() :
{}
{
    IRIref()
|   RDFLiteral()
|   NumericLiteral()
|   BooleanLiteral()
|    
}

void SolutionModifier() #void :
{}
{
    [GroupClause()] [HavingClause()] [OrderClause()] [LimitOffsetClauses()]
}

void GroupClause() :
{}
{
      ( GroupCondition() )+
}

void OrderClause() :
{}
{
      ( OrderCondition() )+
}

void GroupCondition() :
{}
{
    FunctionCall()
|   BuiltInCall()
|    Expression() [  Var() ]  
|   Var()
}

void HavingClause() :
{}
{
     Constraint()
}

void OrderCondition() :
{}
{
    [  |  {jjtThis.setAscending(false);}] BrackettedExpression()
|   FunctionCall()
|   BuiltInCall()
|   Var()
}

void LimitOffsetClauses() #void :
{}
{
    Limit() [ Offset() ]
|
    Offset() [ Limit() ]
}

void Limit() :
{ Token t; }
{
     t = 
    { jjtThis.setValue(Long.parseLong(t.image)); }
}

void Offset() :
{ Token t; }
{
     t = 
    { jjtThis.setValue(Long.parseLong(t.image)); }
}

// Note: Allows return of the text for the SERVICE's inner graph pattern.
Token GroupGraphPattern() #GraphPatternGroup :
{Token endOfPatternToken; }
{
     
    (
        SubSelect() 
        | 
        GraphPattern()
    ) 
    endOfPatternToken = 
    {
        return endOfPatternToken;
    }
}
//void GroupGraphPattern() #GraphPatternGroup :
//{}
//{
//   (SelectQuery() | GraphPattern()) 
//}

void GraphPattern() #void :
{}
{
    [BasicGraphPattern()] [ GraphPatternNotTriples() [] GraphPattern() ]
}

void BasicGraphPattern() :
{}
{
    TriplesBlock() ( FilterOrBind() [] [TriplesBlock()] )*
|
    ( FilterOrBind() [] [TriplesBlock()] )+
}


void FilterOrBind() #void :
{}
{
    Filter()
    |
    NamedSubqueryInclude()
    | 
    Bind()
    |
    Let() 
}

void NamedSubqueryInclude() :
{Token t;}
{
      t = 
     { jjtThis.setName(t.image); }
}

void VarList() #void :
{}
{
    
|
     Var() (  Var() )* 
}

void TriplesBlock() #void :
{}
{
    // Note: recursive rule rewriten to non-recursive rule, requires lookahead
    TriplesSameSubjectPath() ( LOOKAHEAD(2)  TriplesSameSubjectPath() )* []
}

void TriplesTemplate() #void :
{}
{
    // Note: recursive rule rewriten to non-recursive rule, requires lookahead
    TriplesSameSubject() ( LOOKAHEAD(2)  TriplesSameSubject() )* []
}

void GraphPatternNotTriples() #void :
{}
{
    OptionalGraphPattern()
|   GroupOrUnionGraphPattern()
|   GraphGraphPattern()
|   MinusGraphPattern()
|   ServiceGraphPattern()
| 	InlineData()
}

void OptionalGraphPattern() :
{}
{
    // Note: does not refer GroupGraphPattern() because constraints are not limited
    // to the optional graph pattern, but can also reference the operator's LHS
      (SubSelect() | GraphPattern()) 
}

void GraphGraphPattern() :
{}
{
     VarOrIRIref() GroupGraphPattern()
}

void GroupOrUnionGraphPattern() #void :
{}
{
    GroupGraphPattern() [  GroupOrUnionGraphPattern() #UnionGraphPattern(2) ]
}

void MinusGraphPattern() :
{}
{
     GroupGraphPattern()
}

void ServiceGraphPattern() :
{ Token t; }
{
    t =   
    {
    jjtThis.setBeginTokenLinePos(t.beginLine);
    jjtThis.setBeginTokenColumnPos(t.beginColumn);
    }
    [ { jjtThis.setSilent(true); } ] 
    VarOrIRIref() 
    t = GroupGraphPattern()
    {
    jjtThis.setEndTokenLinePos(t.beginLine);
    jjtThis.setEndTokenColumnPos(t.beginColumn);
    }
}

void Filter() #void :
{}
{
     Constraint()
}

void Constraint() :
{}
{
    BrackettedExpression()
|   BuiltInCall()
|   FunctionCall()
}

void FunctionCall() :
{}
{
    IRIref() ArgList()
}

void ArgList() #void :
{}
{
    
|
     Expression() (  Expression() )* 
}

void TriplesSameSubject() :
{}
{
    VarOrTerm() PropertyList()
|
    TriplesNode() [PropertyList()]
}

void PropertyList() :
{}
{
    Verb() ObjectList() [  [PropertyList()] ]
}

void ObjectList():
{}
{
    Object() (  Object() )*
}

void TriplesSameSubjectPath() :
{}
{
// Extension for triple reference pattern.
//  VarOrTerm() PropertyListPath()
    VarOrTermOrTRefP() PropertyListPath()
    |
    TriplesNodePath() [PropertyListPath()]
}

void PropertyListPath() :
{}
{
    (VerbPath() | VerbSimple()) ObjectListPath() [ [PropertyListPath()] ]
}

void ObjectListPath() #ObjectList:
{}
{
	ObjectPath() (  ObjectPath() )*
}

void VerbPath() #void :
{}
{
    Path()
}

void Path() #void :
{}
{
    PathAlternative()
}

void PathAlternative() :
{}
{
    PathSequence() (  PathSequence() )*
}

void PathSequence() :
{}
{
    PathElt() (  PathElt() )*
}

void PathElt() :
{}
{
   [ {jjtThis.setInverse(true); }] PathPrimary() [ PathMod() ]
}

void PathPrimary() #void :
{}
{
    IRIref() 
    |
     { jjtThis.setValue(RDF.TYPE.toString()); } #IRI
    |
     PathNegatedPropertySet() 
    |
     Path() 
}

void PathNegatedPropertySet() #void :
{}
{
    PathOneInPropertySet() 
    |
    
    [ PathOneInPropertySet() (  PathOneInPropertySet() )* ]
    
}

void PathOneInPropertySet() :
{}
{
    IRIref() 
    |
     { jjtThis.setValue(RDF.TYPE.toString()); } #IRI
    |
     {jjtThis.setInverse(true); } ( IRIref() |  { jjtThis.setValue(RDF.TYPE.toString()); } #IRI )
}

void PathMod() :
{ Token min;
  Token max; 
}
{
     { jjtThis.setLowerBound(0);
         jjtThis.setUpperBound(Long.MAX_VALUE);
    }
    |
     { jjtThis.setLowerBound(0);
         jjtThis.setUpperBound(1); 
    }
    |
     { jjtThis.setLowerBound(1);
         jjtThis.setUpperBound(Long.MAX_VALUE);
    }
}

void VerbSimple() #void :
{}
{
    Var()
}

void Object() #void :
{}
{
	GraphNode()
|   TRefPattern() // extension for triple reference patterns.
}

void ObjectPath() #void :{}
{
    GraphNodePath()
}

void Verb() #void :
{}
{
    VarOrIRIref()
|
     { jjtThis.setValue(RDF.TYPE.toString()); } #IRI
}

void TriplesNode() #void :
{}
{
    Collection()
|
    BlankNodePropertyList()
}

void TriplesNodePath() #void :
{}
{
	CollectionPath()
|
	BlankNodePropertyListPath()
}

void BlankNodePropertyList() :
{}
{
     PropertyList() 
}

void BlankNodePropertyListPath() #BlankNodePropertyList :
{}
{
	 PropertyListPath() 
}

void Collection() :
{}
{
     ( GraphNode() )+ 
}

void CollectionPath() #Collection:
{}
{
	 ( GraphNodePath() )+ 
}

void GraphNode() #void :
{}
{
    VarOrTerm()
|
    TriplesNode()
}

void GraphNodePath() #void :
{}
{
	VarOrTerm()
|
	TriplesNodePath()
}

void VarOrTerm() #void :
{}
{
    Var()
|
    GraphTerm()
}

void VarOrIRIref() #void :
{}
{
    Var()
|
    IRIref()
}

void Var() :
{ Token t; }
{
    ( t =  | t =  )
    { jjtThis.setName(t.image.substring(1)); }
}

void GraphTerm() #void :
{
    boolean positive = true;
}
{
    IRIref()
|
    RDFLiteral()
|
    NumericLiteral()
|
    BooleanLiteral()
|
    BlankNode()
|
     {jjtThis.setValue(RDF.NIL.toString());} #IRI
}

void Expression() #void :
{}
{
    ConditionalOrExpression()
}

void ConditionalOrExpression() #void :
{}
{
    ConditionalAndExpression() [  ConditionalOrExpression() #Or(2) ]
}

void ConditionalAndExpression() #void :
{}
{
    ValueLogical() [  ConditionalAndExpression() #And(2) ]
}

void ValueLogical() #void :
{}
{
    RelationalExpression()
}

void RelationalExpression() #void :
{}
{
    NumericExpression()
    [
         NumericExpression() {jjtThis.setOperator(CompareOp.EQ);} #Compare(2)
    |    NumericExpression() {jjtThis.setOperator(CompareOp.NE);} #Compare(2)
    |    NumericExpression() {jjtThis.setOperator(CompareOp.LT);} #Compare(2)
    |    NumericExpression() {jjtThis.setOperator(CompareOp.LE);} #Compare(2)
    |    NumericExpression() {jjtThis.setOperator(CompareOp.GE);} #Compare(2)
    |    NumericExpression() {jjtThis.setOperator(CompareOp.GT);} #Compare(2)
    |   In() #Infix(2)
    |   NotIn() #Infix(2)
    ]
}

void NumericExpression () #void :
{}
{
    AdditiveExpression()
}

void AdditiveExpression() #void :
{}
{
    MultiplicativeExpression()
    (
       MultiplicativeExpression() {jjtThis.setOperator(MathOp.PLUS);} #Math(2)
    |  MultiplicativeExpression() {jjtThis.setOperator(MathOp.MINUS);} #Math(2)
    | NumericLiteralPositive() {jjtThis.setOperator(MathOp.PLUS);} #Math(2)
    | NumericLiteralNegative() {jjtThis.setOperator(MathOp.PLUS);} #Math(2)
    )*
}

void MultiplicativeExpression() #void :
{}
{
    UnaryExpression()
    (
       UnaryExpression() {jjtThis.setOperator(MathOp.MULTIPLY);} #Math(2)
    |  UnaryExpression() {jjtThis.setOperator(MathOp.DIVIDE);} #Math(2)
    )*
}

void UnaryExpression() #void :
{}
{
     PrimaryExpression() #Not
|
    [] PrimaryExpression()
|
    UnaryMinus() PrimaryExpression() {jjtThis.setOperator(MathOp.MULTIPLY);} #Math(2)
}

void UnaryMinus() #NumericLiteral :
{}
{
    
    {
        jjtThis.setValue("-1");
        jjtThis.setDatatype(XMLSchema.INTEGER);
    }
}

void PrimaryExpression() #void :
{}
{
    BrackettedExpression()
|   BuiltInCall()
|   LOOKAHEAD(2) FunctionCall()
|   IRIref()
|   RDFLiteral()
|   NumericLiteral()
|   BooleanLiteral()
|   Var()
|   Aggregate()
}

void Aggregate() #void :
{}
{
    Count() 
|   Sum()
|   Min()
|   Max()
|   Avg()
|   Sample()
|   GroupConcat()
}

void Count() :
{}
{
      [  {jjtThis.setDistinct(true);} ]
       (  {jjtThis.setWildcard(true); } | Expression() ) 
}

void Sum() :
{}
{
      [  {jjtThis.setDistinct(true);} ] Expression() 
}

void Min() :
{}
{
      [  {jjtThis.setDistinct(true);} ] Expression() 
}

void Max() :
{}
{
      [  {jjtThis.setDistinct(true);} ] Expression() 
}

void Avg() :
{}
{
      [  {jjtThis.setDistinct(true);} ] Expression() 
}

void Sample() :
{}
{
      [  {jjtThis.setDistinct(true);} ] Expression() 
}

void GroupConcat() :
{}
{
      [  {jjtThis.setDistinct(true);} ]
    Expression() [    Expression() ] 
}

void BrackettedExpression() #void :
{}
{
     Expression() 
}



void BuiltInCall() #void :
{}
{
    Bound()
|   SameTerm()
|   ExistsFunc()
|   NotExistsFunc()
|   Coalesce()
|   If()
|   StringFunction()
|   NumericFunction()
|   RDFTermFunction()
|   DateTimeFunction()
|   HashFunction()
}

void StringFunction() #void :
{}
{
    Substr()
|   StrLen()
|   UpperCase()
|   LowerCase()
|   StrStarts()
|   StrEnds()
|   StrBefore()
|   StrAfter()
|   Replace()
|   Concat()
|   Contains()
|   EncodeForURI()
|   LangMatches()
|   RegexExpression()
}
void NumericFunction() #void :
{}
{
    Rand()
|   Abs()
|   Ceil()
|   Floor()
|   Round()
}

void RDFTermFunction() #void :
{}
{
    IsIRI()
|   IsBlank()
|   IsLiteral()
|   IsNumeric()
|   BNodeFunc()
|   IRIFunc()
|   Lang()
|   Datatype()
|   Str()
|   StrDt()
|   StrLang()
|	UUID()
|	STRUUID()
}

void DateTimeFunction() #void :
{}
{
    Now()
|   Year()
|   Month()
|   Day()
|   Hours()
|   Minutes()
|   Seconds()
|   Timezone()
|   Tz()
}

void HashFunction() #void :
{}
{
    MD5()
|   SHA1()
|   SHA224()
|   SHA256()
|   SHA384()
|   SHA512()
}


void MD5() :
{}
{
      Expression() 
}

void SHA1() :
{}
{
      Expression() 
}

void SHA224() :
{}
{
      Expression() 
}

void SHA256() :
{}
{
      Expression() 
}

void SHA384() :
{}
{
      Expression() 
}

void SHA512() :
{}
{
      Expression() 
}

void Now() :
{}
{
     
}

void Year() :
{}
{
      Expression() 
}

void Month() :
{}
{
      Expression() 
}

void Day() :
{}
{
      Expression() 
}

void Hours() :
{}
{
      Expression() 
}

void Minutes() :
{}
{
      Expression() 
}

void Seconds() :
{}
{
      Expression() 
}

void Timezone() :
{}
{
      Expression() 
}

void Tz() :
{}
{
      Expression() 
}

void Rand() :
{}
{
     
}

void Abs() :
{}
{
      Expression() 
}

void Ceil() :
{}
{
      Expression() 
}

void Floor() :
{}
{
      Expression() 
}

void Round() :
{}
{
      Expression() 
}

void Substr() :
{}
{
      Expression()  Expression() [  Expression() ] 
}

void StrLen() :
{}
{
      Expression() 
}

void UpperCase() :
{}
{
      Expression() 
}

void LowerCase() :
{}
{
      Expression() 
}

void StrStarts() :
{}
{
      Expression()  Expression() 
}

void StrEnds() :
{}
{
      Expression()  Expression() 
}

void StrBefore() :
{}
{
      Expression()  Expression() 
}

void StrAfter() :
{}
{
      Expression()  Expression() 
}

void Replace() :
{}
{
      Expression()  Expression()  Expression() [  Expression() ] 
}

void Concat() :
{}
{
     ArgList()
}

void Contains() :
{}
{
      Expression()  Expression() 
}

void EncodeForURI() :
{}
{
      Expression() 
}

void If() :
{}
{
      Expression()  Expression()  Expression() 
}

void In() :
{}
{
     ArgList()
}

void NotIn() :
{}
{
     ArgList()
}

void Coalesce() : 
{}
{
      Expression() ( Expression())* 
}

void Str() :
{}
{
      Expression() 
}

void Lang() :
{}
{
      Expression() 
}

void LangMatches() :
{}
{
      Expression()  Expression() 
}

void Datatype() :
{}
{
      Expression() 
}

void Bound() :
{}
{
      Var() 
}

void SameTerm() :
{}
{
      Expression()  Expression() 
}

void IsIRI() :
{}
{
      Expression() 
}

void IsBlank() :
{}
{
      Expression() 
}

void IsLiteral() :
{}
{
      Expression() 
}

void IsNumeric() :
{}
{
      Expression() 
}

void BNodeFunc() :
{}
{
     (  |  Expression()  ) 
}

void IRIFunc() :
{}
{
      Expression() 
}

void StrDt() :
{}
{
      Expression()  Expression() 
}

void StrLang() :
{}
{
      Expression()  Expression() 
}

void UUID() :
{}
{
	 
}

void STRUUID() :
{}
{
	 
}

void Bind() :
{}
{
  // Note: Extension for triple pattern references.
//      Expression()  Var() 
      ( Expression() | TRefPattern() )  Var() 
}

// LET ( ?x := expr ) is an alternative for BIND( expr AS ?x). They do the same thing.
// TODO Handle TRefPattern() in LET.
void Let() :
{}
{
      Var()  Expression() 
}

void RegexExpression() :
{}
{
      Expression()  Expression() [  Expression() ] 
}

void ExistsFunc() :
{}
{
     GroupGraphPattern()
}

void NotExistsFunc() :
{}
{
     GroupGraphPattern()
}


void RDFLiteral() :
{ Token t; }
{
    String()
    [
        t =  {jjtThis.setLang(t.image.substring(1));}
    |
         IRIref()
    ]
}

void NumericLiteral() #void :
{}
{
    (
        NumericLiteralUnsigned()
    |   NumericLiteralPositive()
    |   NumericLiteralNegative()
    )
}

void NumericLiteralUnsigned() #NumericLiteral :
{ Token t; URI datatype; }
{
    (
        t =  { datatype = XMLSchema.INTEGER; }
    |   t =  { datatype = XMLSchema.DECIMAL; }
    |   t =  { datatype = XMLSchema.DOUBLE; }
    )

    {
        jjtThis.setValue(t.image);
        jjtThis.setDatatype(datatype);
    }
}

void NumericLiteralPositive() #NumericLiteral :
{ Token t; URI datatype; }
{
    (
        t =  { datatype = XMLSchema.INTEGER; }
    |   t =  { datatype = XMLSchema.DECIMAL; }
    |   t =  { datatype = XMLSchema.DOUBLE; }
    )

    {
        jjtThis.setValue(t.image);
        jjtThis.setDatatype(datatype);
    }
}

void NumericLiteralNegative() #NumericLiteral :
{ Token t; URI datatype; }
{
    (
        t =  { datatype = XMLSchema.INTEGER; }
    |   t =  { datatype = XMLSchema.DECIMAL; }
    |   t =  { datatype = XMLSchema.DOUBLE; }
    )

    {
        jjtThis.setValue(t.image);
        jjtThis.setDatatype(datatype);
    }
}

void BooleanLiteral() #void :
{}
{
     #True
|    #False
}

void String() :
{ Token t; }
{
    ( t =  | t=  )
    {jjtThis.setValue(_trimString(t.image, 1));}
|
    ( t =  | t = )
    {jjtThis.setValue(_trimString(t.image, 3));}
}

void IRIref() #void :
{}
{
    IRI()
|
    PrefixedName()
}

void PrefixedName() #QName :
{ Token t; }
{
    (t =  | t = )
    {jjtThis.setValue(t.image);}
}

void BlankNode() :
{ Token t; }
{
    t =  {jjtThis.setID(t.image.substring(2));}
|
    
}

void IRI() :
{ Token t; }
{
    t =  {jjtThis.setValue(_trimString(t.image, 1));}
}

/// SPARQL 1.1 Update productions

// bigdata extensions: GRAPHS, SOLUTIONS, and SolutionsRef(). 
void GraphRefAll() :
{}
{
    GraphRef() 
|    {jjtThis.setDefault(true); }
|            {jjtThis.setNamed(true); }
|              {jjtThis.setAllGraphs(true); jjtThis.setAllSolutions(true); }
|           {jjtThis.setAllGraphs(true); }
|   LOOKAHEAD(2)
 SolutionsRef()
|     {jjtThis.setAllSolutions(true); }
}

void GraphOrDefault() :
{}
{
    
|   [] IRIref()
}

void GraphRef() #void :
{}
{ 
     IRIref() 
}

// bigdata extension: either a GRAPH uri or a SOLUTIONS name.
//void GraphOrSolutionsRef() #void :
//{}
//{ 
//  (GraphRef()|SolutionsRef())
//}

// bigdata extension: A SOLUTIONS name (aka named solution set ref).
void SolutionsRef() :
{Token t;}
{
     t =  {jjtThis.setName(t.image);}  
}

void UnparsedQuadDataBlock() :
{}
{
     {jjtThis.setDataBlock(readToMatchingBrace()); } 
}

void QuadData() #void :
{}
{
     Quads()  
}

void Quads() #void :
{}
{
    [TriplesTemplate()] ( QuadsNotTriples() [] [TriplesTemplate()] )*
}

void QuadsNotTriples() :
{}
{
     VarOrIRIref()  [TriplesTemplate()] 
}

void Update() #void :
{}
{
    Load()
|   Clear()
|   Drop()
|   Add()
|   Move()
|   Copy()
|   Create()
|   DropEntailments()
|   CreateEntailments()
|   EnableEntailments()
|   DisableEntailments()
|   LOOKAHEAD(2) InsertData()
|   LOOKAHEAD(2) DeleteData() 
|   LOOKAHEAD(2) DeleteWhere()
|   LOOKAHEAD(2) Modify()
}

void Load() :
{Token t = null;}
{
//     [ {jjtThis.setSilent(true);} ] IRIref() [ GraphRef() ]
     
    (  {jjtThis.setSilent(true);}
    |           (t=|t=) {jjtThis.verifyData=Boolean.valueOf(t.image);}
    |    (t=|t=) {jjtThis.preserveBNodeIDs=Boolean.valueOf(t.image);}
    |   (t=|t=) {jjtThis.stopAtFirstError=Boolean.valueOf(t.image);}
    |     (t=|t=|t=) {jjtThis.datatypeHandling=DatatypeHandling.valueOf(t.image.toUpperCase());}
    )*
    IRIref()
    [  GraphRef() ]
}

void DropEntailments() :
{}
{
    
}

void CreateEntailments() :
{}
{
    
}

void EnableEntailments() :
{}
{
    
}

void DisableEntailments() :
{}
{
    
}

void Clear() :
{}
{
     [ {jjtThis.setSilent(true);} ] GraphRefAll()
}

void Drop() :
{}
{
     [ {jjtThis.setSilent(true);} ] GraphRefAll()
}

void Add() :
{}
{
     [ {jjtThis.setSilent(true);} ] GraphOrDefault()  GraphOrDefault()
}

void Move() :
{}
{
     [ {jjtThis.setSilent(true);} ] GraphOrDefault()  GraphOrDefault()
}

void Copy() :
{}
{
     [ {jjtThis.setSilent(true);} ] GraphOrDefault()  GraphOrDefault()
}

// bigdata extension: CREATE SOLUTIONS ...
void Create() :
{}
{
     [ {jjtThis.setSilent(true);} ]
     ( GraphRef()
//   | SolutionsRef() ( TriplesTemplate() )?
     | SolutionsRef() (QuadData())?
     )
}

void InsertData() :
{}
{
      UnparsedQuadDataBlock()
}

void DeleteData() :
{}
{
      UnparsedQuadDataBlock()
}

void DeleteWhere() :
{}
{
      QuadData()
}

void DeleteClause() :
{Token t;}
{
//     QuadData()
    
    (
       t =  Select() {jjtThis.setName(t.image);}    
    | QuadData()
    )
}

void InsertClause() :
{Token t;}
{
//     QuadData()
     ( t =  Select() {jjtThis.setName(t.image);}
     | QuadData())
}

void UsingClause() #DatasetClause :
{}
{
     [ {jjtThis.setNamed(true);}] IRIref()
}

void Modify() :
{}
{
    [ IRIref()] 
    ( DeleteClause() [InsertClause()] | InsertClause() ) (UsingClause())* 
     GroupGraphPattern()
}

/*
 * Extension for triple pattern references.
 */

void VarOrIRIrefOrIsA() #void :
{}
{
    VarOrIRIref()
| 
     { jjtThis.setValue(RDF.TYPE.toString()); } #IRI
}

// See VarOrTerm()
void VarOrTermOrTRefP() #void :
{}
{
    Var()
|
    GraphTerm()
|
    TRefPattern()
}

// Note: The subject position is constrained to not permit a literal.
void TRefPattern() :
{}
{
   VarOrTermOrTRefP() VarOrIRIrefOrIsA() VarOrTermOrTRefP() 
} 
    

    







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy