Add Break and Continue

Author: AvicennaJr

ast/ast.go

@@ -375,3 +375,21 @@ type Null struct {
 func (n *Null) expressionNode()      {}
 func (n *Null) TokenLiteral() string { return n.Token.Literal }
 func (n *Null) String() string       { return n.Token.Literal }
+
+type Break struct {
+	Statement
+	Token token.Token // the 'break' token
+}
+
+func (b *Break) expressionNode()      {}
+func (b *Break) TokenLiteral() string { return b.Token.Literal }
+func (b *Break) String() string       { return b.Token.Literal }
+
+type Continue struct {
+	Statement
+	Token token.Token // the 'continue' token
+}
+
+func (c *Continue) expressionNode()      {}
+func (c *Continue) TokenLiteral() string { return c.Token.Literal }
+func (c *Continue) String() string       { return c.Token.Literal }

evaluator/evaluator.go

@@ -10,9 +10,11 @@ import (
 )
 
 var (
-	NULL  = &object.Null{}
-	TRUE  = &object.Boolean{Value: true}
-	FALSE = &object.Boolean{Value: false}
+	NULL     = &object.Null{}
+	TRUE     = &object.Boolean{Value: true}
+	FALSE    = &object.Boolean{Value: false}
+	BREAK    = &object.Break{}
+	CONTINUE = &object.Continue{}
 )
 
 func Eval(node ast.Node, env *object.Environment) object.Object {
@@ -109,6 +111,10 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 		return evalDictLiteral(node, env)
 	case *ast.WhileExpression:
 		return evalWhileExpression(node, env)
+	case *ast.Break:
+		return evalBreak(node)
+	case *ast.Continue:
+		return evalContinue(node)
 	case *ast.Null:
 		return NULL
 	case *ast.AssignmentExpression:
@@ -381,7 +387,7 @@ func evalBlockStatement(block *ast.BlockStatement, env *object.Environment) obje
 
 		if result != nil {
 			rt := result.Type()
-			if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ {
+			if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ || rt == object.CONTINUE_OBJ || rt == object.BREAK_OBJ {
 				return result
 			}
 		}
@@ -550,23 +556,27 @@ func evalDictIndexExpression(dict, index object.Object, line int) object.Object
 }
 
 func evalWhileExpression(we *ast.WhileExpression, env *object.Environment) object.Object {
-	var result object.Object
-
-	for {
-		condition := Eval(we.Condition, env)
-		if isError(condition) {
-			return condition
+	condition := Eval(we.Condition, env)
+	if isError(condition) {
+		return condition
+	}
+	if isTruthy(condition) {
+		evaluated := Eval(we.Consequence, env)
+		if isError(evaluated) {
+			return evaluated
 		}
-
-		if isTruthy(condition) {
-			result = Eval(we.Consequence, env)
-		} else {
-			break
+		if evaluated.Type() == object.BREAK_OBJ {
+			return evaluated
 		}
+		evalWhileExpression(we, env)
 	}
+	return NULL
+}
 
-	if result != nil {
-		return result
-	}
-	return nil
+func evalBreak(node *ast.Break) object.Object {
+	return BREAK
+}
+
+func evalContinue(node *ast.Continue) object.Object {
+	return CONTINUE
 }

object/object.go

@@ -22,6 +22,8 @@ const (
 	BUILTIN_OBJ      = "YA_NDANI"
 	ARRAY_OBJ        = "ARRAY"
 	DICT_OBJ         = "KAMUSI"
+	CONTINUE_OBJ     = "ENDELEA"
+	BREAK_OBJ        = "SUSA"
 )
 
 type Object interface {
@@ -189,3 +191,13 @@ func (d *Dict) Inspect() string {
 type Hashable interface {
 	HashKey() HashKey
 }
+
+type Continue struct{}
+
+func (c *Continue) Type() ObjectType { return CONTINUE_OBJ }
+func (c *Continue) Inspect() string  { return "continue" }
+
+type Break struct{}
+
+func (b *Break) Type() ObjectType { return BREAK_OBJ }
+func (b *Break) Inspect() string  { return "break" }

parser/parser.go

@@ -134,6 +134,10 @@ func (p *Parser) parseStatement() ast.Statement {
 		return p.parseLetStatment()
 	case token.RETURN:
 		return p.parseReturnStatement()
+	case token.BREAK:
+		return p.parseBreak()
+	case token.CONTINUE:
+		return p.parseContinue()
 	default:
 		return p.parseExpressionStatement()
 	}
@@ -560,3 +564,19 @@ func (p *Parser) parseWhileExpression() ast.Expression {
 
 	return expression
 }
+
+func (p *Parser) parseBreak() *ast.Break {
+	stmt := &ast.Break{Token: p.curToken}
+	for p.curTokenIs(token.SEMICOLON) {
+		p.nextToken()
+	}
+	return stmt
+}
+
+func (p *Parser) parseContinue() *ast.Continue {
+	stmt := &ast.Continue{Token: p.curToken}
+	for p.curTokenIs(token.SEMICOLON) {
+		p.nextToken()
+	}
+	return stmt
+}