imported interpreter code (a64cf4ce) · Commits · bsmrgo / monkey

ast/ast.go

0 → 100644

+339 −0

Original line number	Diff line number	Diff line
		package ast

		import (
		"bytes"
		"monkey/token"
		"strings"
		)

		// The base Node interface
		type Node interface {
		TokenLiteral() string
		String() string
		}

		// All statement nodes implement this
		type Statement interface {
		Node
		statementNode()
		}

		// All expression nodes implement this
		type Expression interface {
		Node
		expressionNode()
		}

		type Program struct {
		Statements []Statement
		}

		func (p *Program) TokenLiteral() string {
		if len(p.Statements) > 0 {
		return p.Statements[0].TokenLiteral()
		} else {
		return ""
		}
		}

		func (p *Program) String() string {
		var out bytes.Buffer

		for _, s := range p.Statements {
		out.WriteString(s.String())
		}

		return out.String()
		}

		// Statements
		type LetStatement struct {
		Token token.Token // the token.LET token
		Name *Identifier
		Value Expression
		}

		func (ls *LetStatement) statementNode() {}
		func (ls *LetStatement) TokenLiteral() string { return ls.Token.Literal }
		func (ls *LetStatement) String() string {
		var out bytes.Buffer

		out.WriteString(ls.TokenLiteral() + " ")
		out.WriteString(ls.Name.String())
		out.WriteString(" = ")

		if ls.Value != nil {
		out.WriteString(ls.Value.String())
		}

		out.WriteString(";")

		return out.String()
		}

		type ReturnStatement struct {
		Token token.Token // the 'return' token
		ReturnValue Expression
		}

		func (rs *ReturnStatement) statementNode() {}
		func (rs *ReturnStatement) TokenLiteral() string { return rs.Token.Literal }
		func (rs *ReturnStatement) String() string {
		var out bytes.Buffer

		out.WriteString(rs.TokenLiteral() + " ")

		if rs.ReturnValue != nil {
		out.WriteString(rs.ReturnValue.String())
		}

		out.WriteString(";")

		return out.String()
		}

		type ExpressionStatement struct {
		Token token.Token // the first token of the expression
		Expression Expression
		}

		func (es *ExpressionStatement) statementNode() {}
		func (es *ExpressionStatement) TokenLiteral() string { return es.Token.Literal }
		func (es *ExpressionStatement) String() string {
		if es.Expression != nil {
		return es.Expression.String()
		}
		return ""
		}

		type BlockStatement struct {
		Token token.Token // the { token
		Statements []Statement
		}

		func (bs *BlockStatement) statementNode() {}
		func (bs *BlockStatement) TokenLiteral() string { return bs.Token.Literal }
		func (bs *BlockStatement) String() string {
		var out bytes.Buffer

		for _, s := range bs.Statements {
		out.WriteString(s.String())
		}

		return out.String()
		}

		// Expressions
		type Identifier struct {
		Token token.Token // the token.IDENT token
		Value string
		}

		func (i *Identifier) expressionNode() {}
		func (i *Identifier) TokenLiteral() string { return i.Token.Literal }
		func (i *Identifier) String() string { return i.Value }

		type Boolean struct {
		Token token.Token
		Value bool
		}

		func (b *Boolean) expressionNode() {}
		func (b *Boolean) TokenLiteral() string { return b.Token.Literal }
		func (b *Boolean) String() string { return b.Token.Literal }

		type IntegerLiteral struct {
		Token token.Token
		Value int64
		}

		func (il *IntegerLiteral) expressionNode() {}
		func (il *IntegerLiteral) TokenLiteral() string { return il.Token.Literal }
		func (il *IntegerLiteral) String() string { return il.Token.Literal }

		type PrefixExpression struct {
		Token token.Token // The prefix token, e.g. !
		Operator string
		Right Expression
		}

		func (pe *PrefixExpression) expressionNode() {}
		func (pe *PrefixExpression) TokenLiteral() string { return pe.Token.Literal }
		func (pe *PrefixExpression) String() string {
		var out bytes.Buffer

		out.WriteString("(")
		out.WriteString(pe.Operator)
		out.WriteString(pe.Right.String())
		out.WriteString(")")

		return out.String()
		}

		type InfixExpression struct {
		Token token.Token // The operator token, e.g. +
		Left Expression
		Operator string
		Right Expression
		}

		func (ie *InfixExpression) expressionNode() {}
		func (ie *InfixExpression) TokenLiteral() string { return ie.Token.Literal }
		func (ie *InfixExpression) String() string {
		var out bytes.Buffer

		out.WriteString("(")
		out.WriteString(ie.Left.String())
		out.WriteString(" " + ie.Operator + " ")
		out.WriteString(ie.Right.String())
		out.WriteString(")")

		return out.String()
		}

		type IfExpression struct {
		Token token.Token // The 'if' token
		Condition Expression
		Consequence *BlockStatement
		Alternative *BlockStatement
		}

		func (ie *IfExpression) expressionNode() {}
		func (ie *IfExpression) TokenLiteral() string { return ie.Token.Literal }
		func (ie *IfExpression) String() string {
		var out bytes.Buffer

		out.WriteString("if")
		out.WriteString(ie.Condition.String())
		out.WriteString(" ")
		out.WriteString(ie.Consequence.String())

		if ie.Alternative != nil {
		out.WriteString("else ")
		out.WriteString(ie.Alternative.String())
		}

		return out.String()
		}

		type FunctionLiteral struct {
		Token token.Token // The 'fn' token
		Parameters []*Identifier
		Body *BlockStatement
		}

		func (fl *FunctionLiteral) expressionNode() {}
		func (fl *FunctionLiteral) TokenLiteral() string { return fl.Token.Literal }
		func (fl *FunctionLiteral) String() string {
		var out bytes.Buffer

		params := []string{}
		for _, p := range fl.Parameters {
		params = append(params, p.String())
		}

		out.WriteString(fl.TokenLiteral())
		out.WriteString("(")
		out.WriteString(strings.Join(params, ", "))
		out.WriteString(") ")
		out.WriteString(fl.Body.String())

		return out.String()
		}

		type CallExpression struct {
		Token token.Token // The '(' token
		Function Expression // Identifier or FunctionLiteral
		Arguments []Expression
		}

		func (ce *CallExpression) expressionNode() {}
		func (ce *CallExpression) TokenLiteral() string { return ce.Token.Literal }
		func (ce *CallExpression) String() string {
		var out bytes.Buffer

		args := []string{}
		for _, a := range ce.Arguments {
		args = append(args, a.String())
		}

		out.WriteString(ce.Function.String())
		out.WriteString("(")
		out.WriteString(strings.Join(args, ", "))
		out.WriteString(")")

		return out.String()
		}

		type StringLiteral struct {
		Token token.Token
		Value string
		}

		func (sl *StringLiteral) expressionNode() {}
		func (sl *StringLiteral) TokenLiteral() string { return sl.Token.Literal }
		func (sl *StringLiteral) String() string { return sl.Token.Literal }

		type ArrayLiteral struct {
		Token token.Token // the '[' token
		Elements []Expression
		}

		func (al *ArrayLiteral) expressionNode() {}
		func (al *ArrayLiteral) TokenLiteral() string { return al.Token.Literal }
		func (al *ArrayLiteral) String() string {
		var out bytes.Buffer

		elements := []string{}
		for _, el := range al.Elements {
		elements = append(elements, el.String())
		}

		out.WriteString("[")
		out.WriteString(strings.Join(elements, ", "))
		out.WriteString("]")

		return out.String()
		}

		type IndexExpression struct {
		Token token.Token // The [ token
		Left Expression
		Index Expression
		}

		func (ie *IndexExpression) expressionNode() {}
		func (ie *IndexExpression) TokenLiteral() string { return ie.Token.Literal }
		func (ie *IndexExpression) String() string {
		var out bytes.Buffer

		out.WriteString("(")
		out.WriteString(ie.Left.String())
		out.WriteString("[")
		out.WriteString(ie.Index.String())
		out.WriteString("])")

		return out.String()
		}

		type HashLiteral struct {
		Token token.Token // the '{' token
		Pairs map[Expression]Expression
		}

		func (hl *HashLiteral) expressionNode() {}
		func (hl *HashLiteral) TokenLiteral() string { return hl.Token.Literal }
		func (hl *HashLiteral) String() string {
		var out bytes.Buffer

		pairs := []string{}
		for key, value := range hl.Pairs {
		pairs = append(pairs, key.String()+":"+value.String())
		}

		out.WriteString("{")
		out.WriteString(strings.Join(pairs, ", "))
		out.WriteString("}")

		return out.String()
		}

