serql.jj

来自「这是外国一个开源推理机」· JJ 代码 · 共 1,680 行 · 第 1/3 页

|

	<LBRACK>

		{
			optionalGP = new GraphPattern();

			// Create new variable scope
			VarTreeNode node = new VarTreeNode();
			_currentTreeNode.addChild(node);
			_currentTreeNode = node;
		}

	graph_pattern(optionalGP)

	<RBRACK>

		{
			graphPattern.addOptional(optionalGP);

			// Restore variable scope
			_currentTreeNode = _currentTreeNode.getParent();
		}
}

PathElement path_expr_head(GraphPattern graphPattern) :
{
	List leftNode, rightNode;
	Var edge;
}
{
	leftNode = node(graphPattern)
	edge = edge()
	rightNode = node(graphPattern)

		{
			PathElement pe = new PathElement(leftNode, edge, rightNode);
			graphPattern.addAll( pe.getTriplePatterns() );
			return pe;
		}
}

void path_expr_tail(List leftNode, GraphPattern graphPattern) :
{
	Var edge;
	List rightNode;
	PathElement pe;
	GraphPattern optionalGP;
	BooleanExpr where;
}
{
	edge = edge()
	rightNode = node(graphPattern)

		{
			pe = new PathElement(leftNode, edge, rightNode);
			graphPattern.addAll( pe.getTriplePatterns() );
		}

	(
		path_expr_tail(rightNode, graphPattern)
	|
		<SEMICOLON> path_expr_tail(leftNode, graphPattern)
	)?

|

	<LBRACK>
		{
			optionalGP = new GraphPattern();

			// Create new variable scope
			VarTreeNode node = new VarTreeNode();
			_currentTreeNode.addChild(node);
			_currentTreeNode = node;
		}

	edge = edge()
	rightNode = node(optionalGP)

		{
			pe = new PathElement(leftNode, edge, rightNode);
			optionalGP.addAll( pe.getTriplePatterns() );
		}

	(
		path_expr_tail(rightNode, optionalGP)
	|
		<SEMICOLON> path_expr_tail(leftNode, optionalGP)
	)?

	(
		<WHERE> where = boolean_expr()

		{
			optionalGP.addConstraint(where);
		}
	)?

	<RBRACK>

		{
			graphPattern.addOptional(optionalGP);

			// Restore variable scope
			_currentTreeNode = _currentTreeNode.getParent();
		}

	(
		<SEMICOLON> path_expr_tail(leftNode, graphPattern)
	)?
}

Var edge() :
{
	Var var;
	ResourceExpr uri;
}
{
	var = var()

		{
			// Variables in edges are bound:
			_unboundVars.remove(var);

			return var;
		}
|
	uri = uri()

		{
			var = _createAnonymousVar();
			var.setValue(uri.getValue());
			return var;
		}
}

// Returns a list of Var objects
List node(GraphPattern graphPattern) :
{
	Var var;
	List nodeElements = new ArrayList(4);
}
{
	<LBRACE>
	(
		var = node_elem(graphPattern)  { nodeElements.add(var); }

		(
			<COMMA> var = node_elem(graphPattern)  { nodeElements.add(var); }
		)*
	)?
	<RBRACE>

		{
			// If no expressions specified, then create an anonymous variable.
			if (nodeElements.isEmpty()) {
				nodeElements.add( _createAnonymousVar() );
			}

			// Create any implicit unequalities
			for (int i = 0; i < nodeElements.size() - 1; i++) {
				Var var1 = (Var)nodeElements.get(i);

				for (int j = i + 1; j < nodeElements.size(); j++) {
					Var var2 = (Var)nodeElements.get(j);

					// At least one of the variables should be unlocked
					// for the unequality to make any sense:
					if (!var1.hasValue() || !var2.hasValue()) {
						graphPattern.addConstraint(
								new ValueCompare(var1, var2, ValueCompare.NE));
					}
				}
			}

			return nodeElements;
		}
}

Var node_elem(GraphPattern graphPattern) :
{
	Var var;
	ValueExpr valueExpr;
}
{
	var = var()

		{
			// Variables in nodes are bound:
			_unboundVars.remove(var);

			return var;
		}
|
	valueExpr = uri_bnode_or_literal()

		{
			var = _createAnonymousVar();
			var.setValue(valueExpr.getValue());
			return var;
		}
|
	var = reified_stat(graphPattern)

		{
			return var;
		}
}

Var reified_stat(GraphPattern graphPattern) :
{
	List leftNode, rightNode;
	Var edge;
}
{
	leftNode = node(graphPattern)
	edge = edge()
	rightNode = node(graphPattern)

		{
			Var id = _createAnonymousVar();
			ReifiedPathElement reifiedPE = new ReifiedPathElement(id, leftNode, edge, rightNode);
			graphPattern.addAll(reifiedPE.getTriplePatterns());
			return id;
		}
}

BooleanExpr boolean_expr() :
{
	BooleanExpr result, rightExpr;
}
{
	result = and_expr()

	(
		<OR> rightExpr = boolean_expr()
			{
				result = new Or(result, rightExpr);
			}
	)?

		{
			return result;
		}
}

