/// <summary>
/// Parse one mapping
/// </summary>
/// <returns>Parsed mapping</returns>
public Mapping ParseMapping()
{
Mapping mapping = new Mapping();
// Parse Path
mapping.SetPath(ParsePath());
// Skip : symbol
NextToken(":", "path : mapping", ':');
// Parse Markup
mapping.SetMarkup(markupParser.ParseMarkup());
return mapping;
}
/// <summary>
/// Parser for Embed
/// </summary>
/// <returns>Parsed Embed</returns>
public Embed ParseEmbed()
{
Embed embed = null;
NodeList markupList = new NodeList();
//Set up MarkupParser
markupParser = new MarkupParser(EmbeddingTokenStream);
//Parse Markup*
//EmbeddingTokenStream.HasNext(2) && !(EmbeddingTokenStream.Peek(2).GetValue().ToString() == ">"
while (NextTokenIsMarkup())
{
markupList.Add(markupParser.ParseMarkup());
}
//Check if an expression is remaining, otherwise embed is MarkupEmbedding
if (IsExpressionRemaining())
{ //ExpressionEmbedding
ExpressionEmbed expressionEmbed = new ExpressionEmbed();
//Add already parsed markups to expressionEmbed
expressionEmbed.SetMarkups(markupList);
//Set up expressionparser
expressionParser = new ExpressionParser(EmbeddingTokenStream);
//Parse expression
expressionEmbed.SetExpression(expressionParser.ParseExpression());
embed = expressionEmbed;
}
else
{ //MarkupEmbedding
//Get last item from markupList and add it as Markup
if (markupList.Count != 0)
{
Markup markup = (Markup)markupList.Get(markupList.Count - 1);
markupList.Remove(markupList.Count - 1);
MarkupEmbed markupEmbed = new MarkupEmbed();
markupEmbed.SetMarkups(markupList);
markupEmbed.SetMarkup(markup);
embed = markupEmbed;
}
else
{ //Markup* Markup must contain at least one markup element
throw new UnexpectedToken("Markup expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
/*//Determine if remaining embed is Markup or Expression
* if (NextTokenIsMarkup())
* { //MarkupEmbedding
* MarkupEmbed markupEmbed = new MarkupEmbed();
*
* //Add already parsed markups to markupEmbed
* markupEmbed.SetMarkups(markupList);
*
* //Parse latest markup
* markupEmbed.SetMarkup(markupParser.ParseMarkup());
*
* embed = markupEmbed;
* }
* else
* { //ExpressionEmbedding
* ExpressionEmbed expressionEmbed = new ExpressionEmbed();
*
* //Add already parsed markups to expressionEmbed
* expressionEmbed.SetMarkups(markupList);
*
* //Set up expressionparser
* expressionParser = new ExpressionParser(EmbeddingTokenStream);
*
* //Parse expression
* expressionEmbed.SetExpression(expressionParser.ParseExpression());
*
* embed = expressionEmbed;
* } */
return(embed);
}
/// <summary>
/// Parser for MarkupStatement types
/// </summary>
/// <returns>Parsed Statement</returns>
public Statement ParseMarkupStatement()
{
//Start parsing first markup part
Markup firstMarkup = markupParser.ParseMarkup();
if (TokenStream.HasNext() && TokenStream.Peek(1).GetType() == TokenType.SYMBOL && TokenStream.Peek(1).GetValue().ToString() == ";")
{ //Just a single markup statement
MarkupStatement markupStatement = new MarkupStatement();
markupStatement.SetMarkup(firstMarkup);
//Skip ; token
NextToken(";", "markup;", ';');
return(markupStatement);
}
else
{
//Get other markups
NodeList markups = new NodeList();
markups.Add(firstMarkup);
while (DetectNextIsMarkup())
{
markups.Add(markupParser.ParseMarkup());
}
//Determine statement type
if (TokenStream.HasNext())
{
if (TokenStream.Peek(1).GetType() == TokenType.EMBEDDING)
{ //Markup Embedding Statement
MarkupEmbeddingStatement markupEmbedding = new MarkupEmbeddingStatement();
markupEmbedding.SetMarkups(markups);
markupEmbedding.SetEmbedding(embeddingParser.ParseEmbedding());
//Skip ; token
NextToken(";", "Markup+ Embedding;", ';');
return(markupEmbedding);
}
else if (TokenStream.Peek(1).GetValue().ToString() == ";")
{ //MarkupStatement
MarkupMarkupStatement markupStatement = new MarkupMarkupStatement();
//Get last parsed markup from list and remove it from list
Markup last = (Markup)markups.Get(markups.Count - 1);
markups.Remove(markups.Count - 1);
markupStatement.SetMarkup(last);
markupStatement.SetMarkups(markups);
//Skip ; token
NextToken(";", "Markup+ Markup;", ';');
return(markupStatement);
}
else if (IsMarkupStatStatement())
{ //MarkupStatStatement
MarkupStatStatement markupStatStatement = new MarkupStatStatement();
markupStatStatement.SetMarkups(markups);
markupStatStatement.SetStatement(ParseStatement());
return(markupStatStatement);
}
else if (IsMarkupExpressionStatement())
{ //MarkupExpressionStatement
MarkupExpressionStatement markupExpressionStatement = new MarkupExpressionStatement();
//Parse MarkupExpressionStatement
markupExpressionStatement.SetMarkups(markups);
markupExpressionStatement.SetExpression(expressionParser.ParseExpression());
//Skip ; token
NextToken(";", "Markup+ Expression;", ';');
return(markupExpressionStatement);
}
else
{ //Unexpected token
throw new UnexpectedToken("Markup Statement expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
else
{
throw new UnexpectedToken("Expected MarkupStatement type, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
}
public void ParseDefaultMarkupTest()
{
//Parse tokens
MarkupParser markupParser = new MarkupParser(Init("(\"test\")"));
Markup parsedMarkup = markupParser.ParseMarkup();
//Check attributes
Assert.AreEqual(0, parsedMarkup.GetArguments().Count);
}
public void ParseCallNoArgsMarkupTest()
{
//Parse tokens
MarkupParser markupParser = new MarkupParser(Init("home()"));
Markup parsedMarkup = markupParser.ParseMarkup();
//Check markup
Assert.AreEqual("home", parsedMarkup.GetDesignator().GetIdentifier()); //identifier check
Assert.AreEqual(0, parsedMarkup.GetDesignator().GetAttributes().Count); //no attributes
Assert.AreEqual(0, parsedMarkup.GetArguments().Count); //no arguments
}
/// <summary>
/// Parser for Embed
/// </summary>
/// <returns>Parsed Embed</returns>
public Embed ParseEmbed()
{
Embed embed = null;
NodeList markupList = new NodeList();
//Set up MarkupParser
markupParser = new MarkupParser(EmbeddingTokenStream);
//Parse Markup*
//EmbeddingTokenStream.HasNext(2) && !(EmbeddingTokenStream.Peek(2).GetValue().ToString() == ">"
while(NextTokenIsMarkup())
{
markupList.Add(markupParser.ParseMarkup());
}
//Check if an expression is remaining, otherwise embed is MarkupEmbedding
if (IsExpressionRemaining())
{ //ExpressionEmbedding
ExpressionEmbed expressionEmbed = new ExpressionEmbed();
//Add already parsed markups to expressionEmbed
expressionEmbed.SetMarkups(markupList);
//Set up expressionparser
expressionParser = new ExpressionParser(EmbeddingTokenStream);
//Parse expression
expressionEmbed.SetExpression(expressionParser.ParseExpression());
embed = expressionEmbed;
}
else
{ //MarkupEmbedding
//Get last item from markupList and add it as Markup
if (markupList.Count != 0)
{
Markup markup = (Markup)markupList.Get(markupList.Count - 1);
markupList.Remove(markupList.Count - 1);
MarkupEmbed markupEmbed = new MarkupEmbed();
markupEmbed.SetMarkups(markupList);
markupEmbed.SetMarkup(markup);
embed = markupEmbed;
}
else
{ //Markup* Markup must contain at least one markup element
throw new UnexpectedToken("Markup expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
/*//Determine if remaining embed is Markup or Expression
if (NextTokenIsMarkup())
{ //MarkupEmbedding
MarkupEmbed markupEmbed = new MarkupEmbed();
//Add already parsed markups to markupEmbed
markupEmbed.SetMarkups(markupList);
//Parse latest markup
markupEmbed.SetMarkup(markupParser.ParseMarkup());
embed = markupEmbed;
}
else
{ //ExpressionEmbedding
ExpressionEmbed expressionEmbed = new ExpressionEmbed();
//Add already parsed markups to expressionEmbed
expressionEmbed.SetMarkups(markupList);
//Set up expressionparser
expressionParser = new ExpressionParser(EmbeddingTokenStream);
//Parse expression
expressionEmbed.SetExpression(expressionParser.ParseExpression());
embed = expressionEmbed;
} */
return embed;
}
