- Some minor formatting.

- Parser can now handle return statements.

git-svn-id: https://svn.tlawal.org/svn/monkey@21 f6afcba9-9ef1-4bdd-9b72-7484f5705bac

ast/ast.go

@@ -26,11 +26,16 @@ type Identifier struct {
 }
 
 type LetStatement struct {
-	Token token.Token // the token.LET token
+	Token token.Token // token.LET token
 	Name  *Identifier
 	Value Expression
 }
 
+type ReturnStatement struct {
+	Token       token.Token // token.RETURN token
+	ReturnValue Expression
+}
+
 func (ls *LetStatement) statement_node() {}
 
 func (ls *LetStatement) TokenLiteral() string {
@@ -50,3 +55,9 @@ func (p *Program) TokenLiteral() string {
 		return ""
 	}
 }
+
+func (rs *ReturnStatement) statement_node() {}
+
+func (rs *ReturnStatement) TokenLiteral() string {
+	return rs.Token.Literal
+}

parser/parser.go

@@ -52,6 +52,8 @@ func (l_parser *Parser) parse_statement() ast.Statement {
 	switch l_parser.current_token.Type {
 	case token.LET:
 		return l_parser.parse_let_statement()
+	case token.RETURN:
+		return l_parser.parse_return_statement()
 	default:
 		return nil
 	}
@@ -75,6 +77,17 @@ func (l_parser *Parser) parse_let_statement() *ast.LetStatement {
 	return statement
 }
 
+func (l_parser *Parser) parse_return_statement() *ast.ReturnStatement {
+	statement := &ast.ReturnStatement{Token: l_parser.current_token}
+	l_parser.next_token()
+
+	// TODO(tijani): Skipping the expression until there is semicolon
+	for !l_parser.current_token_is(token.SEMICOLON) {
+		l_parser.next_token()
+	}
+	return statement
+}
+
 func (l_parser *Parser) expect_peek(l_token token.TokenType) bool {
 	if l_parser.peek_token_is(l_token) {
 		l_parser.next_token()

parser/parser_test.go

@@ -6,6 +6,20 @@ import (
 	"testing"
 )
 
+func check_parser_errors(l_test *testing.T, l_parser *Parser) {
+	errors := l_parser.Errors()
+	if len(errors) == 0 {
+		return
+	}
+
+	l_test.Errorf("parser has %d errors", len(errors))
+
+	for _, message := range errors {
+		l_test.Errorf("parser error: %q", message)
+	}
+	l_test.FailNow()
+}
+
 func TestLetStatement(l_test *testing.T) {
 	input := `
    let x = 4;
@@ -68,16 +82,33 @@ func testLetStatement(l_test *testing.T, statement ast.Statement, name string) b
 	return true
 }
 
-func check_parser_errors(l_test *testing.T, l_parser *Parser) {
-	errors := l_parser.Errors()
-	if len(errors) == 0 {
-		return
+func TestReturnStatement(l_test *testing.T) {
+	input := `
+   return 6;
+   return 10;
+   return 8419849;
+  `
+
+	l_lexer := lexer.New(input)
+	l_parser := New(l_lexer)
+
+	program := l_parser.ParseProgram()
+	check_parser_errors(l_test, l_parser)
+
+	if len(program.Statements) != 3 {
+		l_test.Fatalf("program.Statements does not contain 3 statements, got=%d", len(program.Statements))
 	}
 
-	l_test.Errorf("parser has %d errors", len(errors))
+	for _, statement := range program.Statements {
+		return_statement, ok := statement.(*ast.ReturnStatement)
 
-	for _, message := range errors {
-		l_test.Errorf("parser error: %q", message)
+		if !ok {
+			l_test.Errorf("statment not *ast.ReturnStatement, got =%T", statement)
+			continue
+		}
+
+		if return_statement.TokenLiteral() != "return" {
+			l_test.Errorf("return_statement.TokenLiteral() not 'return', got %q", return_statement.TokenLiteral())
+		}
 	}
-	l_test.FailNow()
 }