ast/ast_test.go

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		package ast

		import (
		"monkey/token"
		"testing"
		)

		func TestString(t *testing.T) {
		program := &Program{
		Statements: []Statement{
		&LetStatement{
		Token: token.Token{Type: token.LET, Literal: "let"},
		Name: &Identifier{
		Token: token.Token{Type: token.IDENT, Literal: "myVar"},
		Value: "myVar",
		},
		Value: &Identifier{
		Token: token.Token{Type: token.IDENT, Literal: "anotherVar"},
		Value: "anotherVar",
		},
		},
		},
		}

		if program.String() != "let myVar = anotherVar;" {
		t.Errorf("program.String() wrong. got=%q", program.String())
		}
		}

evaluator/builtins.go

0 → 100644

+117 −0

Original line number	Diff line number	Diff line
		package evaluator

		import (
		"fmt"
		"monkey/object"
		)

		var builtins = map[string]*object.Builtin{
		"len": &object.Builtin{Fn: func(args ...object.Object) object.Object {
		if len(args) != 1 {
		return newError("wrong number of arguments. got=%d, want=1",
		len(args))
		}

		switch arg := args[0].(type) {
		case *object.Array:
		return &object.Integer{Value: int64(len(arg.Elements))}
		case *object.String:
		return &object.Integer{Value: int64(len(arg.Value))}
		default:
		return newError("argument to `len` not supported, got %s",
		args[0].Type())
		}
		},
		},
		"puts": &object.Builtin{
		Fn: func(args ...object.Object) object.Object {
		for _, arg := range args {
		fmt.Println(arg.Inspect())
		}

		return NULL
		},
		},
		"first": &object.Builtin{
		Fn: func(args ...object.Object) object.Object {
		if len(args) != 1 {
		return newError("wrong number of arguments. got=%d, want=1",
		len(args))
		}
		if args[0].Type() != object.ARRAY_OBJ {
		return newError("argument to `first` must be ARRAY, got %s",
		args[0].Type())
		}

		arr := args[0].(*object.Array)
		if len(arr.Elements) > 0 {
		return arr.Elements[0]
		}

		return NULL
		},
		},
		"last": &object.Builtin{
		Fn: func(args ...object.Object) object.Object {
		if len(args) != 1 {
		return newError("wrong number of arguments. got=%d, want=1",
		len(args))
		}
		if args[0].Type() != object.ARRAY_OBJ {
		return newError("argument to `last` must be ARRAY, got %s",
		args[0].Type())
		}

		arr := args[0].(*object.Array)
		length := len(arr.Elements)
		if length > 0 {
		return arr.Elements[length-1]
		}

		return NULL
		},
		},
		"rest": &object.Builtin{
		Fn: func(args ...object.Object) object.Object {
		if len(args) != 1 {
		return newError("wrong number of arguments. got=%d, want=1",
		len(args))
		}
		if args[0].Type() != object.ARRAY_OBJ {
		return newError("argument to `rest` must be ARRAY, got %s",
		args[0].Type())
		}

		arr := args[0].(*object.Array)
		length := len(arr.Elements)
		if length > 0 {
		newElements := make([]object.Object, length-1, length-1)
		copy(newElements, arr.Elements[1:length])
		return &object.Array{Elements: newElements}
		}

		return NULL
		},
		},
		"push": &object.Builtin{
		Fn: func(args ...object.Object) object.Object {
		if len(args) != 2 {
		return newError("wrong number of arguments. got=%d, want=2",
		len(args))
		}
		if args[0].Type() != object.ARRAY_OBJ {
		return newError("argument to `push` must be ARRAY, got %s",
		args[0].Type())
		}

		arr := args[0].(*object.Array)
		length := len(arr.Elements)

		newElements := make([]object.Object, length+1, length+1)
		copy(newElements, arr.Elements)
		newElements[length] = args[1]

		return &object.Array{Elements: newElements}
		},
		},
		}

