private void TryParseLineTerminator(TokenisingParserContext context)
{
IToken next = context.Tokens.Dequeue();
//Discard Comments
while (next.TokenType == Token.COMMENT)
{
next = context.Tokens.Dequeue();
}
//Ensure we finish with a Dot terminator
if (next.TokenType != Token.DOT)
{
throw Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, expected a Dot Line Terminator to terminate a Triple", next);
}
}
private INode TryParsePredicate(TokenisingParserContext context)
{
IToken predToken = context.Tokens.Dequeue();
//Discard Comments
while (predToken.TokenType == Token.COMMENT)
{
predToken = context.Tokens.Dequeue();
}
switch (predToken.TokenType)
{
case Token.BLANKNODE:
case Token.BLANKNODEWITHID:
throw Error("Predicate cannot be a Blank Node in NTriples", predToken);
case Token.URI:
return context.Handler.CreateUriNode(new Uri(predToken.Value));
//return this.ConvertToNode(g, predToken);
case Token.LITERAL:
case Token.LITERALWITHDT:
case Token.LITERALWITHLANG:
throw Error("Predicate cannot be a Literal in NTriples", predToken);
default:
throw Error("Unexpected Token '" + predToken.GetType().ToString() + "' encountered, expected a URI for the Predicate of a Triple", predToken);
}
}
private INode TryParseObject(TokenisingParserContext context)
{
IToken objToken = context.Tokens.Dequeue();
String dt;
//Discard Comments
while (objToken.TokenType == Token.COMMENT)
{
objToken = context.Tokens.Dequeue();
}
switch (objToken.TokenType)
{
case Token.BLANKNODE:
return context.Handler.CreateBlankNode();
case Token.BLANKNODEWITHID:
return context.Handler.CreateBlankNode(objToken.Value.Substring(2));
case Token.URI:
return context.Handler.CreateUriNode(new Uri(objToken.Value));
case Token.LITERALWITHDT:
dt = ((LiteralWithDataTypeToken)objToken).DataType;
dt = dt.Substring(1,dt.Length-2);
return context.Handler.CreateLiteralNode(objToken.Value, new Uri(dt));
case Token.LITERALWITHLANG:
return context.Handler.CreateLiteralNode(objToken.Value, ((LiteralWithLanguageSpecifierToken)objToken).Language);
case Token.LITERAL:
IToken next = context.Tokens.Peek();
//Is there a Language Specifier or Data Type?
if (next.TokenType == Token.LANGSPEC)
{
context.Tokens.Dequeue();
return context.Handler.CreateLiteralNode(objToken.Value, next.Value);
}
else if (next.TokenType == Token.URI)
{
context.Tokens.Dequeue();
return context.Handler.CreateLiteralNode(objToken.Value, new Uri(Tools.ResolveUriOrQName(next, context.Namespaces, context.BaseUri)));
}
else
{
return context.Handler.CreateLiteralNode(objToken.Value);
}
default:
throw Error("Unexpected Token '" + objToken.GetType().ToString() + "' encountered, expected a Blank Node, Literal or URI for the Object of a Triple", objToken);
}
}
private void TryParseTriple(TokenisingParserContext context)
{
//Get the Subject, Predicate and Object
INode subj = this.TryParseSubject(context);
INode pred = this.TryParsePredicate(context);
INode obj = this.TryParseObject(context);
//Ensure we're terminated by a DOT
this.TryParseLineTerminator(context);
//Assert the Triple
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
}
private INode TryParseSubject(TokenisingParserContext context)
{
IToken subjToken = context.Tokens.Dequeue();
//Discard Comments
while (subjToken.TokenType == Token.COMMENT)
{
subjToken = context.Tokens.Dequeue();
}
switch (subjToken.TokenType)
{
case Token.BLANKNODE:
return context.Handler.CreateBlankNode();
case Token.BLANKNODEWITHID:
return context.Handler.CreateBlankNode(subjToken.Value.Substring(2));
case Token.URI:
return context.Handler.CreateUriNode(new Uri(subjToken.Value));
case Token.LITERAL:
case Token.LITERALWITHDT:
case Token.LITERALWITHLANG:
throw Error("Subject cannot be a Literal in NTriples", subjToken);
default:
throw Error("Unexpected Token '" + subjToken.GetType().ToString() + "' encountered, expected a Blank Node or URI for the Subject of a Triple", subjToken);
}
}
/// <summary>
/// Parses NTriples Syntax from the given Input using a RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="input">Input to read input from</param>
public void Load(IRdfHandler handler, TextReader input)
{
if (handler == null) throw new RdfParseException("Cannot read RDF into a null RDF Handler");
if (input == null) throw new RdfParseException("Cannot read RDF from a null TextReader");
try
{
TokenisingParserContext context = new TokenisingParserContext(handler, new NTriplesTokeniser(input), this._queuemode, this._traceparsing, this._tracetokeniser);
this.Parse(context);
}
catch
{
throw;
}
finally
{
try
{
input.Close();
}
catch
{
//Catch is just here in case something goes wrong with closing the stream
//This error can be ignored
}
}
}
private void Parse(TokenisingParserContext context)
{
try
{
context.Handler.StartRdf();
//Initialise the Buffer
context.Tokens.InitialiseBuffer(10);
//Expect a BOF
IToken start = context.Tokens.Dequeue();
if (start.TokenType != Token.BOF)
{
throw Error("Unexpected Token '" + start.GetType().ToString() + "' encountered, expected a Beginning of File Token", start);
}
//Expect Triples
IToken next = context.Tokens.Peek();
while (next.TokenType != Token.EOF)
{
//Discard Comments
while (next.TokenType == Token.COMMENT)
{
context.Tokens.Dequeue();
next = context.Tokens.Peek();
}
if (next.TokenType == Token.EOF) break;
this.TryParseTriple(context);
next = context.Tokens.Peek();
}
context.Handler.EndRdf(true);
}
catch (RdfParsingTerminatedException)
{
context.Handler.EndRdf(true);
//Discard this - it justs means the Handler told us to stop
}
catch (RdfParseException)
{
//We hit some Parsing error
context.Handler.EndRdf(false);
throw;
}
}
/// <summary>
/// Tries to parse Collections
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="firstSubj">Blank Node which is the head of the collection</param>
private void TryParseCollection(TokenisingParserContext context, INode firstSubj)
{
//The opening bracket of the collection will already have been discarded when we get called
IToken next;
INode subj = firstSubj;
INode obj = null, nextSubj;
INode rdfFirst = context.Handler.CreateUriNode(new Uri(RdfSpecsHelper.RdfListFirst));
INode rdfRest = context.Handler.CreateUriNode(new Uri(RdfSpecsHelper.RdfListRest));
INode rdfNil = context.Handler.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil));
do
{
next = context.Tokens.Dequeue();
if (context.TraceParsing)
{
Console.WriteLine("Trying to parse a Collection item from Token '" + next.GetType().ToString() + "'");
}
switch (next.TokenType)
{
case Token.BLANKNODE:
obj = context.Handler.CreateBlankNode();
break;
case Token.BLANKNODEWITHID:
obj = context.Handler.CreateBlankNode(next.Value.Substring(2));
break;
case Token.COMMENT:
//Discard and continue
continue;
case Token.LEFTBRACKET:
//Start of a collection so create a new Blank Node to be it's first subject
next = context.Tokens.Peek();
if (next.TokenType == Token.RIGHTBRACKET)
{
//Empty Collection => rdf:nil
context.Tokens.Dequeue();
obj = context.Handler.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil));
}
else
{
obj = context.Handler.CreateBlankNode();
this.TryParseCollection(context, obj);
}
break;
case Token.LEFTSQBRACKET:
//Allowed Blank Node Collections as part of a Collection
IToken temp = context.Tokens.Peek();
if (temp.TokenType == Token.RIGHTSQBRACKET)
{
//Anonymous Blank Node
context.Tokens.Dequeue();
obj = context.Handler.CreateBlankNode();
}
else
{
//Blank Node Collection
obj = context.Handler.CreateBlankNode();
this.TryParsePredicateObjectList(context, obj, true);
}
break;
case Token.LITERAL:
case Token.LITERALWITHDT:
case Token.LITERALWITHLANG:
case Token.LONGLITERAL:
case Token.PLAINLITERAL:
obj = this.TryParseLiteral(context, next);
break;
case Token.QNAME:
case Token.URI:
obj = ParserHelper.TryResolveUri(context, next);
break;
case Token.RIGHTBRACKET:
//We might terminate here if someone put a comment before the end of the Collection
if (!context.Handler.HandleTriple(new Triple(subj, rdfFirst, obj))) ParserHelper.Stop();
if (!context.Handler.HandleTriple(new Triple(subj, rdfRest, rdfNil))) ParserHelper.Stop();
return;
default:
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered while trying to parse a Collection", next);
}
//Assert the relevant Triples
if (!context.Handler.HandleTriple(new Triple(subj, rdfFirst, obj))) ParserHelper.Stop();
if (context.Tokens.Peek().TokenType == Token.RIGHTBRACKET)
{
//End of the Collection
context.Tokens.Dequeue();
if (!context.Handler.HandleTriple(new Triple(subj, rdfRest, rdfNil))) ParserHelper.Stop();
return;
}
else
{
//More stuff in the collection
nextSubj = context.Handler.CreateBlankNode();
if (!context.Handler.HandleTriple(new Triple(subj, rdfRest, nextSubj))) ParserHelper.Stop();
subj = nextSubj;
}
} while (true);
}
/// <summary>
/// Tries to parse Literal Tokens into Literal Nodes
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="lit">Literal Token</param>
/// <returns></returns>
private INode TryParseLiteral(TokenisingParserContext context, IToken lit)
{
IToken next;
String dturi;
switch (lit.TokenType)
{
case Token.LITERAL:
case Token.LONGLITERAL:
next = context.Tokens.Peek();
if (next.TokenType == Token.LANGSPEC)
{
//Has a Language Specifier
next = context.Tokens.Dequeue();
return context.Handler.CreateLiteralNode(lit.Value, next.Value);
}
else if (next.TokenType == Token.DATATYPE)
{
//Has a Datatype
next = context.Tokens.Dequeue();
try
{
if (next.Value.StartsWith("<"))
{
dturi = next.Value.Substring(1, next.Value.Length - 2);
return context.Handler.CreateLiteralNode(lit.Value, new Uri(Tools.ResolveUri(dturi, context.BaseUri.ToSafeString())));
}
else
{
dturi = Tools.ResolveQName(next.Value, context.Namespaces, context.BaseUri);
return context.Handler.CreateLiteralNode(lit.Value, new Uri(dturi));
}
}
catch (RdfException rdfEx)
{
throw new RdfParseException("Unable to resolve the Datatype '" + next.Value + "' due to the following error:\n" + rdfEx.Message, next, rdfEx);
}
}
else
{
//Just an untyped Literal
return context.Handler.CreateLiteralNode(lit.Value);
}
case Token.LITERALWITHDT:
LiteralWithDataTypeToken litdt = (LiteralWithDataTypeToken)lit;
try
{
if (litdt.DataType.StartsWith("<"))
{
dturi = litdt.DataType.Substring(1, litdt.DataType.Length - 2);
return context.Handler.CreateLiteralNode(litdt.Value, new Uri(Tools.ResolveUri(dturi, context.BaseUri.ToSafeString())));
}
else
{
dturi = Tools.ResolveQName(litdt.DataType, context.Namespaces, context.BaseUri);
return context.Handler.CreateLiteralNode(litdt.Value, new Uri(dturi));
}
}
catch (RdfException rdfEx)
{
throw new RdfParseException("Unable to resolve the Datatype '" + litdt.DataType + "' due to the following error:\n" + rdfEx.Message, litdt, rdfEx);
}
case Token.LITERALWITHLANG:
LiteralWithLanguageSpecifierToken langlit = (LiteralWithLanguageSpecifierToken)lit;
return context.Handler.CreateLiteralNode(langlit.Value, langlit.Language);
case Token.PLAINLITERAL:
//Attempt to infer Type
if (TurtleSpecsHelper.IsValidPlainLiteral(lit.Value))
{
if (TurtleSpecsHelper.IsValidDouble(lit.Value))
{
return context.Handler.CreateLiteralNode(lit.Value, new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble));
}
else if (TurtleSpecsHelper.IsValidInteger(lit.Value))
{
return context.Handler.CreateLiteralNode(lit.Value, new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger));
}
else if (TurtleSpecsHelper.IsValidDecimal(lit.Value))
{
return context.Handler.CreateLiteralNode(lit.Value, new Uri(XmlSpecsHelper.XmlSchemaDataTypeDecimal));
}
else
{
return context.Handler.CreateLiteralNode(lit.Value, new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean));
}
}
else
{
throw ParserHelper.Error("The value '" + lit.Value + "' is not valid as a Plain Literal in Turtle", lit);
}
default:
throw ParserHelper.Error("Unexpected Token '" + lit.GetType().ToString() + "' encountered, expected a valid Literal Token to convert to a Node", lit);
}
}
/// <summary>
/// Tries to parse Object lists
/// </summary>
/// <param name="context">Parse Context</param>
/// <param name="subj">Subject of the Triples</param>
/// <param name="pred">Predicate of the Triples</param>
/// <param name="bnodeList">Whether this is a Blank Node Object list</param>
private void TryParseObjectList(TokenisingParserContext context, INode subj, INode pred, bool bnodeList)
{
IToken objToken, next;
INode obj = null;
do
{
objToken = context.Tokens.Dequeue();
if (context.TraceParsing)
{
Console.WriteLine("Attempting to parse an Object List from the Object Token '" + objToken.GetType().ToString() + "'");
}
switch (objToken.TokenType)
{
case Token.BLANKNODE:
obj = context.Handler.CreateBlankNode();
break;
case Token.BLANKNODEWITHID:
obj = context.Handler.CreateBlankNode(objToken.Value.Substring(2));
break;
case Token.COMMA:
//Discard and continue - set object to null so we know we're expected to complete a triple
if (obj != null)
{
obj = null;
continue;
}
else
{
throw ParserHelper.Error("Unexpected Comma Triple terminator encountered, expected a valid Object for the current Triple", objToken);
}
case Token.COMMENT:
//Discard and ignore
continue;
case Token.DOT:
if (obj != null)
{
//OK to return if we've seen a valid Triple
return;
}
else
{
throw ParserHelper.Error("Unexpected Dot Triple terminator encountered, expected a valid Object for the current Triple", objToken);
}
case Token.LEFTBRACKET:
//Start of a collection so create a new Blank Node to be it's first subject
next = context.Tokens.Peek();
if (next.TokenType == Token.RIGHTBRACKET)
{
//Empty Collection => rdf:nil
context.Tokens.Dequeue();
obj = context.Handler.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil));
}
else
{
obj = context.Handler.CreateBlankNode();
this.TryParseCollection(context, obj);
}
break;
case Token.LEFTSQBRACKET:
//Start of a Blank Node collection?
next = context.Tokens.Peek();
if (next.TokenType == Token.RIGHTSQBRACKET)
{
//An anonymous Blank Node
context.Tokens.Dequeue();
obj = context.Handler.CreateBlankNode();
}
else
{
//Start of a Blank Node Collection
obj = context.Handler.CreateBlankNode();
this.TryParsePredicateObjectList(context, obj, true);
}
break;
case Token.LITERAL:
case Token.LITERALWITHDT:
case Token.LITERALWITHLANG:
case Token.LONGLITERAL:
case Token.PLAINLITERAL:
obj = this.TryParseLiteral(context, objToken);
break;
case Token.RIGHTSQBRACKET:
if (bnodeList)
{
if (obj != null)
{
//Ok to return if we've seen a Triple
return;
}
else
{
throw ParserHelper.Error("Unexpected Right Square Bracket encountered, expecting a valid object for the current Blank Node Predicate Object list", objToken);
}
}
else
{
throw ParserHelper.Error("Unexpected Right Square Bracket encountered but not expecting the end of a Blank Node Predicate Object list", objToken);
}
case Token.SEMICOLON:
if (obj != null)
{
//Ok to return if we've seen a Triple
return;
}
else
{
throw ParserHelper.Error("Unexpected Semicolon Triple terminator encountered, expected a valid Object for the current Triple", objToken);
}
case Token.QNAME:
case Token.URI:
obj = ParserHelper.TryResolveUri(context, objToken);
break;
case Token.EOF:
throw ParserHelper.Error("Unexpected end of file while trying to parse an Object list", objToken);
default:
throw ParserHelper.Error("Unexpected Token '" + objToken.GetType().ToString() + "' encountered while trying to parse an Object list", objToken);
}
//Assert the Triple
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
//Expect a comma/semicolon/dot terminator if we are to continue
next = context.Tokens.Peek();
if (bnodeList)
{
//If in a Blank Node list a dot is not permitted but a ] is
if (next.TokenType != Token.COMMA && next.TokenType != Token.SEMICOLON && next.TokenType != Token.RIGHTSQBRACKET)
{
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered while trying to parse a Blank Node Object List, expected a comma, semicolon or ] to terminate the current Triple/list", next);
}
}
else if (next.TokenType != Token.COMMA && next.TokenType != Token.SEMICOLON && next.TokenType != Token.DOT)
{
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered while trying to parse an Object list, expected a comma, semicolon or dot to terminate the current Triple", next);
}
} while (true);
}
/// <summary>
/// Tries to parse Predicate Object lists
/// </summary>
/// <param name="context">Parse Context</param>
/// <param name="subj">Subject of the Triples</param>
/// <param name="bnodeList">Whether this is a Blank Node Predicate Object list</param>
private void TryParsePredicateObjectList(TokenisingParserContext context, INode subj, bool bnodeList)
{
IToken predToken;
INode pred = null;
do
{
predToken = context.Tokens.Dequeue();
if (context.TraceParsing)
{
Console.WriteLine("Attempting to parse Predicate Object List from the Predicate Token '" + predToken.GetType().ToString() + "'");
}
switch (predToken.TokenType)
{
case Token.COMMENT:
//Discard and continue
continue;
case Token.KEYWORDA:
//'a' Keyword
pred = context.Handler.CreateUriNode(new Uri(NamespaceMapper.RDF + "type"));
break;
case Token.RIGHTSQBRACKET:
//If the last token was a semicolon and we're parsing a Blank Node Predicate Object list
//then a trailing semicolon is permitted
if (bnodeList)
{
if (context.Tokens.LastTokenType == Token.SEMICOLON)
{
return;
}
else
{
//If Predicate is not null then we've seen at least one valid Triple and this is just the end of the Blank Node Predicate Object list
if (pred != null)
{
return;
}
else
{
throw ParserHelper.Error("Unexpected Right Square Bracket encountered while trying to parse a Blank Node Predicate Object list, expected a valid Predicate", predToken);
}
}
}
else
{
throw ParserHelper.Error("Unexpected Right Square Bracket encountered while trying to parse a Predicate Object list", predToken);
}
case Token.QNAME:
case Token.URI:
pred = ParserHelper.TryResolveUri(context, predToken);
break;
case Token.EOF:
throw ParserHelper.Error("Unexpected end of file while trying to parse a Predicate Object list", predToken);
default:
throw ParserHelper.Error("Unexpected Token '" + predToken.GetType().ToString() + "' encountered while trying to parse a Predicate Object list", predToken);
}
this.TryParseObjectList(context, subj, pred, bnodeList);
if (context.Tokens.LastTokenType == Token.DOT && !bnodeList) return; //Dot terminates a normal Predicate Object list
if (context.Tokens.LastTokenType == Token.RIGHTSQBRACKET && bnodeList) return; //Trailing semicolon may terminate a Blank Node Predicate Object list
if (context.Tokens.LastTokenType == Token.SEMICOLON && context.Tokens.Peek().TokenType == Token.DOT)
{
//Dot terminates a Predicate Object list with a trailing semicolon
context.Tokens.Dequeue();
return;
}
} while (true);
}
/// <summary>
/// Tries to parse Triples
/// </summary>
/// <param name="context">Parser Context</param>
private void TryParseTriples(TokenisingParserContext context)
{
IToken subjToken = context.Tokens.Dequeue();
IToken next;
INode subj;
if (context.TraceParsing)
{
Console.WriteLine("Attempting to parse Triples from the Subject Token '" + subjToken.GetType().ToString() + "'");
}
switch (subjToken.TokenType)
{
case Token.BLANKNODE:
subj = context.Handler.CreateBlankNode();
break;
case Token.BLANKNODEWITHID:
subj = context.Handler.CreateBlankNode(subjToken.Value.Substring(2));
break;
case Token.LEFTBRACKET:
//Start of a collection so create a new Blank Node to be it's first subject
next = context.Tokens.Peek();
if (next.TokenType == Token.RIGHTBRACKET)
{
//An Empty Collection => rdf:nil
context.Tokens.Dequeue();
subj = context.Handler.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil));
}
else
{
subj = context.Handler.CreateBlankNode();
this.TryParseCollection(context, subj);
}
break;
case Token.LEFTSQBRACKET:
//Start of a Blank Node collection?
next = context.Tokens.Peek();
if (next.TokenType == Token.RIGHTSQBRACKET)
{
//An anoynmous Blank Node
context.Tokens.Dequeue();
subj = context.Handler.CreateBlankNode();
}
else
{
//Start of a Blank Node Collection
subj = context.Handler.CreateBlankNode();
this.TryParsePredicateObjectList(context, subj, true);
}
break;
case Token.QNAME:
case Token.URI:
subj = ParserHelper.TryResolveUri(context, subjToken);
break;
default:
throw ParserHelper.Error("Unexpected Token '" + subjToken.GetType().ToString() + "' encountered, this Token is not valid as the subject of a Triple", subjToken);
}
this.TryParsePredicateObjectList(context, subj, false);
}
/// <summary>
/// Tries to parse Base/Prefix declarations
/// </summary>
/// <param name="context">Parse Context</param>
private void TryParseDirective(TokenisingParserContext context)
{
if (context.TraceParsing)
{
Console.WriteLine("Attempting to parse a Base/Prefix Declaration");
}
//If we've been called an AT token has been encountered which we can discard
context.Tokens.Dequeue();
//Then we expect either a Base Directive/Prefix Directive
IToken directive = context.Tokens.Dequeue();
if (directive.TokenType == Token.BASEDIRECTIVE)
{
//Then expect a Uri for the Base Uri
IToken u = context.Tokens.Dequeue();
if (u.TokenType == Token.URI)
{
//Set the Base Uri resolving against the current Base if any
try
{
Uri baseUri = new Uri(Tools.ResolveUri(u.Value, context.BaseUri.ToSafeString()));
context.BaseUri = baseUri;
if (!context.Handler.HandleBaseUri(baseUri)) ParserHelper.Stop();
}
catch (RdfException rdfEx)
{
throw new RdfParseException("Unable to set the Base URI to '" + u.Value + "' due to the following error:\n" + rdfEx.Message, u, rdfEx);
}
}
else
{
throw ParserHelper.Error("Unexpected Token '" + u.GetType().ToString() + "' encountered, expected a URI after a Base Directive", u);
}
}
else if (directive.TokenType == Token.PREFIXDIRECTIVE)
{
//Expect a Prefix then a Uri
IToken pre = context.Tokens.Dequeue();
if (pre.TokenType == Token.PREFIX)
{
IToken ns = context.Tokens.Dequeue();
if (ns.TokenType == Token.URI)
{
//Register a Namespace resolving the Namespace Uri against the Base Uri
try
{
Uri nsUri = new Uri(Tools.ResolveUri(ns.Value, context.BaseUri.ToSafeString()));
String nsPrefix = (pre.Value.Length > 1) ? pre.Value.Substring(0, pre.Value.Length - 1) : String.Empty;
context.Namespaces.AddNamespace(nsPrefix, nsUri);
if (!context.Handler.HandleNamespace(nsPrefix, nsUri)) ParserHelper.Stop();
}
catch (RdfException rdfEx)
{
throw new RdfParseException("Unable to resolve the Namespace URI '" + ns.Value + "' due to the following error:\n" + rdfEx.Message, ns, rdfEx);
}
}
else
{
throw ParserHelper.Error("Unexpected Token '" + ns.GetType().ToString() + "' encountered, expected a URI after a Prefix Directive", pre);
}
}
else
{
throw ParserHelper.Error("Unexpected Token '" + pre.GetType().ToString() + "' encountered, expected a Prefix after a Prefix Directive", pre);
}
}
else
{
throw ParserHelper.Error("Unexpected Token '" + directive.GetType().ToString() + "' encountered, expected a Base/Prefix Directive after an @ symbol", directive);
}
//All declarations are terminated with a Dot
IToken terminator = context.Tokens.Dequeue();
if (terminator.TokenType != Token.DOT)
{
throw ParserHelper.Error("Unexpected Token '" + terminator.GetType().ToString() + "' encountered, expected a Dot Line Terminator to terminate a Prefix/Base Directive", terminator);
}
}
/// <summary>
/// Internal method which does the parsing of the input
/// </summary>
/// <param name="context">Parser Context</param>
private void Parse(TokenisingParserContext context)
{
try
{
context.Handler.StartRdf();
//Initialise Buffer and start parsing
context.Tokens.InitialiseBuffer(10);
IToken next = context.Tokens.Dequeue();
if (next.TokenType != Token.BOF)
{
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, expected a BOF Token", next);
}
do
{
next = context.Tokens.Peek();
switch (next.TokenType)
{
case Token.AT:
this.TryParseDirective(context);
break;
case Token.COMMENT:
//Discard and ignore
context.Tokens.Dequeue();
break;
case Token.BLANKNODE:
case Token.BLANKNODEWITHID:
case Token.LEFTBRACKET:
case Token.LEFTSQBRACKET:
case Token.QNAME:
case Token.URI:
//Valid Subject of a Triple
this.TryParseTriples(context);
break;
case Token.LITERAL:
case Token.LITERALWITHDT:
case Token.LITERALWITHLANG:
case Token.LONGLITERAL:
//Literals not valid as Subjects
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, Literals are not valid as Subjects in Turtle", next);
case Token.KEYWORDA:
//'a' Keyword only valid as Predicate
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, the 'a' Keyword is only valid as a Predicate in Turtle", next);
case Token.EOF:
//OK - the loop will now terminate since we've seen the End of File
break;
default:
throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered", next);
}
} while (next.TokenType != Token.EOF);
context.Handler.EndRdf(true);
}
catch (RdfParsingTerminatedException)
{
context.Handler.EndRdf(true);
//Discard this - it justs means the Handler told us to stop
}
catch
{
context.Handler.EndRdf(false);
throw;
}
}