} // Like a linked list, points to the next else (could be an 'else if' if it has a Condition) public IfStatement(SourceSpan span, Expressions.Expression condition, InstructionStatement body, IfStatement elseStatement) { this.Span = span; this.Condition = condition; this.Body = body; this.ElseStatement = elseStatement; }
public ForEachStatement(SourceSpan span, Token variable, Expressions.Expression collection, InstructionStatement body) { this.Span = span; this.Variable = variable; this.Collection = collection; this.Body = body; }
private ForEachStatement ParseForEachStatement() { Token forEachKeyword = ConsumeType(TokenType.KeywordForEach, "Expected foreach keyword.", "LSS028"); SourceSpan span = forEachKeyword.Span; SkipWhitespace(); ConsumeType(TokenType.OpenParenthesis, "Expected open parenthesis after foreach keyword.", "LSS029"); SkipWhitespace(); ConsumeType(TokenType.KeywordVar, "Expected var keyword when declaring iteration variable.", "LSS030"); SkipWhitespace(); Token variableName = ConsumeType(TokenType.Symbol, "Expected name of iteration variable.", "LSS031"); SkipWhitespace(); ConsumeType(TokenType.Colon, "Expected colon after iteration variable.", "LSS032"); SkipWhitespace(); Expression collection = ParseExpression(); SkipWhitespace(); ConsumeType(TokenType.CloseParenthesis, "Expected close parenthesis after collection.", "LSS033"); SkipWhitespace(); InstructionStatement body = ParseInstructionStatement(); span += body.Span; return(new ForEachStatement(span, variableName, collection, body)); }
private IfStatement ParseIfStatement() { Token ifKeyword = ConsumeType(TokenType.KeywordIf, "Expected if keyword.", "LSS025"); SourceSpan span = ifKeyword.Span; SkipWhitespace(); ConsumeType(TokenType.OpenParenthesis, "Expected an open parenthesis after if keyword.", "LSS026"); Expression condition = ParseExpression(); SkipWhitespace(); ConsumeType(TokenType.CloseParenthesis, "Expected a close parenthesis after if condition.", "LSS027"); InstructionStatement body = ParseInstructionStatement(); span = span + body.Span; SkipWhitespace(); IfStatement elseStatement = null; if (ConsumeIfType(out Token elseKeyword, TokenType.KeywordElse)) { SkipWhitespace(); if (Peek().Type == TokenType.KeywordIf) { elseStatement = ParseIfStatement(); } else { InstructionStatement elseBody = ParseInstructionStatement(); elseStatement = new IfStatement(elseKeyword.Span + elseBody.Span, null, elseBody, null); } span = span + elseStatement.Span; SkipWhitespace(); } return(new IfStatement(span, condition, body, elseStatement)); }
private DoWhileStatement ParseDoWhileStatement() { Token doKeyword = ConsumeType(TokenType.KeywordDo, "", ""); SkipWhitespace(); InstructionStatement body = ParseInstructionStatement(); SkipWhitespace(); ConsumeType(TokenType.KeywordWhile, "Expected do statement to have a while keyword after the body.", "LSS034"); SkipWhitespace(); ConsumeType(TokenType.OpenParenthesis, "Expected do statement to have a condition after the while", "LSS035"); Expression condition = ParseExpression(); SkipWhitespace(); Token endParenthesis = ConsumeType(TokenType.CloseParenthesis, "Expected do statement condition to have a closing parenthesis after the condition.", "LSS036"); return(new DoWhileStatement(doKeyword.Span + endParenthesis.Span, body, condition)); }
public DoWhileStatement(SourceSpan span, InstructionStatement body, Expressions.Expression condition) { this.Span = span; this.Condition = condition; this.Body = body; }
private InstructionStatement ParseInstructionStatement() { // { means block SkipWhitespace(); if (Peek().Type == TokenType.OpenBrace) { return(ParseBlockStatement()); } else if (Peek().Type == TokenType.KeywordIf) { return(ParseIfStatement()); } else if (Peek().Type == TokenType.KeywordForEach) { return(ParseForEachStatement()); } else if (Peek().Type == TokenType.KeywordDo) { return(ParseDoWhileStatement()); } else if (ConsumeIfType(out Token whileKeyword, TokenType.KeywordWhile)) { SkipWhitespace(); ConsumeType(TokenType.OpenParenthesis, "Expected an open parenthesis after while keyword.", "LSS037"); Expression condition = ParseExpression(); SkipWhitespace(); ConsumeType(TokenType.CloseParenthesis, "Expected a close parenthesis after while condition.", "LSS038"); InstructionStatement body = ParseInstructionStatement(); return(new WhileStatement(whileKeyword.Span + body.Span, condition, body)); } else if (ConsumeIfType(out Token returnKeyword, TokenType.KeywordReturn)) { if (ConsumeIfType(out _, TokenType.Semicolon)) { return(new ReturnStatement(returnKeyword, null)); } else { Expression value = ParseExpression(); SkipWhitespace(); ConsumeType(TokenType.Semicolon, "Expected a semicolon after expression to return.", "LSS039"); return(new ReturnStatement(returnKeyword, value)); } } else if (ConsumeIfType(out Token varKeyword, TokenType.KeywordVar)) { SkipWhitespace(); Token name = ConsumeType(TokenType.Symbol, "Expected a name for variable declaration.", "LSS040"); Expression initializer = null; SkipWhitespace(); if (ConsumeIfType(out _, TokenType.Equals)) { initializer = ParseExpression(); } SkipWhitespace(); ConsumeType(TokenType.Semicolon, "Expected a semicolon after variable initializer.", "LSS041"); return(new VariableDeclarationStatement(varKeyword.Span + name.Span, name, initializer)); } else { Expression value = ParseExpression(); SkipWhitespace(); if (ConsumeIfType(out Token equalsOperator, TokenType.Equals)) { Expression rhs = ParseExpression(); SkipWhitespace(); ConsumeType(TokenType.Semicolon, "Expected semicolon after assignment statement.", "LSS042"); return(new AssignmentStatement(value, rhs)); } else { ConsumeType(TokenType.Semicolon, "Expected semicolon after expression statement.", "LSS043"); return(new ExpressionStatement(value)); } } }