imported, merged, and basic cleanup of interpreter and compiler sources (c623297d) · Commits · bsmrgo / monkey

.gitignore

0 → 100644

+6 −0

Original line number	Diff line number	Diff line
		# === files git should ignore ===

		# binaries
		bin/*

		# === End Of FIle ===

ast/ast.go

0 → 100644

+344 −0

Original line number	Diff line number	Diff line
		package ast

		import (
		"bytes"
		"fmt"
		"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 (oe *InfixExpression) expressionNode() {}
		func (oe *InfixExpression) TokenLiteral() string { return oe.Token.Literal }
		func (oe *InfixExpression) String() string {
		var out bytes.Buffer

		out.WriteString("(")
		out.WriteString(oe.Left.String())
		out.WriteString(" " + oe.Operator + " ")
		out.WriteString(oe.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
		Name string
		}

		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())
		if fl.Name != "" {
		out.WriteString(fmt.Sprintf("<%s>", fl.Name))
		}
		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())
		}
		}

benchmark/main.go

0 → 100644

+75 −0

Original line number	Diff line number	Diff line
		package main

		import (
		"flag"
		"fmt"
		"time"

		"monkey/compiler"
		"monkey/evaluator"
		"monkey/lexer"
		"monkey/object"
		"monkey/parser"
		"monkey/vm"
		)

		var engine = flag.String("engine", "vm", "use 'vm' or 'eval'")

		var input = `
		let fibonacci = fn(x) {
		if (x == 0) {
		0
		} else {
		if (x == 1) {
		return 1;
		} else {
		fibonacci(x - 1) + fibonacci(x - 2);
		}
		}
		};
		fibonacci(35);
		`

		func main() {
		flag.Parse()

		var duration time.Duration
		var result object.Object

		l := lexer.New(input)
		p := parser.New(l)
		program := p.ParseProgram()

		if *engine == "vm" {
		comp := compiler.New()
		err := comp.Compile(program)
		if err != nil {
		fmt.Printf("compiler error: %s", err)
		return
		}

		machine := vm.New(comp.Bytecode())

		start := time.Now()

		err = machine.Run()
		if err != nil {
		fmt.Printf("vm error: %s", err)
		return
		}

		duration = time.Since(start)
		result = machine.LastPoppedStackElem()
		} else {
		env := object.NewEnvironment()
		start := time.Now()
		result = evaluator.Eval(program, env)
		duration = time.Since(start)
		}

		fmt.Printf(
		"engine=%s, result=%s, duration=%s\n",
		*engine,
		result.Inspect(),
		duration)
		}

cmd/compiler/main.go

0 → 100644

+19 −0

Original line number	Diff line number	Diff line
		package main

		import (
		"fmt"
		"monkey/repl"
		"os"
		"os/user"
		)

		func main() {
		user, err := user.Current()
		if err != nil {
		panic(err)
		}
		fmt.Printf("Hello %s! This is the Monkey programming language!\n",
		user.Username)
		fmt.Printf("Feel free to type in commands\n")
		repl.Start(os.Stdin, os.Stdout)
		}