public StatementParser(TokenIterator iterator)
: base(iterator)
{
//Create subparsers
predicateParser = new PredicateParser(iterator);
expressionParser = new ExpressionParser(iterator);
embeddingParser = new EmbeddingParser(iterator);
markupParser = new MarkupParser(iterator);
}
public void ParseCatExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("expression+'symbol"));
Expression expression = expressionParser.ParseExpression();
//Check type of expression
Assert.AreEqual(typeof(CatExpression), expression.GetType());
CatExpression parsedCatExpression = (CatExpression)expression;
//Check expressions in catexpression
Assert.AreEqual(typeof(VarExpression), parsedCatExpression.GetLeftExpression().GetType());
Assert.AreEqual(typeof(SymExpression), parsedCatExpression.GetRightExpression().GetType());
VarExpression left = (VarExpression) parsedCatExpression.GetLeftExpression();
SymExpression right = (SymExpression)parsedCatExpression.GetRightExpression();
Assert.AreEqual("expression", left.GetVariableIdentifier());
Assert.AreEqual("symbol", right.GetSym());
}
public PredicateParser(TokenIterator iterator)
: base(iterator)
{
//Create subparser
expressionParser = new ExpressionParser(iterator);
}
public MarkupParser(TokenIterator iterator)
: base(iterator)
{
//Create parsers here
expressionParser = new ExpressionParser(iterator);
}
public void ParseFieldExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("expressie.identifier"));
Expression expression = expressionParser.ParseExpression();
//Test type of expression
Assert.AreEqual(typeof(FieldExpression), expression.GetType());
FieldExpression parsedFieldExpression = (FieldExpression)expression;
//Test field members
Assert.AreEqual("expressie", parsedFieldExpression.GetExpression().ToString());
Assert.AreEqual(typeof(VarExpression), parsedFieldExpression.GetExpression().GetType());
Assert.AreEqual("identifier", parsedFieldExpression.GetIdentifier());
}
public void ParseExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("expressie.identifier"));
Expression expression = expressionParser.ParseExpression();
//Test type of expression
Assert.AreEqual(typeof(FieldExpression), expression.GetType());
}
public void ParseVarExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("home"));
VarExpression expression = expressionParser.ParseVarExpression();
//Test variable identifier
Assert.AreEqual("home", expression.GetVariableIdentifier());
}
public PredicateParser(TokenIterator iterator)
: base(iterator)
{
//Create subparser
expressionParser = new ExpressionParser(iterator);
}
public void ParseSymExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("'symbol"));
SymExpression expression = expressionParser.ParseSymExpression();
//Test variable identifier
Assert.AreEqual("symbol", expression.GetSym());
}
public void ParseRecordExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("{token1:\"token1\", token2:10, token3:'symbol}"));
RecordExpression expression = expressionParser.ParseRecordExpression();
//Test Record contents
Assert.AreEqual(3, expression.GetRecords().Count);
List<ISyntaxNode>.Enumerator recordEnumerator = expression.GetRecords().GetEnumerator();
recordEnumerator.MoveNext();
KeyValuePair current = (KeyValuePair) recordEnumerator.Current;
Assert.AreEqual("token1", current.GetKey());
Assert.AreEqual(typeof(TextExpression), current.GetValue().GetType());
Assert.AreEqual("\"token1\"", current.GetValue().ToString());
recordEnumerator.MoveNext();
current = (KeyValuePair)recordEnumerator.Current;
Assert.AreEqual("token2", current.GetKey());
Assert.AreEqual(typeof(NumExpression), current.GetValue().GetType());
Assert.AreEqual(10, ((NumExpression)current.GetValue()).GetNum());
recordEnumerator.MoveNext();
current = (KeyValuePair)recordEnumerator.Current;
Assert.AreEqual("token3", current.GetKey());
Assert.AreEqual(typeof(SymExpression), current.GetValue().GetType());
Assert.AreEqual("'symbol", current.GetValue().ToString());
}
public void ParseNumExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("1230"));
NumExpression expression = expressionParser.ParseNumExpression();
//Test variable identifier
Assert.AreEqual(1230, expression.GetNum());
}
public void ParseListExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("[var1, var2, var3, var4]"));
ListExpression listExpression = expressionParser.ParseListExpression();
//Test items of list
Assert.AreEqual(4, listExpression.GetExpressions().Count);
Expression[] expressions = (Expression[]) listExpression.GetExpressions().ToArray();
Assert.AreEqual("var1", expressions[0].ToString());
Assert.AreEqual("var2", expressions[1].ToString());
Assert.AreEqual("var3", expressions[2].ToString());
Assert.AreEqual("var4", expressions[3].ToString());
}
public void ParseKeyValuePairTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("token1:\"value1\""));
KeyValuePair keyValuePair = expressionParser.ParseKeyValuePair();
//Check key
Assert.AreEqual("token1", keyValuePair.GetKey());
//Check value
Assert.AreEqual(typeof(TextExpression), keyValuePair.GetValue().GetType());
TextExpression textExpression = (TextExpression) keyValuePair.GetValue();
Assert.AreEqual("value1", textExpression.GetText());
}
/// <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;
}
public MarkupParser(TokenIterator iterator)
: base(iterator)
{
//Create parsers here
expressionParser = new ExpressionParser(iterator);
}
public void ParseIsPredicateTest()
{
//Create parser
PredicateParser predicateParser = new PredicateParser(Init(".string?"));
ExpressionParser expressionParser = new ExpressionParser(Init("test"));
Expression parsedExpression = expressionParser.ParseExpression();
IsPredicate parsedIsPredicate = predicateParser.ParseIsPredicate(parsedExpression);
//Check expression
Assert.AreEqual(typeof(VarExpression), parsedIsPredicate.GetExpression().GetType());
Assert.AreEqual("test", parsedIsPredicate.GetExpression().ToString());
//Check type
Assert.AreEqual(typeof(StringType), parsedIsPredicate.GetType().GetType());
}
/// <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);
}
public void ParseTextExpressionTest()
{
//Create parser and parse tokens
ExpressionParser expressionParser = new ExpressionParser(Init("text"));
TextExpression expression = expressionParser.ParseTextExpression();
//Test variable identifier
Assert.AreEqual("text", expression.GetText());
}
