/// <summary>
/// Get NextToken and verify it maches matchObject (EmbeddedTokenStream)
/// </summary>
/// <param name="name">Name of expected token</param>
/// <param name="syntax">Type of expected token</param>
/// <param name="matchObject">Type of expected token</param>
/// <returns>True if token matches, otherwise false</returns>
private new bool NextToken(String name, String syntax, Object matchObject)
{
if (NextToken(name, syntax))
{
if (CurrentToken.GetValue().Equals(matchObject))
{
return(true);
}
else
{
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
return(false);
}
/// <summary>
/// Get NextToken and verify type of token (EmbeddedTokenStream)
/// </summary>
/// <param name="name">Name of expected token</param>
/// <param name="syntax">Syntax of expected token</param>
/// <param name="type">Type of expected token</param>
/// <returns>True if token found and type matches, otherwise false</returns>
private new bool NextToken(String name, String syntax, TokenType type)
{
if (NextToken(name, syntax))
{
if (type.Equals(CurrentToken.GetType()))
{
return(true);
}
else
{
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
return(false);
}
/// <summary>
/// Parser for Embedding
/// </summary>
/// <returns>Parsed Embedding</returns>
public Embedding ParseEmbedding()
{
//Get iterator for specific embedding
if (TokenStream.Peek(1).GetType() == TokenType.EMBEDDING)
{ //Store embedding in internal tokeniterator to parse internally
CurrentToken = TokenStream.NextToken();
EmbeddingTokenStream = ((EmbeddingToken)CurrentToken).GetTokenIterator();
}
else
{ //Raise exception
throw new UnexpectedToken("Embedding expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
//Let's parse embedding
Embedding embedding = new Embedding();
embedding.SetPreText(ParsePreText());
embedding.SetEmbed(ParseEmbed());
embedding.SetTextTail(ParseTextTail());
return(embedding);
}
/// <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>
/// Get NextToken and verify if it exists (EmbeddedTokenStream)
/// </summary>
/// <param name="name">Name of expected token</param>
/// <param name="syntax">Syntax of expected token</param>
/// <returns>True if new token found, otherwise false</returns>
private new bool NextToken(String name, String syntax)
{
if (EmbeddingTokenStream.HasNext())
{
CurrentToken = EmbeddingTokenStream.NextToken();
return(true);
}
else
{
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
/// <summary>
/// Parse one module
/// </summary>
/// <param name="module">Module to parse</param>
public Module ParseModule()
{
Module module = new Module();
//Skip module token
NextToken("module", "module identifier", "module");
//Parse first the identifier of the module and set it
ModuleId moduleIdentifier = ParseModuleId();
module.SetModuleId(moduleIdentifier);
//Look for elements like SITE, DEF, etc
while (TokenStream.HasNext())
{
if (MatchValue(TokenStream.Peek(1).GetValue().ToString(), Waebric.WaebricKeyword.MODULE.ToString()))
{ //New module found, raise exception, only one module per file allowed
throw new UnexpectedToken("Unexpected token, found second module definition:", "module", TokenStream.Peek(1).GetLine());
}
CurrentToken = TokenStream.NextToken();
//Check for different elements which may appear in a module
if (MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.DEF.ToString()))
{ //Function definition found
module.AddFunctionDefinition(functionParser.ParseFunctionDefinition());
}
else if (MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.SITE.ToString()))
{ //Site definition found, call siteparser
module.AddSite(siteParser.ParseSite());
}
else if (MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.IMPORT.ToString()))
{ //Imports found
module.AddImport(ParseImport());
}
else
{
//Exception
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
return(module);
}
/// <summary>
/// Parse a module identifier
/// </summary>
/// <param name="identifier">Identifier to parse</param>
public ModuleId ParseModuleId()
{
ModuleId moduleId = new ModuleId();
//parse module identifier
while (TokenStream.HasNext())
{
if (NextToken("identifier", "module identifier.identifier", TokenType.IDENTIFIER))
{
moduleId.AddIdentifier(CurrentToken.GetValue().ToString());
}
else
{
//Raise exception
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".")
{ //Period, so another identifier will appear after this one
NextToken(".", "module identifier.identifier", '.');
}
else
{
break; //No more module identifier stuff will appear
}
}
return(moduleId);
}
/// <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());
}
}
}
/// <summary>
/// Parse import
/// </summary>
/// <returns></returns>
public Import ParseImport()
{
Import import = new Import();
if (TokenStream.HasNext() && TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER)
{
import.SetModuleId(ParseModuleId());
}
else
{
//Raise exception
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
return(import);
}
/// <summary>
/// Parser for Assignment
/// </summary>
/// <returns>Parsed Assignment</returns>
public Assignment ParseAssignment()
{
//Determine type
if (TokenStream.HasNext(2) && TokenStream.Peek(2).GetValue().ToString() == "(")
{ //FuncBindAssignment
return(ParseFuncBindAssignment());
}
else if (TokenStream.HasNext(2) && TokenStream.Peek(2).GetValue().ToString() == "=")
{ //VarBindAssignment
return(ParseVarBindAssignment());
}
else
{
throw new UnexpectedToken("Assignment expected, found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
/// <summary>
/// Parser for LetStatement
/// </summary>
/// <returns>Parsed LetStatement</returns>
public LetStatement ParseLetStatement()
{
LetStatement letStatement = new LetStatement();
//Skip let token
NextToken("let", "let assignment+ in statement* end", "let");
//Parse arguments
while (TokenStream.HasNext())
{
if (TokenStream.Peek(1).GetValue().ToString() == "in")
{
break; //no more assignments left
}
letStatement.AddAssignment(ParseAssignment());
}
if (letStatement.GetAssignments().Count == 0)
{ //No assignments is not allowed
throw new UnexpectedToken("LetStatement doesn't contain assignments.", "Expected at least one assignment ", CurrentToken.GetLine());
//throw new UnexpectedToken();
}
//Skip in token
NextToken("in", "let assignment+ in statement* end", "in");
//Parse statements
while (TokenStream.HasNext())
{
if (TokenStream.Peek(1).GetValue().ToString() == "end")
{ //No more statements left
break;
}
letStatement.AddStatement(ParseStatement());
}
//Skip end token
NextToken("end", "let assignment+ in statement* end", "end");
return(letStatement);
}
/// <summary>
/// Parse an expression
/// </summary>
/// <returns>Parsed Expression</returns>
public Expression ParseExpression()
{
Expression expression = null;
//Determine subtype and then parse that type
if (TokenStream.Peek(1).GetType() == TokenType.TEXT)
{ //Text expression
expression = ParseTextExpression();
}
else if (TokenStream.Peek(1).GetType() == TokenType.WAEBRICSYMBOL)
{ //Symbol expression
expression = ParseSymExpression();
}
else if (TokenStream.Peek(1).GetType() == TokenType.NUMBER)
{ //Numeric expression
expression = ParseNumExpression();
}
else if (TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER)
{ //Variable expression
expression = ParseVarExpression();
}
else if (TokenStream.Peek(1).GetValue().ToString() == "[")
{ //List expression
expression = ParseListExpression();
}
else if (TokenStream.Peek(1).GetValue().ToString() == "{")
{ //Record expression
expression = ParseRecordExpression();
}
//Check if it is maybe an catenation or field
if (TokenStream.HasNext(2) && TokenStream.Peek(1).GetValue().ToString() == "." && TokenStream.Peek(2).GetType() == TokenType.IDENTIFIER &&
TokenStream.Peek(3).GetValue().ToString() != "?")
{ //Field
return(ParseFieldExpression(expression));
}
else if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "+")
{ //Catenation
return(ParseCatExpression(expression));
}
if (expression == null)
{ //No expression found, raise exception
throw new UnexpectedToken("Expression expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
return(expression);
}
/// <summary>
/// Parser for Attribute
/// </summary>
/// <returns>Parsed Attribute</returns>
public Attribute ParseAttribute()
{
CurrentToken = TokenStream.NextToken();
Attribute attribute = null;
switch (CurrentToken.GetValue().ToString())
{ //Determine different types of attributes
case "#": //Id attribute
attribute = ParseIdAttribute();
break;
case ".": //Class attribute
attribute = ParseClassAttribute();
break;
case "$": //Name attribute
attribute = ParseNameAttribute();
break;
case ":": //Type attribute
attribute = ParseTypeAttribute();
break;
case "@": //Width_(Height) attribute
if (TokenStream.Peek(2).GetValue().ToString() == "%")
{ //Width-Height attribute
attribute = ParseWidth_HeightAttribute();
}
else
{ //Only width attribute
attribute = ParseWidthAttribute();
}
break;
default:
throw new UnexpectedToken("Expected attribute, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
return(attribute);
}
/// <summary>
/// Parser for Type
/// </summary>
/// <returns>Parsed Type</returns>
public Type ParseType()
{
//return specific type
CurrentToken = TokenStream.NextToken();
if (CurrentToken.GetValue().ToString() == "list")
{ //ListType
return(new ListType());
}
else if (CurrentToken.GetValue().ToString() == "record")
{ //RecordType
return(new RecordType());
}
else if (CurrentToken.GetValue().ToString() == "string")
{ //StringType
return(new StringType());
}
else
{ //Unexpected type, throw exception
throw new UnexpectedToken("Type expected, but found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
