rql-parser.jj

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

/*  Sesame - Storage and Querying architecture for RDF and RDF Schema
 *  Copyright (C) 2001-2004 Aduna
 *
 *  Contact: 
 *  	Aduna
 *  	Prinses Julianaplein 14 b
 *  	3817 CS Amersfoort
 *  	The Netherlands
 *  	tel. [phone]
 *  	fax. [phone]
 *
 *  	http://aduna.biz/
 *  	http://www.openrdf.org/
 *  
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * RQL parser file for JavaCC, a Java Compiler Compiler. JavaCC can be
 * downloaded from https://javacc.dev.java.net/
 */

options {
	STATIC=false;
	IGNORE_CASE=true;
}


PARSER_BEGIN(RqlParser)

package org.openrdf.sesame.query.rql.parser;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.openrdf.sesame.query.rql.model.And;
import org.openrdf.sesame.query.rql.model.ArraySelection;
import org.openrdf.sesame.query.rql.model.BooleanConstant;
import org.openrdf.sesame.query.rql.model.BooleanQuery;
import org.openrdf.sesame.query.rql.model.ClassQuery;
import org.openrdf.sesame.query.rql.model.ClassSelector;
import org.openrdf.sesame.query.rql.model.ClassVar;
import org.openrdf.sesame.query.rql.model.CompareTo;
import org.openrdf.sesame.query.rql.model.Constant;
import org.openrdf.sesame.query.rql.model.DataPathSelector;
import org.openrdf.sesame.query.rql.model.DataQuery;
import org.openrdf.sesame.query.rql.model.DataVar;
import org.openrdf.sesame.query.rql.model.Domain;
import org.openrdf.sesame.query.rql.model.DomainSelector;
import org.openrdf.sesame.query.rql.model.Exists;
import org.openrdf.sesame.query.rql.model.Forall;
import org.openrdf.sesame.query.rql.model.In;
import org.openrdf.sesame.query.rql.model.InstanceOf;
import org.openrdf.sesame.query.rql.model.InstanceSelector;
import org.openrdf.sesame.query.rql.model.IntegerConstant;
import org.openrdf.sesame.query.rql.model.Intersect;
import org.openrdf.sesame.query.rql.model.Like;
import org.openrdf.sesame.query.rql.model.Minus;
import org.openrdf.sesame.query.rql.model.Not;
import org.openrdf.sesame.query.rql.model.Or;
import org.openrdf.sesame.query.rql.model.PropertyQuery;
import org.openrdf.sesame.query.rql.model.PropertySelector;
import org.openrdf.sesame.query.rql.model.PropertyVar;
import org.openrdf.sesame.query.rql.model.Query;
import org.openrdf.sesame.query.rql.model.Range;
import org.openrdf.sesame.query.rql.model.RangeSelector;
import org.openrdf.sesame.query.rql.model.RdfProperty;
import org.openrdf.sesame.query.rql.model.RdfsClass;
import org.openrdf.sesame.query.rql.model.RealConstant;
import org.openrdf.sesame.query.rql.model.ResourceQuery;
import org.openrdf.sesame.query.rql.model.SetQuery;
import org.openrdf.sesame.query.rql.model.SfwQuery;
import org.openrdf.sesame.query.rql.model.StringConstant;
import org.openrdf.sesame.query.rql.model.SubClassOf;
import org.openrdf.sesame.query.rql.model.SubPropertyOf;
import org.openrdf.sesame.query.rql.model.SuperClassOf;
import org.openrdf.sesame.query.rql.model.SuperPropertyOf;
import org.openrdf.sesame.query.rql.model.TypeOf;
import org.openrdf.sesame.query.rql.model.URI;
import org.openrdf.sesame.query.rql.model.Union;
import org.openrdf.sesame.query.rql.model.UnknownSelector;
import org.openrdf.sesame.query.rql.model.Var;

public class RqlParser {

	protected Map _varMap = new HashMap();
	protected List _varList = new ArrayList();
	protected List _unboundVarList = new ArrayList();

