rdql-parser.jj

这是外国一个开源推理机

	  | ["\u0ED0"-"\u0ED9"] | ["\u0F20"-"\u0F29"]>
|	<#EXTENDER:
		"\u00B7" | "\u02D0" | "\u02D1" | "\u0387" | "\u0640" | "\u0E46" | "\u0EC6" | "\u3005" | ["\u3031"-"\u3035"]
	  | ["\u309D"-"\u309E"] | ["\u30FC"-"\u30FE"]>
}

TOKEN :
{
	<INTEGER_LITERAL: (<NUM>)+>
|	<FLOATING_POINT_LITERAL: (<NUM>)* "." (<NUM>)+ ("e" ("+"|"-")? (<NUM>)+)?>
}

TableQuery parseQuery() :
{
	Query qc;
}
{
	(
		prefixes_clause()
	)?

	qc = select_query() <EOF>

		{
			return new TableQuery(qc);
		}
}

void comma_opt() :
{}
{
	(<COMMA>)?
}

/*-------------------------------+
| NAMESPACE DECLARATIONS         |
+-------------------------------*/

void prefixes_clause() :
{}
{
	<PREFIXES> prefix_decl()
	(
		comma_opt() prefix_decl()
	)*
}

void prefix_decl() :
{
	Token prefixToken;
	ResourceExpr uri;
}
{
	prefixToken = <NCNAME> <FOR> uri = quoted_uri()

		{
			String prefix = prefixToken.image;
			_setNamespacePrefix(prefix, uri.getString());
		}
}

Query select_query() :
{
	List projection;
	GraphPattern graphPattern = new GraphPattern();
}
{
	<SELECT> projection = projection()

	( (<SOURCE>|<FROM>) <QUOTED_URI> ( comma_opt() <QUOTED_URI> )* )?

	<WHERE> triple_pattern_clause(graphPattern)

	( <SUCHTHAT> constraint_clause(graphPattern) )?

		{
			if (projection == null) {
				// "SELECT *", take all shared variables
				projection = new ArrayList(_sharedVars.size());
				for (int i = 0; i < _sharedVars.size(); i++) {
					Var var = (Var)_sharedVars.get(i);
					projection.add( new ProjectionElem(var, null) );
				}
			}

			if (projection.isEmpty()) {
				throw new ParseException("Select clause does not contain any variables.");
			}

			return new SelectQuery(projection, graphPattern);
		}
}

List projection() :
{
	Var var;
	List projection;
}
{
	<STAR> { return null; }
|
	{ projection = new ArrayList(16); }

	var = var()  { projection.add( new ProjectionElem(var) ); }

	(
		comma_opt() var = var()  { projection.add( new ProjectionElem(var) ); }
	)*

		{
			return projection;
		}
}

ProjectionElem projection_elem() :
{
	Var var;
}
{
	var = var()

	{
		return new ProjectionElem(var);
	}
}

void triple_pattern_clause(GraphPattern graphPattern) :
{
}
{
	triple_pattern(graphPattern)

	(
		comma_opt() triple_pattern(graphPattern)
	)*
}

void triple_pattern(GraphPattern graphPattern) :
{
	ValueExpr subject, predicate, object;
	Var subjectVar, predicateVar, objectVar;
}
{
	<LPAREN>
	subject = var_or_uri()
	comma_opt()
	predicate = var_or_uri()
	comma_opt()
	object = var_or_const()
	<RPAREN>

		{
			if (subject instanceof Var) {
				subjectVar = (Var)subject;
			}
			else {
				subjectVar = _createAnonymousVar();
				subjectVar.setValue( subject.getValue() );
			}

			if (predicate instanceof Var) {
				predicateVar = (Var)predicate;
			}
			else {
				predicateVar = _createAnonymousVar();
				predicateVar.setValue( predicate.getValue() );
			}

			if (object instanceof Var) {
				objectVar = (Var)object;
			}
			else {
				objectVar = _createAnonymousVar();
				objectVar.setValue( object.getValue() );
			}

			graphPattern.add( new TriplePattern(subjectVar, predicateVar, objectVar) );
		}
}

void constraint_clause(GraphPattern graphPattern) :
{
	BooleanExpr boolExpr;
}
{
	boolExpr = boolean_expr() { graphPattern.addConstraint(boolExpr); }
	
	(
		( <COMMA> | <SUCHTHAT> )
		boolExpr = boolean_expr() { graphPattern.addConstraint(boolExpr); }
	)*
}

BooleanExpr boolean_expr() :
{
	BooleanExpr result, tmpExpr;
}
{
	result = conditional_and_expr()

	(
		<SC_OR> tmpExpr = conditional_and_expr()
			{
				result = new Or(result, tmpExpr);
			}
	)*

		{
			return result;
		}
}

BooleanExpr conditional_and_expr() :
{
	BooleanExpr result, tmpExpr;
}
{
	result = boolean_elem()

	(
		<SC_AND> tmpExpr = boolean_elem()
			{
				result = new And(result, tmpExpr);
			}
	)*

		{
			return result;
		}
}

