From e4bca02235d0ed2e4355a08969371dfa6845e038 Mon Sep 17 00:00:00 2001 From: Chuck Smith Date: Wed, 21 Feb 2024 16:29:53 -0500 Subject: [PATCH] Strings --- Makefile | 93 +++++++++++++++++++++++++++++++++++++++ compiler/compiler.go | 4 ++ compiler/compiler_test.go | 44 ++++++++++++++++++ vm/vm.go | 20 +++++++-- vm/vm_test.go | 33 +++++++++++++- 5 files changed, 189 insertions(+), 5 deletions(-) create mode 100644 Makefile diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..4187880 --- /dev/null +++ b/Makefile @@ -0,0 +1,93 @@ +.PHONY: dev build cli server install image release profile compare bench test clean + +CGO_ENABLED=0 + +VERSION ?= $(shell git describe 2>/dev/null || echo "") + +DESTDIR ?= $(GOBIN) + +ifeq ($(LOCAL), 1) +IMAGE := r.mills.io/prologic/monkey +TAG := dev +else +ifeq ($(BRANCH), master) +IMAGE := prologic/monkey +TAG := latest +else +IMAGE := prologic/monkey +TAG := dev +endif +endif + +all: help + +help: ## Show this help message + @echo "monkey - Monkey Lang" + @awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n make \033[36m\033[0m\n"} /^[$$()% a-zA-Z_-]+:.*?##/ { printf " \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST) + +dev: cli ## Build monkey and run the REPL + @./monkey + +build: clean cli server ## Build monkey + +cli: ## Build monkey CLI + @go build \ + -tags "netgo static_build" -installsuffix netgo \ + -ldflags "-w -X go.mills.io/monkey/v2.MonkeyVersion=$(VERSION)" \ + ./cmd/monkey/... + +server: ## Build Monkey server + @go build \ + -tags "netgo static_build" -installsuffix netgo \ + -ldflags "-w -X go.mills.io/monkey/v2.MonkeyVersion=$(VERSION)" \ + ./cmd/monkey-server/... + +install: cli server ## Install monkey to $DESTDIR + @install -D -m 755 monkey $(DESTDIR)/monkey + @install -D -m 755 monkey-server $(DESTDIR)monkey-server + +ifeq ($(PUBLISH), 1) +image: ## Build and Publish the Docker image + @docker buildx build \ + --build-arg VERSION="$(VERSION)" \ + --build-arg COMMIT="$(COMMIT)" \ + --build-arg BUILD="$(BUILD)" \ + --platform linux/amd64,linux/arm64 --push -t $(IMAGE):$(TAG) . +else +image: ## Build the Docker image + @docker build \ + --build-arg VERSION="$(VERSION)" -t $(IMAGE):$(TAG) . +endif + +release: ## Release monkey + @./tools/release.sh + +profile: ## Run tests with profiling enabled + @go test -cpuprofile cpu.prof -memprofile mem.prof -v -bench ./... + +compare: ## Run benchmarks comparing Monkey with other languages + @hyperfine -w 5 -p 'make build; gcc -o examples/fib examples/fib.c' \ + -n c -n go -n tengo -n python -n tauc -n taugo -n monkey \ + --sort mean-time --export-markdown Benchmark.md \ + './examples/fib' \ + 'go run examples/fib.go' \ + 'tengo examples/fib.tengo' \ + 'python3 examples/fib.py' \ + 'tauc examples/fib.tau' \ + 'taugo examples/fib.tau' \ + './monkey examples/fib.m' + +bench: # Run test benchmarks + @go test -v -benchmem -bench=. ./... + +test: ## Run unit tests + @go test -v \ + -cover \ + -coverprofile coverage.out \ + -covermode atomic \ + -coverpkg ./... \ + -race \ + ./... + +clean: ## Cleanup untrakced files + @git clean -f -d -X 2> /dev/null || true \ No newline at end of file diff --git a/compiler/compiler.go b/compiler/compiler.go index dcbd62b..be6ffe2 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -190,6 +190,10 @@ func (c *Compiler) Compile(node ast.Node) error { c.emit(code.OpGetGlobal, symbol.Index) + case *ast.StringLiteral: + str := &object.String{Value: node.Value} + c.emit(code.OpConstant, c.addConstant(str)) + } return nil diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go index 38b6ec2..5cdc524 100644 --- a/compiler/compiler_test.go +++ b/compiler/compiler_test.go @@ -277,6 +277,31 @@ func TestGlobalLetStatements(t *testing.T) { runCompilerTests(t, tests) } +func TestStringExpressions(t *testing.T) { + tests := []compilerTestCase{ + { + input: `"monkey"`, + expectedConstants: []interface{}{"monkey"}, + expectedInstructions: []code.Instructions{ + code.Make(code.OpConstant, 0), + code.Make(code.OpPop), + }, + }, + { + input: `"mon" + "key"`, + expectedConstants: []interface{}{"mon", "key"}, + expectedInstructions: []code.Instructions{ + code.Make(code.OpConstant, 0), + code.Make(code.OpConstant, 1), + code.Make(code.OpAdd), + code.Make(code.OpPop), + }, + }, + } + + runCompilerTests(t, tests) +} + func runCompilerTests(t *testing.T, tests []compilerTestCase) { t.Helper() @@ -347,6 +372,12 @@ func testConstants(t *testing.T, expected []interface{}, actual []object.Object) if err != nil { return fmt.Errorf("constant %d = testIntegerObject failed : %s", i, err) } + + case string: + err := testStringObject(constant, actual[i]) + if err != nil { + return fmt.Errorf("constant %d = testStringObject failed : %s", i, err) + } } } return nil @@ -364,3 +395,16 @@ func testIntegerObject(expected int64, actual object.Object) interface{} { return nil } + +func testStringObject(expected string, actual object.Object) error { + result, ok := actual.(*object.String) + if !ok { + return fmt.Errorf("object is not String. got %T (%+v", actual, actual) + } + + if result.Value != expected { + return fmt.Errorf("object has wrong value. got=%q, want=%q", result.Value, expected) + } + + return nil +} diff --git a/vm/vm.go b/vm/vm.go index 01803bb..b59d920 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -177,11 +177,14 @@ func (vm *VM) executeBinaryOperation(op code.Opcode) error { leftType := left.Type() rightRight := right.Type() - if leftType == object.INTEGER_OBJ && rightRight == object.INTEGER_OBJ { + switch { + case leftType == object.INTEGER_OBJ && rightRight == object.INTEGER_OBJ: return vm.executeBinaryIntegerOperation(op, left, right) + case leftType == object.STRING_OBJ && rightRight == object.STRING_OBJ: + return vm.executeBinaryStringOperation(op, left, right) + default: + return fmt.Errorf("unsupported types for binary operation: %s %s", leftType, rightRight) } - - return fmt.Errorf("unsupported types for binary operation: %s %s", leftType, rightRight) } func (vm *VM) executeBinaryIntegerOperation(op code.Opcode, left, right object.Object) error { @@ -206,6 +209,17 @@ func (vm *VM) executeBinaryIntegerOperation(op code.Opcode, left, right object.O return vm.push(&object.Integer{Value: result}) } +func (vm *VM) executeBinaryStringOperation(op code.Opcode, left, right object.Object) error { + if op != code.OpAdd { + return fmt.Errorf("unknown string operator: %d", op) + } + + leftValue := left.(*object.String).Value + rightValue := right.(*object.String).Value + + return vm.push(&object.String{Value: leftValue + rightValue}) +} + func (vm *VM) executeComparison(op code.Opcode) error { right := vm.pop() left := vm.pop() diff --git a/vm/vm_test.go b/vm/vm_test.go index 757ab55..187e3ba 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -55,6 +55,12 @@ func testExpectedObject(t *testing.T, expected interface{}, actual object.Object t.Errorf("testBooleanObject failed: %s", err) } + case string: + err := testStringObject(expected, actual) + if err != nil { + t.Errorf("testStringObject failed: %s", err) + } + case *object.Null: if actual != Null { t.Errorf("object is not Null: %T (%+v)", actual, actual) @@ -68,7 +74,7 @@ func parse(input string) *ast.Program { return p.ParseProgram() } -func testIntegerObject(expected int64, actual object.Object) interface{} { +func testIntegerObject(expected int64, actual object.Object) error { result, ok := actual.(*object.Integer) if !ok { return fmt.Errorf("object is not Integer. got=%T (%+v", actual, actual) @@ -81,7 +87,7 @@ func testIntegerObject(expected int64, actual object.Object) interface{} { return nil } -func testBooleanObject(expected bool, actual object.Object) interface{} { +func testBooleanObject(expected bool, actual object.Object) error { result, ok := actual.(*object.Boolean) if !ok { return fmt.Errorf("object is not Boolean. got=%T (%+v", actual, actual) @@ -94,6 +100,19 @@ func testBooleanObject(expected bool, actual object.Object) interface{} { return nil } +func testStringObject(expected string, actual object.Object) error { + result, ok := actual.(*object.String) + if !ok { + return fmt.Errorf("object is not String. got=%T (%+v", actual, actual) + } + + if result.Value != expected { + return fmt.Errorf("object has wrong value. got=%q, want=%q", result.Value, expected) + } + + return nil +} + func TestIntegerArithmetic(t *testing.T) { tests := []vmTestCase{ {"1", 1}, @@ -175,3 +194,13 @@ func TestGlobalLetStatements(t *testing.T) { runVmTests(t, tests) } + +func TestStringExpressions(t *testing.T) { + tests := []vmTestCase{ + {`"monkey"`, "monkey"}, + {`"mon" + "key"`, "monkey"}, + {`"mon" + "key" + "banana"`, "monkeybanana"}, + } + + runVmTests(t, tests) +}