	public Var getSharedVar(String name) {
		Var result = (Var)_varMap.get(name);
		if (result == null) {
			// Create a new Var
			if (name.startsWith("$")) {
//System.out.println("Creating new ClassVar: " + name);
				result = new ClassVar(name);
			}
			else if (name.startsWith("@")) {
//System.out.println("Creating new PropertyVar: " + name);
				result = new PropertyVar(name);
			}
			else {
//System.out.println("Creating new DataVar: " + name);
				result = new DataVar(name);
			}
			_varMap.put(name, result);
			_varList.add(result);
			_unboundVarList.add(result);
		}
		return result;
	}

	public List getVarList() {
		return _varList;
	}

	public void clearVars() {
		_varMap.clear();
		_varList = new ArrayList();
	}

	private int _varNo = 1;
	public String getAnonymousVarName() {
		return "_" + _varNo++;
	}

	/** namespaces **/
	protected Map _nsMap = new HashMap();

	public void addNamespace(String prefix, String namespace) {
		_nsMap.put(prefix, namespace);
	}

	public String getNamespace(String prefix) {
		return (String)_nsMap.get(prefix);
	}

	// non-public "struct"
	static class FromTo {
		DataVar dataVar;
		ClassQuery classQ;
	}

} // end class RqlParser

PARSER_END(RqlParser)


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


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

TOKEN : /* SPECIAL CHARS */
{
	<AMP: "&">
|	<LPAREN: "(">
|	<RPAREN: ")">
|	<LBRACE: "{">
|	<RBRACE: "}">
|	<LBRACKET: "[">
|	<RBRACKET: "]">
|	<ASTERISK: "*">
|	<COMMA: ",">
|	<DOT: ".">
|	<COLON: ":">
|	<QUOTE: "'">
|	<DOUBLEQUOTE: "\"">
|	<CIRCUMFLEX: "^">
}

TOKEN : // keywords
{
	<SELECT: "select">
|	<FROM: "from">
|	<WHERE: "where">
|	<USING: "using">
|	<NAMESPACE: "namespace">
|	<CLASS: "Class">
|	<PROPERTY: "Property">
|	<TYPEOF: "typeOf">
|	<SUBCLASSOF: "subClassOf">
|	<SUPERCLASSOF: "superClassOf">
|	<SUBPROPERTYOF: "subPropertyOf">
|	<SUPERPROPERTYOF: "superPropertyOf">
|	<DOMAIN: "domain">
|	<RANGE: "range">
|	<TRUE: "true">
|	<FALSE: "false">
|	<AND: "and">
|	<OR: "or">
|	<NOT: "not">
|	<LIKE: "like">
|	<EXISTS: "exists">
|	<FORALL: "forall">
|	<IN: "in">
|	<UNION: "union">
|	<INTERSECT: "intersect">
|	<MINUS: "minus">
|	<NULL: "null">
}

TOKEN:
{
	<IDENTIFIER: (<ALPHA>|"_") (<ALPHA>|<DIGIT>|"-"|"_"|".")*>
|	<CLASSVAR: "$" <IDENTIFIER>>
|	<PROPERTYVAR: "@" <IDENTIFIER>>
|	<INTEGER_LITERAL: (<DIGIT>)+>
|	<REAL_LITERAL: (<DIGIT>)* "." (<DIGIT>)+>
|	<QUOTED_STRING: "\"" (~["\""])* "\"">
|	<QUOTED_CHAR: "'" (~["'"]) "'">
|	<#ALPHA: ["a"-"z", "A"-"Z"]>
|	<#DIGIT: ["0"-"9"]>
}