BooleanExpr and_expr() :
{
	BooleanExpr result, rightExpr;
}
{
	result = boolean_elem()

	(
		<AND> rightExpr = and_expr()
			{
				result = new And(result, rightExpr);
			}
	)?

		{
			return result;
		}
}

BooleanExpr boolean_elem() :
{
	BooleanExpr expr;
	Query	qc;
	Var var;
}
{
	<LPAREN> expr = boolean_expr() <RPAREN>    { return expr; }
|
	<TRUE>                                     { return BooleanConstant.TRUE; }
|
	<FALSE>                                    { return BooleanConstant.FALSE; }
|
	<NOT> expr = boolean_elem()                { return new Not(expr); }
|
	expr = any_all_like_or_in()                { return expr; }
|
	<ISRESOURCE> <LPAREN> var = var() <RPAREN> { return new IsResource(var); }
|
	<ISLITERAL> <LPAREN> var = var() <RPAREN>  { return new IsLiteral(var); }
|
	<ISURI> <LPAREN> var = var() <RPAREN>      { return new IsURI(var); }
|
	<ISBNODE> <LPAREN> var = var() <RPAREN>    { return new IsBNode(var); }
|
	<EXISTS> <LPAREN> qc = table_query_set() <RPAREN> { return new Exists(qc); }
}

BooleanExpr any_all_like_or_in() :
{
	ValueExpr leftValue, rightValue;
	Query qc;
	int op;
	String pattern;
	boolean ignoreCase = false;
}
{
	leftValue = var_or_value()

	(
		op = comp_op()
		(
			rightValue = var_or_value()
				{
					return new ValueCompare(leftValue, rightValue, op);
				}
		|
			<ANY> <LPAREN> qc = table_query_set() <RPAREN>
				{
					return new CompareAny(leftValue, qc, op);
				}
		|
			<ALL> <LPAREN> qc = table_query_set() <RPAREN>
				{
					return new CompareAll(leftValue, qc, op);
				}
		)
	|
		<LIKE> pattern = string()
		( <IGNORE> <CASE> {ignoreCase = true;} )?

			{
				return new Like(leftValue, new StringConstant(pattern), ignoreCase);
			}
	|
		<IN> <LPAREN> qc = table_query_set() <RPAREN>

			{
				if (qc.getColumnHeaders().length != 1) {
					throw new ParseException("Query argument for IN operator must have exactly one column.");
				}

				return new In(leftValue, qc);
			}
	)
}

int comp_op() :
{
}
{
	<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 var_or_value() :
{
	ValueExpr expr;
}
{
	expr = var() { return expr; }
|
	expr = value() { return expr; }
}

ValueExpr uri_bnode_or_literal() :
{
	ValueExpr expr;
}
{
	expr = uri()     { return expr; }
|
	expr = bnode()   { return expr; }
|
	expr = literal() { return expr; }
}

Var var():
{
	String varName;
}
{
	varName = nc_name()

	{
		return _getSharedVar(varName);
	}
}

ValueExpr value():
{
	ValueExpr expr;
	Var var;
}
{
	expr = uri()                              { return expr; }
|
	expr = bnode()                            { return expr; }
|
	expr = literal()                          { return expr; }
|
	expr = _null()                            { return expr; }
|
	<DATATYPE> <LPAREN> var = var() <RPAREN>  { return new Datatype(var); }
|
	<LANG> <LPAREN> var = var() <RPAREN>      { return new Lang(var); }
|
	<LABEL> <LPAREN> var = var() <RPAREN>     { return new Label(var); }
|
	<NAMESPACE> <LPAREN> var = var() <RPAREN> { return new Namespace(var); }
|
	<LOCALNAME> <LPAREN> var = var() <RPAREN> { return new LocalName(var); }
}

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

ResourceExpr full_uri():
{
	Token uriToken;
}
{
	uriToken = <FULL_URI>

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

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

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

ResourceExpr bnode() :
{
	Token bnodeToken;
}
{
	bnodeToken = <BNODE>

	{
		return new ResourceExpr( _parseBNode(bnodeToken.image) );
	}
}

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

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

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

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

		{
			return new LiteralExpr( new LiteralImpl(
					XmlDatatypeUtil.normalizeDecimal(token.image),
					XSD_DECIMAL) );
		}
}

String nc_name():
{
	Token token;
}
{
	token = <PREFIX_NAME> { return token.image; }
|
	token = <UNDERSCORE> { return token.image; }
}

String string() :
{
	Token token;
}
{
	try {
		token = <LITERAL>
	}
	catch (ParseException e) {
		// thrown exception reports that a <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 <LITERAL>: " + literal.toString());
			}

			return literal.getLabel();
		}
}

int pos_integer() :
{
	Token token;
}
{
	token = <POS_INTEGER>

		{
			try {
				return Integer.parseInt( token.image );
			}
			catch (NumberFormatException e) {
				// Should never happen: tokenizer enforces that token contains a valid integer
				throw new RuntimeException(e);
			}
		}
}

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