BooleanExpr boolean_elem() :
{
	ValueExpr leftValue, rightValue;
	BooleanExpr expr;
	int op;
	String pattern;
}
{
	<TRUE>

	{
		return BooleanConstant.TRUE;
	}
|
	<FALSE>
	
	{
		return BooleanConstant.FALSE;
	}
|
	// FIXME: theoretically required lookahead for LL-parsers to parse
	// parenthesis is infinite, investigate use of LALR-parser instead
	LOOKAHEAD(5)
	<LPAREN> expr = boolean_expr() <RPAREN>
	
	{
		return expr;
	}
|
	<NOT> expr = boolean_elem()

	{
		return new Not(expr);
	}
|
	leftValue = value_expr()

	(
		op = string_compare_operator()
		rightValue = value_expr()

			{
				return new StringCompare(leftValue, rightValue, op);
			}
	|
		op = value_compare_operator()
		rightValue = value_expr()

			{
				return new ValueCompare(leftValue, rightValue, op);
			}
	|
		<STR_MATCH> pattern = string()

			{
				return new Like(leftValue, new StringConstant(pattern), true);
			}
	|
		<STR_NMATCH> pattern = string()

			{
				return new Not( new Like(leftValue, new StringConstant(pattern), true) );
			}
	)
}

int string_compare_operator() :
{}
{
	<STR_EQ> { return StringCompare.EQ; }
|	<STR_NE> { return StringCompare.NE; }
}

int value_compare_operator() :
{}
{
	<EQ> { return ValueCompare.EQ; }
|	<NE> { return ValueCompare.NE; }
|	<LT> { return ValueCompare.LT; }
|	<LE> { return ValueCompare.LE; }
|	<GE> { return ValueCompare.GE; }
|	<GT> { return ValueCompare.GT; }
}

ValueExpr value_expr() :
{
	ValueExpr result;
}
{
	result = additive_expr()

	{
		return result;
	}
}

ValueExpr additive_expr() :
{
	ValueExpr result, tmpExpr;
	int op;
}
{
	result = multiplicative_expr()

	(
		op = additive_operator()
		tmpExpr = multiplicative_expr()

		{
			result = new MathExpr(result, tmpExpr, op);
		}
	)*

	{
		return result;
	}
}

int additive_operator() :
{}
{
	<PLUS>  { return MathExpr.PLUS; }
|	<MINUS> { return MathExpr.SUBTRACT; }
}

ValueExpr multiplicative_expr() :
{
	ValueExpr result, tmpExpr;
	int op;
}
{
	result = unary_expr()

	(
		op = multiplicative_operator()
		tmpExpr = unary_expr()

		{
			result = new MathExpr(result, tmpExpr, op);
		}
	)*

	{
		return result;
	}
}

int multiplicative_operator() :
{}
{
	<STAR>  { return MathExpr.MULTIPLY; }
|	<SLASH> { return MathExpr.DIVIDE; }
|	<REM>   { return MathExpr.REMAINDER; }
}

ValueExpr unary_expr() :
{
	ValueExpr result;
}
{
	result = var_or_const()

	{
		return result;
	}
|
	<PLUS> result = unary_expr()

	{
		return result;
	}
|
	<MINUS> result = unary_expr()

	{
		// Multiply by -1
		return new MathExpr(
				new LiteralExpr( new LiteralImpl("-1", XSD_INTEGER) ), // -1
				result, MathExpr.MULTIPLY);
	}
|
	<LPAREN> result = unary_expr() <RPAREN>

	{
		return result;
	}
}

ValueExpr var_or_uri() :
{
	ValueExpr result;
}
{
	result = var() { return result; }
|	result = uri() { return result; }
}

ValueExpr var_or_const() :
{
	ValueExpr result;
}
{
	result = var()     { return result; }
|	result = value()   { return result; }
}

Var var():
{
	Token varToken;
}
{
	varToken = <VAR>

	{
		String varName = varToken.image.substring(1);
		return _getSharedVar(varName);
	}
}

ValueExpr value():
{
	ValueExpr result;
	Var var;
}
{
	result = uri()     { return result; }
|	result = literal() { return result; }
|	result = _null()   { return result; }
}

ResourceExpr uri():
{
	ResourceExpr expr;
}
{
	expr = quoted_uri() { return expr; }
|
	expr = qname() { return expr; }
}

ResourceExpr quoted_uri():
{
	Token uriToken;
}
{
	uriToken = <QUOTED_URI>

	{
		URI uri = _parseQuotedURI(uriToken.image);
		return new ResourceExpr(uri);
	}
}

ResourceExpr qname() :
{
	Token uriToken;
}
{
	uriToken = <QNAME>

	{
		URI uri = _parseQName(uriToken.image);
		return new ResourceExpr(uri);
	}
}

LiteralExpr literal() :
{
	Token token;
}
{
	token = <TEXT_LITERAL>

		{
			return new LiteralExpr( _parseLiteral(token.image) );
		}
|
	token = <INTEGER_LITERAL>

		{
			return new LiteralExpr( new LiteralImpl(
					XmlDatatypeUtil.normalizeInteger(token.image),
					XSD_INTEGER) );
					
		}
|
	token = <FLOATING_POINT_LITERAL>

		{
			return new LiteralExpr( new LiteralImpl(
					XmlDatatypeUtil.normalizeFloat(token.image),
					XSD_FLOAT) );
		}
}

String string() :
{
	Token token;
}
{
	try {
		token = <TEXT_LITERAL>
	}
	catch (ParseException e) {
		// thrown exception reports that a <TEXT_LITERAL> is
		// expected, but we actually mean a <STRING>
		throw _createParseException(e.currentToken, new String[]{"<STRING>"});
	}

		{
			Literal literal = _parseLiteral(token.image);

			if (literal.getLanguage() != null || literal.getDatatype() != null) {
				// Not a plain literal that can be qualified as a string
				throw new ParseException("Expected <STRING>, found <TEXT_LITERAL>: " + literal.toString());
			}

			return literal.getLabel();
		}
}

Null _null() :
{}
{
	<NULL> { return new Null(); }
}