/// <summary>
/// Parser for Formals
/// </summary>
/// <param name="functionDefinition">functionDefinition to add formals to</param>
/// <returns>Parsed Formals</returns>
public void ParseFormals(FunctionDefinition functionDefinition)
{
if (TokenStream.Peek(1).GetValue().ToString() != "(")
{
return; //No formals, so return empty formals
}
//Skip ( token
NextToken("(", "(formal1, formal2)", '(');
while (TokenStream.HasNext())
{ //Parse formals
if (TokenStream.Peek(1).GetValue().ToString() == ")")
{
break; //End of formals
}
else if (TokenStream.Peek(1).GetValue().ToString() == ",")
{
//Skip , token
NextToken(",", "(formal1, formal2)", ',');
}
functionDefinition.AddFormal(ParseFormal());
}
//Skip ) token
NextToken(")", "(formal1, formal2)", ')');
}
/// <summary>
/// Parser for EchoStatement
/// </summary>
/// <returns>Parsed EchoStatement</returns>
public EchoStatement ParseEchoStatement()
{
//Skip echo
NextToken("echo", "echo Expression/Embedding ;", "echo");
//Determine echo type
if (TokenStream.HasNext() && TokenStream.Peek(1).GetType() == TokenType.EMBEDDING)
{ //EchoEmbeddingStatement
EchoEmbeddingStatement echoEmbedding = new EchoEmbeddingStatement();
//Parse embedding
echoEmbedding.SetEmbedding(embeddingParser.ParseEmbedding());
//Skip ; token
NextToken(";", "echo Expression/Embedding ;", ';');
return(echoEmbedding);
}
else
{ //EchoExpressionStatement
EchoExpressionStatement echoExpression = new EchoExpressionStatement();
//Parse expression
echoExpression.SetExpression(expressionParser.ParseExpression());
//Skip ; token
NextToken(";", "echo Expression/Embedding ;", ';');
return(echoExpression);
}
}
/// <summary>
/// Parse an RecordExpression
/// </summary>
/// <returns>Parsed Record Expression</returns>
public RecordExpression ParseRecordExpression()
{
RecordExpression recordExpression = new RecordExpression();
//Skip { token
NextToken("{", "{key:value, key:value}", '{');
while (TokenStream.HasNext())
{ //Scan for key value pairs
if (TokenStream.Peek(1).GetValue().ToString() == "}")
{
break; //} marks end of stream
}
recordExpression.AddKeyValuePair(ParseKeyValuePair());
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ",")
{
//Skip , token
NextToken(",", "{key:value, key:value}", ',');
}
}
//Skip } token
NextToken("}", "{key:value, key:value}", '}');
return(recordExpression);
}
/// <summary>
/// Parse an ListExpression
/// </summary>
/// <returns>Parsed List Expression</returns>
public ListExpression ParseListExpression()
{
ListExpression listExpression = new ListExpression();
//Skip [ token
NextToken("[", "[ expression, expression ]", '[');
while (TokenStream.HasNext())
{ //Scan for expressions
if (TokenStream.Peek(1).GetValue().ToString() == "]")
{
break; //empty list found
}
listExpression.AddExpression(ParseExpression());
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ",")
{ //separator
NextToken(",", "[ expression, expression ]", ',');
}
}
//Skip ] token
NextToken("]", "[ expression, expression ]", ']');
return(listExpression);
}
/// <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>
/// Detects if next tokens are markup (in a Markup+ form)
/// </summary>
/// <returns>True if markup otherwise false</returns>
private bool DetectNextIsMarkup()
{
int j = 1;
if (TokenStream.HasNext(1) && TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER)
{
if (TokenStream.HasNext(j + 1) && TokenStream.Peek(j + 1).GetValue().ToString() == "+")
{ //CatExpression isn't markup
return(false);
}
//Determine if arguments exists
while (TokenStream.HasNext(j + 1))
{
if (IsNextMarkupAttribute(j + 1))
{
//Attribute is max 2 tokens wide
if (TokenStream.HasNext(j + 2))
{
j += 2;
}
else
{ //No markup;
return(false);
}
}
else
{ //End of attributes
break;
}
}
//Determine if it is a call
if (TokenStream.HasNext(j + 1) && TokenStream.Peek(j + 1).GetType() == TokenType.SYMBOL && TokenStream.Peek(j + 1).GetValue().ToString() == "(")
{ //Call markup
return(true);
}
else if (TokenStream.HasNext(j + 1) && TokenStream.Peek(j + 1).GetType() == TokenType.SYMBOL && TokenStream.Peek(j + 1).GetValue().ToString() == ";")
{ //No markup in a list
return(false);
}
else
{ //Everything else is just markup
return(true);
}
}
else
{ //No identifier at start, so no markup
return(false);
}
}
/// <summary>
/// Parser for Statements
/// </summary>
/// <returns>Parsed Statements</returns>
public Statement ParseStatement()
{
if (TokenStream.HasNext())
{
//Determine type of statement
if (TokenStream.Peek(1).GetValue().ToString() == "if")
{ //If (ThenElse) statement
return(ParseIfStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "each")
{ //Each statement
return(ParseEachStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "let")
{ //Let statement
return(ParseLetStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "{")
{ //Block statement
return(ParseBlockStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "comment")
{ //Comment statement
return(ParseCommentStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "echo")
{ //Echo statement
return(ParseEchoStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "cdata")
{ //Cdata statement
return(ParseCdataStatement());
}
else if (TokenStream.Peek(1).GetValue().ToString() == "yield")
{ //Yield statement
return(ParseYieldStatement());
}
else if (TokenStream.Peek(1).GetType() == TokenType.IDENTIFIER)
{ //Markup statements, starts always with an identifier
return(ParseMarkupStatement());
}
else
{ //Unexpected token, throw exception
throw new UnexpectedToken("Statement expected, but found:", TokenStream.Peek(1).GetValue().ToString(), TokenStream.Peek(1).GetLine());
}
}
return(null);
}
/// <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>
/// 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 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());
}
}
private bool IsMarkupStatStatement()
{
String value = TokenStream.Peek(1).GetValue().ToString();
bool lookahead = TokenStream.HasNext(3);
if (lookahead)
{
String second = TokenStream.Peek(2).GetValue().ToString();
String look = TokenStream.Peek(3).GetValue().ToString();
return(value == "if" || value == "each" || value == "let" || (value == "{" && !(second == "}" && look == ";")) || value == "comment" ||
value == "echo" || value == "cdata" || value == "yield");
}
else
{
return(value == "if" || value == "each" || value == "let" || value == "{" || value == "comment" ||
value == "echo" || value == "cdata" || value == "yield");
}
}
/// <summary>
/// Parser for If(Else)Statement
/// </summary>
/// <returns>Parsed If(Else)Statement</returns>
public Statement ParseIfStatement()
{
Statement statement = null;
//Skip if keyword
NextToken("if", "if ( Predicate ) Statement else Statement", "if");
//Skip ( token
NextToken("(", "if ( Predicate ) Statement else Statement", '(');
//Parse predicate
Predicate predicate = predicateParser.ParsePredicate();
//Skip ) token
NextToken(")", "if ( Predicate ) Statement else Statement", ')');
//Parse if part of statement
Statement ifStatementPart = ParseStatement();
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "else")
{ //Else part detected
//Skip else token
NextToken("else", "if ( Predicate ) Statement else Statement", "else");
//Parse else statement part
Statement elseStatementPart = ParseStatement();
IfElseStatement ifElseStatement = new IfElseStatement();
ifElseStatement.SetPredicate(predicate);
ifElseStatement.SetTrueStatement(ifStatementPart);
ifElseStatement.SetFalseStatement(elseStatementPart);
statement = ifElseStatement;
}
else
{ //If statement
IfStatement ifStatement = new IfStatement();
ifStatement.SetPredicate(predicate);
ifStatement.SetTrueStatement(ifStatementPart);
statement = ifStatement;
}
return(statement);
}
/// <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>
/// Parser for Predicate
/// </summary>
/// <returns>Parsed Predicate</returns>
public Predicate ParsePredicate()
{
Predicate predicate = null; //Empty predicate
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "!")
{ //Not Predicate
NotPredicate notPredicate = new NotPredicate();
//Skip ! token
NextToken("!", "! predicate", '!');
//Parse predicate after !
notPredicate.SetPredicate(ParsePredicate());
predicate = notPredicate;
}
else
{ //Other predicates exists out of an expression
Expression expression = expressionParser.ParseExpression();
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".")
{ //IsPredicate
predicate = ParseIsPredicate(expression);
}
else
{ //ExpressionPredicate
predicate = ParseExpressionPredicate(expression);
}
}
//Check for && or || predicates
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "&" && TokenStream.Peek(2).GetValue().ToString() == "&")
{ //AndPredicate
return(ParseAndPredicate(predicate));
}
else if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "|" && TokenStream.Peek(2).GetValue().ToString() == "|")
{ //OrPredicate
return(ParseOrPredicate(predicate));
}
return(predicate);
}
/// <summary>
/// Parse Directory
/// </summary>
/// <returns>Parsed Directory</returns>
public Directory ParseDirectory()
{
Directory directory = new Directory();
//Parse path elements
while (TokenStream.HasNext())
{
if(TokenStream.Peek(2).GetValue().ToString() == ".")
{ //End of directory, filename starts here
break;
}
PathElement element = new PathElement();
NextToken("directory", "directory/filename.ext", TokenType.IDENTIFIER);
element.SetPathElement(CurrentToken.GetValue().ToString());
directory.AddDirectoryElement(element);
//Skip / or \
NextToken("/ or \\", "directory/FileName.ext", TokenType.SYMBOL);
}
return directory;
}
/// <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>
/// Parser for Designator
/// </summary>
/// <returns>Parsed Designator</returns>
public Designator ParseDesignator()
{
Designator tag = new Designator();
//Parse identifier of tag
NextToken("identifier", "identifier");
tag.SetIdentifier(CurrentToken.GetValue().ToString());
while (TokenStream.HasNext())
{ //Parse attributes
if (TokenStream.Peek(1).GetType() == TokenType.SYMBOL && IsAttribute(TokenStream.Peek(1).GetValue().ToString()))
{
tag.AddAttribute(ParseAttribute());
}
else
{
break; //No attributes left, so break
}
}
return(tag);
}
/// <summary>
/// Parser for FunctionDefinition
/// </summary>
/// <returns>Parsed FunctionDefinition</returns>
public FunctionDefinition ParseFunctionDefinition()
{
FunctionDefinition functionDefinition = new FunctionDefinition();
//Parse FunctionId
CurrentToken = TokenStream.NextToken();
functionDefinition.SetIdentifier(CurrentToken.GetValue().ToString());
//Parse Formals
ParseFormals(functionDefinition);
//Parse Statements
while (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() != "end")
{
functionDefinition.AddStatement(statementParser.ParseStatement());
}
//Skip end token
NextToken("end", "def function() statements end", "end");
return(functionDefinition);
}
/// <summary>
/// Parser for FuncBindAssignment
/// </summary>
/// <returns>Parsed FuncBindAssignment</returns>
public FuncBindAssignment ParseFuncBindAssignment()
{
FuncBindAssignment funcBindAssignment = new FuncBindAssignment();
//Parse identifier
CurrentToken = TokenStream.NextToken();
funcBindAssignment.SetIdentifier(CurrentToken.GetValue().ToString());
//Skip ( token
NextToken("(", "identifier(identifier1, identifier2) = statement;", '(');
//Parse identifiers
while (TokenStream.HasNext())
{
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ")")
{ //No more identifiers
break;
}
else if (TokenStream.Peek(1).GetValue().ToString() == ",")
{
//Skip , token
NextToken(",", "(identifier1, identifier2)", ',');
}
CurrentToken = TokenStream.NextToken();
funcBindAssignment.AddIdentifier(CurrentToken.GetValue().ToString());
}
//Skip ) token
NextToken(")", "identifier(identifier1, identifier2) = statement;", ')');
//Skip = token
NextToken("=", "identifier(identifier1, identifier2) = statement;", '=');
//Parse statement
funcBindAssignment.SetStatement(ParseStatement());
return(funcBindAssignment);
}
/// <summary>
/// Parser for BlockStatement
/// </summary>
/// <returns>Parsed BlockStatement</returns>
public BlockStatement ParseBlockStatement()
{
BlockStatement blockStatement = new BlockStatement();
//Skip { token
NextToken("{", "{ statements* }", '{');
//Parse statements
while (TokenStream.HasNext())
{
if (TokenStream.Peek(1).GetValue().ToString() == "}")
{ //End of blockstatement
break;
}
blockStatement.AddStatement(ParseStatement());
}
//Skip } token
NextToken("}", "{ statements* }", '}');
return(blockStatement);
}
/// <summary>
/// Parse mappings
/// </summary>
/// <returns>A list of parsed mappings</returns>
public NodeList ParseMappings()
{
NodeList MappingList = new NodeList();
while (TokenStream.HasNext()) //Parse mappings
{
MappingList.Add(ParseMapping());
if (TokenStream.HasNext()) //Check if another mapping comes
{
if (MatchValue(TokenStream.Peek(1).GetValue().ToString(), Waebric.WaebricKeyword.END.ToString()))
{
break; //END found so stop searching
}
else
{
NextToken(";", "Mapping ; Mapping", ';'); //Match separator
}
}
}
return MappingList;
}
/// <summary>
/// Parser for Arguments
/// </summary>
/// <param name="markup">Markup to add arguments to</param>
/// <returns>Parsed arguments</returns>
public void ParseArguments(Markup markup)
{
//Skip ( character
NextToken("(", "(Argument, Argument)", '(');
while (TokenStream.HasNext())
{ //Parse argument(s)
if (TokenStream.Peek(1).GetValue().ToString() == ")")
{ //No arguments left, so break
break;
}
else if (TokenStream.Peek(1).GetValue().ToString() == ",")
{ //Second argument
//Skip comma
NextToken(",", "Argument, Argument", ',');
}
//Parse argument
markup.AddArgument(ParseArgument());
}
//Skip ) character
NextToken(")", "(Argument, Argument)", ')');
}
/// <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());
}
}
}