// See RFC2396 : http://www.ietf.org/rfc/rfc2396.txt
// FIXME: non-ascii chars not supported yet
TOKEN : // URI
{
	<URI: <SCHEME> ":" (<UCHAR>|<RESERVED>)* ("#" (<FRAGMENT>)?)?>
|	<#SCHEME: (<ALPHA>|<DIGIT>|"+"|"-"|".")+>
|	<#FRAGMENT: (<UCHAR>|<RESERVED>)+>
|	<#UCHAR: (<UNRESERVED>|<ESCAPE>)>
|	<#UNRESERVED: (<ALPHA>|<DIGIT>|<SAFE>|<EXTRA>)>
|	<#ESCAPE: "%" <HEX> <HEX>>
|	<#RESERVED: (";"|"/"|"?"|":"|"@"|"&"|"="|"+")>
|	<#EXTRA: ("!"|"*"|<QUOTE>|"("|")"|",")>
|	<#SAFE: ("$"|"-"|"_"|"."|"~")>
|	<#HEX: (["A"-"F", "a"-"f"] | <DIGIT>)>
}


Query parse() :
{
	Query q;

	// (re)set _varNo to '1'.
	_varNo = 1;
}
{
	{ clearVars(); }

	( <USING> <NAMESPACE> namespace() ("," namespace())* )?
	q = query() <EOF> 

	{ 
		if (_unboundVarList.size() > 0) {
			String msg = "Unbound variable(s): ";

			for (int i = 0; i < _unboundVarList.size(); i++) {
				Var var = (Var)_unboundVarList.get(i);
				if (i > 0) {
					msg += ", ";
				}
				msg += var.getName();
			}

			throw new ParseException(msg);
		}
		return q; 
	}
}

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

void namespace() :
{
	Token prefixToken, nsToken;
}
{
	prefixToken = <IDENTIFIER> "=" nsToken = <URI>

	{
		String prefix = prefixToken.image;
		String ns = nsToken.image;

		//FIXME: check if prefix isn't used twice?
		addNamespace(prefix, ns);
	}
}

/*-------------------------------------------------+
| QUERY                                            |
+-------------------------------------------------*/

Query query() :
{
	Query q;
}
{
	q = sfw_query() { return q; }
|	q = uri() { return q; }
|	q = data_query() { return q; }
|	q = class_query() { return q; }
|	q = property_query() { return q; }
|	q = set_query() { return q; }
/*
|	constant()
*/
}

/*-------------------------------------------------+
| VARIABLES                                        |
+-------------------------------------------------*/

Var var() :
{
	Var v;
}
{
	v = datavar()     {return v;}
|	v = classvar()    {return v;}
|	v = propertyvar() {return v;}
}

DataVar datavar() :
{
	Token t;
}
{
	t = <IDENTIFIER> {return (DataVar)getSharedVar(t.image);}
}

ClassVar classvar() :
{
	Token t;
}
{
	t = <CLASSVAR> {return (ClassVar)getSharedVar(t.image);}
}

PropertyVar propertyvar() :
{
	Token t;
}
{
	t = <PROPERTYVAR> {return (PropertyVar)getSharedVar(t.image);}
}

/*-------------------------------------------------+
| URI's                                            |
+-------------------------------------------------*/

URI uri() :
{
	Token t;
}
{
	t = <URI>
	
	{
		String uriString = t.image;

		int colonIdx = uriString.indexOf(':');
		if (colonIdx != -1) {
			String prefix = uriString.substring(0, colonIdx);
			String namespace = getNamespace(prefix);
			if (namespace != null) {
				uriString = namespace + uriString.substring(colonIdx + 1);
			}
		}

		return new URI(uriString);
	}
}


/*-------------------------------------------------+
| SFW QUERY                                        |
+-------------------------------------------------*/

ResourceQuery sfw_query() :
{
	List projsList = new ArrayList();
	List rangesList = new ArrayList();
	BooleanQuery where = null;
}
{
	<SELECT> projslist(projsList)
	<FROM>   rangeslist(rangesList)
	(
		<WHERE>  where = boolean_query()
	 )?
	{
		if (projsList.isEmpty()) {
			// select *
			projsList = getVarList();
		}
		return new SfwQuery(projsList, rangesList, where);
	}
}

void projslist(List projsList) :
{
	ResourceQuery q;
}
{
	<ASTERISK>
|
	q = projs_elem()   { projsList.add(q); }
	(
		<COMMA> q = projs_elem()   { projsList.add(q); }
	)*
}

ResourceQuery projs_elem() :
{
	ResourceQuery q;