turtleparser.java

这是外国一个开源推理机

			if (c == '\\') {
				// This escapes the next character, which might be a '"'
				c = _reader.read();
				if (c == -1) {
					_throwEOFException();
				}
				label.append( (char)c );
			}

			c = _reader.read();
		}

		String labelStr = label.toString();

		// Unescape any escape sequences
		try {
			labelStr = TurtleUtil.unescapeString(labelStr);
		}
		catch (IllegalArgumentException e) {
			_throwParseException(e.getMessage());
		}

		// c == '"', read next char
		c = _peek();

		if (c == '@') {
			_reader.read();

			// Read language
			StringBuffer lang = new StringBuffer(8);

			c = _reader.read();
			if (c == -1) {
				_throwEOFException();
			}
			if (!TurtleUtil.isLanguageStartChar(c)) {
				_throwParseException("Expected a letter, found '" + (char)c + "'");
			}

			lang.append( (char)c );

			c = _reader.read();
			while (TurtleUtil.isLanguageChar(c)) {
				lang.append( (char)c );
				c = _reader.read();
			}

			_unread(c);

			return _createLiteral(labelStr, lang.toString(), null);
		}
		else if (c == '^') {
			_reader.read();

			// next character should be another '^'
			_verifyCharacter(_reader.read(), "^");

			// Read datatype
			URI datatype = _parseResource();
			return _createLiteral(labelStr, null, datatype);
		}
		else {
			return _createLiteral(labelStr, null, null);
		}
	}

	private Literal _parseInteger()
		throws IOException, ParseException
	{
		StringBuffer value = new StringBuffer(8);
		int c = _reader.read();
		while (ASCIIUtil.isNumber(c)) {
			value.append( (char)c );
			c = _reader.read();
		}

		_unread(c);

		// Normalize integer value
		String valueStr = value.toString();
		valueStr = XmlDatatypeUtil.normalize(valueStr, XmlSchema.INTEGER);

		// Return result as a typed literal
		URI xsdInteger = _createURI(XmlSchema.INTEGER);
		return _createLiteral(valueStr, null, xsdInteger);
	}

	private URI _parseResource()
		throws IOException, ParseException
	{
		int c = _peek();
		if (c == '<') {
			// uriref (e.g. <foo://bar>)
			return _parseUriRef();
		}
		else if (c == ':' || TurtleUtil.isPrefixStartChar(c)) {
			// qname (e.g. rdfs:Class or :foo)
			return _parseQName();
		}
		else if (c == -1) {
			_throwEOFException();
			return null;
		}
		else {
			_throwParseException("Expected '<', ':' or a letter, found '" + (char)c + "'");
			return null;
		}
	}

	private URI _parseUriRef()
		throws IOException, ParseException
	{
		// First character should be '<'
		int c = _reader.read();
		_verifyCharacter(c, "<");

		// Read up to the next '>' character
		StringBuffer uriRef = new StringBuffer(100);
		c = _reader.read();
		while (c != '>') {
			if (c == -1) {
				_throwEOFException();
			}
			uriRef.append( (char)c );
			c = _reader.read();
		}

		return _resolveURI( uriRef.toString() );
	}

	private URI _parseQName()
		throws IOException, ParseException
	{
		// First character should be a ':' or a letter
		int c = _reader.read();
		if (c == -1) {
			_throwEOFException();
		}
		if (c != ':' && !TurtleUtil.isPrefixStartChar(c)) {
			_throwParseException("Expected a ':' or a letter, found '" + (char)c + "'");
		}

		String namespace = null;

		if (c == ':') {
			// Use default namespace
			namespace = (String)_namespaceTable.get("");
			if (namespace == null) {
				_throwParseException("Default namespace used but not defined");
			}
		}
		else {
			// c is the first letter of the prefix
			StringBuffer prefix = new StringBuffer(8);
			prefix.append( (char)c);

			c = _reader.read();
			while (TurtleUtil.isPrefixChar(c)) {
				prefix.append( (char)c );
				c = _reader.read();
			}

			_verifyCharacter(c, ":");

			namespace = (String)_namespaceTable.get(prefix.toString());
			if (namespace == null) {
				_throwParseException("Namespace prefix '" + prefix.toString() + "' used but not defined");
			}
		}

		// c == ':', read optional local name
		StringBuffer localName = new StringBuffer(16);
		c = _reader.read();
		if (TurtleUtil.isNameStartChar(c)) {
			localName.append( (char)c );

			c = _reader.read();
			while (TurtleUtil.isNameChar(c)) {
				localName.append( (char)c );
				c = _reader.read();
			}
		}

		// Unread last character
		_unread(c);

		// Note: namespace has already been resolved
		return _createURI( namespace + localName.toString() );
	}

	private Resource _parseBlank()
		throws IOException, ParseException, StatementHandlerException
	{
		int c = _peek();

		if (c == '_') {
			return _parseNodeID();
		}
		else if (c == '[') {
			_reader.read();

			BNode bNode = _createBNode();

			c = _reader.read();
			if (c != ']') {
				// Remember current subject and predicate
				Resource oldSubject = _subject;
				URI oldPredicate = _predicate;

				// generated bNode becomes subject
				_subject = bNode;

				// Enter recursion with nested predicate-object list
				_skipWhitespace();
				_parsePredicateObjectList();
				_skipWhitespace();

				// Read closing bracket
				_verifyCharacter(_reader.read(), "]");

				// Restore previous subject and predicate
				_subject = oldSubject;
				_predicate = oldPredicate;
			}

			return bNode;
		}
		else if (c == '(') {
			return _parseItemList();
		}
		else {
			// Throw exception
			_verifyCharacter(c, "_[(");
			return null;
		}
	}

	private BNode _parseNodeID()
		throws IOException, ParseException
	{
		// Node ID should start with "_:"
		_verifyCharacter(_reader.read(), "_");
		_verifyCharacter(_reader.read(), ":");

		// Read the node ID
		int c = _reader.read();
		if (c == -1) {
			_throwEOFException();
		}
		else if (!TurtleUtil.isNameStartChar(c)) {
			_throwParseException("Expected a letter, found '" + (char)c + "'");
		}

		StringBuffer name = new StringBuffer(32);
		name.append( (char)c );

		// Read all following letter and numbers, they are part of the name
		c = _reader.read();
		while (TurtleUtil.isNameChar(c)) {
			name.append( (char)c );
			c = _reader.read();
		}

		_unread(c);

		return _createBNode( name.toString() );
	}

	private Resource _parseItemList()
		throws IOException, ParseException, StatementHandlerException
	{
		_verifyCharacter(_reader.read(), "(");
		_skipWhitespace();

		int c = _peek();

		if (c == ')') {
			// Empty list
			_reader.read();
			return _createURI(RDF.NIL);
		}
		else {
			BNode listRoot = _createBNode();

			// Remember current subject and predicate
			Resource oldSubject = _subject;
			URI oldPredicate = _predicate;

			// Create URIs for rdf:first and rdf:rest
			URI rdfFirst = _createURI(RDF.FIRST);
			URI rdfRest = _createURI(RDF.REST);
			URI rdfNil = _createURI(RDF.NIL);

			// generated bNode becomes subject, predicate becomes rdf:first
			_subject = listRoot;
			_predicate = rdfFirst;

			_parseObject();
			_skipWhitespace();

			BNode bNode = listRoot;
			c = _peek();

			while (c != ')') {
				// Create another list node and link it to the previous
				BNode newNode = _createBNode();
				_statementHandler.handleStatement(bNode, rdfRest, newNode);

				// New node becomes the current
				_subject = bNode = newNode;

				_parseObject();

				_skipWhitespace();
				c = _peek();
			}

			// Skip ')'
			_reader.read();

			// Close the list
			_statementHandler.handleStatement(bNode, rdfRest, rdfNil);

			// Restore previous subject and predicate
			_subject = oldSubject;
			_predicate = oldPredicate;

			return listRoot;
		}
	}

	private URI _resolveURI(String uri)
		throws ParseException
	{
		// Unescape any escape sequences
		try {
			uri = TurtleUtil.unescapeString(uri);
		}
		catch (IllegalArgumentException e) {
			_throwParseException(e.getMessage());
		}

		// Resolve relative URIs against base URI
		org.openrdf.util.uri.URI relUri = new org.openrdf.util.uri.URI(uri);

		if (_verifyData) {
			if (relUri.isRelative() && !relUri.isSelfReference() && // Relative URI that is not a self-reference
				_baseURI.isOpaque())
			{
				_throwParseException("Relative URI '" + uri +
						"' cannot be resolved using the opaque base URI '" + _baseURI + "'");
			}
		}

		uri = _baseURI.resolve(relUri).toString();

		return _createURI(uri);
	}

	private URI _createURI(String uri)
		throws ParseException
	{
		try {
			return _valFactory.createURI(uri);
		}
		catch (Exception e) {
			_throwParseException(e);
			return null;
		}
	}

	private BNode _createBNode()
		throws ParseException
	{
		try {
			return _valFactory.createBNode();
		}
		catch (Exception e) {
			_throwParseException(e);
			return null;
		}
	}

	private BNode _createBNode(String nodeID)
		throws ParseException
	{
		// Maybe the node ID has been used before:
		BNode result = (BNode)_bNodeIdMap.get(nodeID);

		if (result == null) {
			// This is a new node ID, create a new BNode object for it
			try {
				if (_preserveBNodeIds) {
					result = _valFactory.createBNode(nodeID);
				}
				else {
					result = _valFactory.createBNode();
				}
			}
			catch (Exception e) {
				_throwParseException(e);
			}

			// Remember it, the nodeID might occur again.
			_bNodeIdMap.put(nodeID, result);
		}

		return result;
	}

	private Literal _createLiteral(String label, String lang, URI datatype)
		throws ParseException
	{
		if (datatype != null) {
			if (_datatypeHandling == DT_VERIFY) {
				if (!XmlDatatypeUtil.isValidValue(label, datatype.getURI())) {
					_throwParseException("'" + label + "' is not a valid value for datatype " + datatype);
				}
			}
			else if (_datatypeHandling == DT_NORMALIZE) {
				try {
					label = XmlDatatypeUtil.normalize(label, datatype.getURI());
				}
				catch (IllegalArgumentException e) {
					_throwParseException("'" + label + "' is not a valid value for datatype " + datatype + ": " + e.getMessage());
				}
			}
		}

		try {
			if (datatype != null) {
				return _valFactory.createLiteral(label, datatype);
			}
			else if (lang != null) {
				return _valFactory.createLiteral(label, lang);
			}
			else {
				return _valFactory.createLiteral(label);
			}
		}
		catch (Exception e) {
			_throwParseException(e);
			return null;
		}
	}

	/**
	 * Verifies that the supplied character <tt>c</tt> is one of the expected
	 * characters specified in <tt>expected</tt>. This method will throw a
	 * <tt>ParseException</tt> if this is not the case.
	 **/
	private void _verifyCharacter(int c, String expected)
		throws ParseException
	{
		if (c == -1) {
			_throwEOFException();
		}
		else if (expected.indexOf((char)c) == -1) {
			StringBuffer msg = new StringBuffer(32);
			msg.append("Expected ");
			for (int i = 0; i < expected.length(); i++) {
				if (i > 0) {
					msg.append(" or ");
				}
				msg.append('\'');
				msg.append(expected.charAt(i));
				msg.append('\'');
			}
			msg.append(", found '");
			msg.append( (char)c );
			msg.append("'");

			_throwParseException(msg.toString());
		}
	}

	private int _peek()
		throws IOException
	{
		int result = _reader.read();
		_unread(result);
		return result;
	}

	private void _unread(int c)
		throws IOException
	{
		if (c != -1) {
			_reader.unread(c);
		}
	}

	private void _reportLocation() {
		if (_locListener != null) {
			_locListener.parseLocationUpdate(_lineReader.getLineNumber(), -1);
		}
	}

	private void _throwParseException(String msg)
		throws ParseException
	{
		if (_errListener != null) {
			_errListener.fatalError(msg, _lineReader.getLineNumber(), -1);
		}

		throw new ParseException(msg, _lineReader.getLineNumber(), -1);
	}

	private void _throwParseException(Exception e)
		throws ParseException
	{
		if (e instanceof ParseException) {
			throw (ParseException)e;
		}
		else {
			if (_errListener != null) {
				_errListener.fatalError(e.getMessage(), _lineReader.getLineNumber(), -1);
			}

			throw new ParseException(e, _lineReader.getLineNumber(), -1);
		}
	}

	private void _throwEOFException()
		throws ParseException
	{
		_throwParseException("Unexpected end of file");
	}
}