/// <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 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>
/// 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>
/// 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)", ')');
}
private bool IsNextMarkupAttribute(int index)
{
if (TokenStream.Peek(index).GetType() != TokenType.SYMBOL)
{
return(false);
}
String tokenText = TokenStream.Peek(index).GetValue().ToString();
return(tokenText == "#" || tokenText == "." || tokenText == "$" || tokenText == ":" || tokenText == "@" || tokenText == "%");
}
private bool IsMarkupExpressionStatement()
{
if (TokenStream.Peek(1).GetType() == TokenType.SYMBOL)
{ //Expression characters are only [ and {
return(TokenStream.Peek(1).GetValue().ToString() == "[" || TokenStream.Peek(1).GetValue().ToString() == "{");
}
else
{
return(TokenStream.Peek(1).GetType() != TokenType.KEYWORD);
}
}
public virtual AType Parse(TokenStream tokens)
{
tokens.EnsureNotEof();
Token throwToken = tokens.Peek();
AType type = this.TryParse(tokens);
if (type == null)
{
throw new ParserException(throwToken, "Type name expected");
}
return(type);
}
/// <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 an argument
/// </summary>
/// <returns>Parsed Argument</returns>
public Argument ParseArgument()
{
Argument argument = null;
//Determine type of argument
if (TokenStream.Peek(2).GetValue().ToString() == "=")
{ //IdCon = Expression
argument = ParseAttrArgument();
}
else
{ //Expression
argument = ParseExpressionArgument();
}
return(argument);
}
/// <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 markup
/// </summary>
/// <returns>Parsed markup</returns>
public Markup ParseMarkup()
{
//First parse mandatory designator
Markup markup = new Markup();
markup.SetDesignator(ParseDesignator());
//Determine if arguments are after designator
if (TokenStream.Peek(1).GetType() == TokenType.SYMBOL && TokenStream.Peek(1).GetValue().ToString() == "(")
{
//We are dealing with an MarkupCall, so set Markup as Call
markup.SetCall();
ParseArguments(markup);
}
return(markup);
}
/// <summary>
/// Parse a path
/// </summary>
/// <returns>Parsed path</returns>
public Path ParsePath()
{
Path path = new Path();
//Determine if we have directories in path or just a filename
if (TokenStream.Peek(2).GetValue().ToString() == ".")
{ //Just a single filename to parse
path.SetFilename(ParseFileName());
}
else
{ //Directory and filename
path.SetDirectoryName(ParseDirectoryName());
path.SetFilename(ParseFileName());
}
return path;
}
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 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);
}
protected void ParseArgumentListDeclaration(
TokenStream tokens,
Node owner,
IList <AType> argTypesOut,
IList <Token> argNamesOut,
IList <Expression> argDefaultValuesOut)
{
bool optionalArgFound = false;
while (!tokens.PopIfPresent(")"))
{
if (argNamesOut.Count > 0)
{
tokens.PopExpected(",");
}
AType argType = this.HasTypes
? this.parser.TypeParser.Parse(tokens)
: AType.Any(tokens.Peek());
Token argName = tokens.Pop();
this.parser.VerifyIdentifier(argName);
Expression defaultValue = null;
if (tokens.PopIfPresent("="))
{
defaultValue = this.parser.ExpressionParser.Parse(tokens, owner);
optionalArgFound = true;
}
else if (optionalArgFound)
{
throw this.parser.GenerateParseError(
ErrorMessages.OPTIONAL_ARGUMENT_WAS_NOT_AT_END_OF_ARGUMENT_LIST,
argName);
}
argTypesOut.Add(argType);
argNamesOut.Add(argName);
argDefaultValuesOut.Add(defaultValue);
}
}
/// <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 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 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;
}