evaluator/evaluator.go

0 → 100644

+442 −0

Original line number	Diff line number	Diff line
		package evaluator

		import (
		"fmt"
		"monkey/ast"
		"monkey/object"
		)

		var (
		NULL = &object.Null{}
		TRUE = &object.Boolean{Value: true}
		FALSE = &object.Boolean{Value: false}
		)

		func Eval(node ast.Node, env *object.Environment) object.Object {
		switch node := node.(type) {

		// Statements
		case *ast.Program:
		return evalProgram(node, env)

		case *ast.BlockStatement:
		return evalBlockStatement(node, env)

		case *ast.ExpressionStatement:
		return Eval(node.Expression, env)

		case *ast.ReturnStatement:
		val := Eval(node.ReturnValue, env)
		if isError(val) {
		return val
		}
		return &object.ReturnValue{Value: val}

		case *ast.LetStatement:
		val := Eval(node.Value, env)
		if isError(val) {
		return val
		}
		env.Set(node.Name.Value, val)

		// Expressions
		case *ast.IntegerLiteral:
		return &object.Integer{Value: node.Value}

		case *ast.StringLiteral:
		return &object.String{Value: node.Value}

		case *ast.Boolean:
		return nativeBoolToBooleanObject(node.Value)

		case *ast.PrefixExpression:
		right := Eval(node.Right, env)
		if isError(right) {
		return right
		}
		return evalPrefixExpression(node.Operator, right)

		case *ast.InfixExpression:
		left := Eval(node.Left, env)
		if isError(left) {
		return left
		}

		right := Eval(node.Right, env)
		if isError(right) {
		return right
		}

		return evalInfixExpression(node.Operator, left, right)

		case *ast.IfExpression:
		return evalIfExpression(node, env)

		case *ast.Identifier:
		return evalIdentifier(node, env)

		case *ast.FunctionLiteral:
		params := node.Parameters
		body := node.Body
		return &object.Function{Parameters: params, Env: env, Body: body}

		case *ast.CallExpression:
		function := Eval(node.Function, env)
		if isError(function) {
		return function
		}

		args := evalExpressions(node.Arguments, env)
		if len(args) == 1 && isError(args[0]) {
		return args[0]
		}

		return applyFunction(function, args)

		case *ast.ArrayLiteral:
		elements := evalExpressions(node.Elements, env)
		if len(elements) == 1 && isError(elements[0]) {
		return elements[0]
		}
		return &object.Array{Elements: elements}

		case *ast.IndexExpression:
		left := Eval(node.Left, env)
		if isError(left) {
		return left
		}
		index := Eval(node.Index, env)
		if isError(index) {
		return index
		}
		return evalIndexExpression(left, index)

		case *ast.HashLiteral:
		return evalHashLiteral(node, env)

		}

		return nil
		}

		func evalProgram(program ast.Program, env object.Environment) object.Object {
		var result object.Object

		for _, statement := range program.Statements {
		result = Eval(statement, env)

		switch result := result.(type) {
		case *object.ReturnValue:
		return result.Value
		case *object.Error:
		return result
		}
		}

		return result
		}

		func evalBlockStatement(
		block *ast.BlockStatement,
		env *object.Environment,
		) object.Object {
		var result object.Object

		for _, statement := range block.Statements {
		result = Eval(statement, env)

		if result != nil {
		rt := result.Type()
		if rt == object.RETURN_VALUE_OBJ \|\| rt == object.ERROR_OBJ {
		return result
		}
		}
		}

		return result
		}

		func nativeBoolToBooleanObject(input bool) *object.Boolean {
		if input {
		return TRUE
		}
		return FALSE
		}

		func evalPrefixExpression(operator string, right object.Object) object.Object {
		switch operator {
		case "!":
		return evalBangOperatorExpression(right)
		case "-":
		return evalMinusPrefixOperatorExpression(right)
		default:
		return newError("unknown operator: %s%s", operator, right.Type())
		}
		}

		func evalInfixExpression(
		operator string,
		left, right object.Object,
		) object.Object {
		switch {
		case left.Type() == object.INTEGER_OBJ && right.Type() == object.INTEGER_OBJ:
		return evalIntegerInfixExpression(operator, left, right)
		case left.Type() == object.STRING_OBJ && right.Type() == object.STRING_OBJ:
		return evalStringInfixExpression(operator, left, right)
		case operator == "==":
		return nativeBoolToBooleanObject(left == right)
		case operator == "!=":
		return nativeBoolToBooleanObject(left != right)
		case left.Type() != right.Type():
		return newError("type mismatch: %s %s %s",
		left.Type(), operator, right.Type())
		default:
		return newError("unknown operator: %s %s %s",
		left.Type(), operator, right.Type())
		}
		}

		func evalBangOperatorExpression(right object.Object) object.Object {
		switch right {
		case TRUE:
		return FALSE
		case FALSE:
		return TRUE
		case NULL:
		return TRUE
		default:
		return FALSE
		}
		}

		func evalMinusPrefixOperatorExpression(right object.Object) object.Object {
		if right.Type() != object.INTEGER_OBJ {
		return newError("unknown operator: -%s", right.Type())
		}

		value := right.(*object.Integer).Value
		return &object.Integer{Value: -value}
		}

		func evalIntegerInfixExpression(
		operator string,
		left, right object.Object,
		) object.Object {
		leftVal := left.(*object.Integer).Value
		rightVal := right.(*object.Integer).Value

		switch operator {
		case "+":
		return &object.Integer{Value: leftVal + rightVal}
		case "-":
		return &object.Integer{Value: leftVal - rightVal}
		case "*":
		return &object.Integer{Value: leftVal * rightVal}
		case "/":
		return &object.Integer{Value: leftVal / rightVal}
		case "<":
		return nativeBoolToBooleanObject(leftVal < rightVal)
		case ">":
		return nativeBoolToBooleanObject(leftVal > rightVal)
		case "==":
		return nativeBoolToBooleanObject(leftVal == rightVal)
		case "!=":
		return nativeBoolToBooleanObject(leftVal != rightVal)
		default:
		return newError("unknown operator: %s %s %s",
		left.Type(), operator, right.Type())
		}
		}

		func evalStringInfixExpression(
		operator string,
		left, right object.Object,
		) object.Object {
		if operator != "+" {
		return newError("unknown operator: %s %s %s",
		left.Type(), operator, right.Type())
		}

		leftVal := left.(*object.String).Value
		rightVal := right.(*object.String).Value
		return &object.String{Value: leftVal + rightVal}
		}

		func evalIfExpression(
		ie *ast.IfExpression,
		env *object.Environment,
		) object.Object {
		condition := Eval(ie.Condition, env)
		if isError(condition) {
		return condition
		}

		if isTruthy(condition) {
		return Eval(ie.Consequence, env)
		} else if ie.Alternative != nil {
		return Eval(ie.Alternative, env)
		} else {
		return NULL
		}
		}

		func evalIdentifier(
		node *ast.Identifier,
		env *object.Environment,
		) object.Object {
		if val, ok := env.Get(node.Value); ok {
		return val
		}

		if builtin, ok := builtins[node.Value]; ok {
		return builtin
		}

		return newError("identifier not found: " + node.Value)
		}

		func isTruthy(obj object.Object) bool {
		switch obj {
		case NULL:
		return false
		case TRUE:
		return true
		case FALSE:
		return false
		default:
		return true
		}
		}

		func newError(format string, a ...interface{}) *object.Error {
		return &object.Error{Message: fmt.Sprintf(format, a...)}
		}

		func isError(obj object.Object) bool {
		if obj != nil {
		return obj.Type() == object.ERROR_OBJ
		}
		return false
		}

		func evalExpressions(
		exps []ast.Expression,
		env *object.Environment,
		) []object.Object {
		var result []object.Object

		for _, e := range exps {
		evaluated := Eval(e, env)
		if isError(evaluated) {
		return []object.Object{evaluated}
		}
		result = append(result, evaluated)
		}

		return result
		}

		func applyFunction(fn object.Object, args []object.Object) object.Object {
		switch fn := fn.(type) {

		case *object.Function:
		extendedEnv := extendFunctionEnv(fn, args)
		evaluated := Eval(fn.Body, extendedEnv)
		return unwrapReturnValue(evaluated)

		case *object.Builtin:
		return fn.Fn(args...)

		default:
		return newError("not a function: %s", fn.Type())
		}
		}

		func extendFunctionEnv(
		fn *object.Function,
		args []object.Object,
		) *object.Environment {
		env := object.NewEnclosedEnvironment(fn.Env)

		for paramIdx, param := range fn.Parameters {
		env.Set(param.Value, args[paramIdx])
		}

		return env
		}

		func unwrapReturnValue(obj object.Object) object.Object {
		if returnValue, ok := obj.(*object.ReturnValue); ok {
		return returnValue.Value
		}

		return obj
		}

		func evalIndexExpression(left, index object.Object) object.Object {
		switch {
		case left.Type() == object.ARRAY_OBJ && index.Type() == object.INTEGER_OBJ:
		return evalArrayIndexExpression(left, index)
		case left.Type() == object.HASH_OBJ:
		return evalHashIndexExpression(left, index)
		default:
		return newError("index operator not supported: %s", left.Type())
		}
		}

		func evalArrayIndexExpression(array, index object.Object) object.Object {
		arrayObject := array.(*object.Array)
		idx := index.(*object.Integer).Value
		max := int64(len(arrayObject.Elements) - 1)

		if idx < 0 \|\| idx > max {
		return NULL
		}

		return arrayObject.Elements[idx]
		}

		func evalHashLiteral(
		node *ast.HashLiteral,
		env *object.Environment,
		) object.Object {
		pairs := make(map[object.HashKey]object.HashPair)

		for keyNode, valueNode := range node.Pairs {
		key := Eval(keyNode, env)
		if isError(key) {
		return key
		}

		hashKey, ok := key.(object.Hashable)
		if !ok {
		return newError("unusable as hash key: %s", key.Type())
		}

		value := Eval(valueNode, env)
		if isError(value) {
		return value
		}

		hashed := hashKey.HashKey()
		pairs[hashed] = object.HashPair{Key: key, Value: value}
		}

		return &object.Hash{Pairs: pairs}
		}

		func evalHashIndexExpression(hash, index object.Object) object.Object {
		hashObject := hash.(*object.Hash)

		key, ok := index.(object.Hashable)
		if !ok {
		return newError("unusable as hash key: %s", index.Type())
		}

		pair, ok := hashObject.Pairs[key.HashKey()]
		if !ok {
		return NULL
		}

		return pair.Value
		}

evaluator/evaluator_test.go

0 → 100644

+629 −0

File added.

Preview size limit exceeded, changes collapsed.