go-vise

commit 7cf1de955e97c2d206be8b34515cab355063521d
parent 7bb479f4cbf2b85686abcf3af4d12f007cfb8546
Author: lash <dev@holbrook.no>
Date:   Tue,  4 Apr 2023 21:02:17 +0100

Add parser for display arg

Diffstat:
M
go/asm/asm.go
 | 
57
++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
M
go/asm/asm_test.go
 | 
23
++++++++++++++++++++++-
M
go/vm/debug_test.go
 | 
6
+++---

3 files changed, 81 insertions(+), 5 deletions(-)
diff --git a/go/asm/asm.go b/go/asm/asm.go
@@ -21,7 +21,8 @@ type Asm struct {
 
 type Display struct {
 	Sym string `@Sym Whitespace`
-	Val string `@Quote @Sym @Quote Whitespace`
+	//Val string `Quote (@Desc @Whitespace?)+ Quote Whitespace`
+	Val string `Quote (@Sym @Whitespace?)+ Quote Whitespace`
 }
 
 func(d Display) String() string {
@@ -135,6 +136,16 @@ func writeSym(s string, w *bytes.Buffer) (int, error) {
 	return w.WriteString(s)
 }
 
+func writeDisplay(s string, w *bytes.Buffer) (int, error) {
+	s = strings.Trim(s, "\"'")
+	sz := len(s)
+	if sz > 255 {
+		return 0, fmt.Errorf("string size %v too big", sz)
+	}
+	w.Write([]byte{byte(sz)})
+	return w.WriteString(s)
+}
+
 func writeSize(n uint32, w *bytes.Buffer) (int, error) {
 	bn := [4]byte{}
 	sz := numSize(n)
@@ -148,6 +159,41 @@ func writeSize(n uint32, w *bytes.Buffer) (int, error) {
 }
 
 
+func parseDisplay(op vm.Opcode, arg Arg, w io.Writer) (int, error) {
+	var rn int
+
+	v := arg.ArgDisplay
+	if v == nil {
+		return 0, nil
+	}
+
+	b := bytes.NewBuffer(nil)
+
+	n, err := writeOpcode(op, b)
+	rn += n
+	if  err != nil {
+		return rn, err
+	}
+	
+	n, err = writeSym(v.Sym, b)
+	rn += n
+	if err != nil {
+		return rn, err
+	}
+
+	n, err = writeDisplay(v.Val, b)
+	rn += n
+	if err != nil {
+		return rn, err
+	}
+	if w != nil {
+		rn, err = w.Write(b.Bytes())
+	} else {
+		rn = 0
+	}
+	return rn, err
+}
+
 func parseSized(op vm.Opcode, arg Arg, w io.Writer) (int, error) {
 	var rn int
 
@@ -198,6 +244,15 @@ func Parse(s string, w io.Writer) (int, error) {
 			rn += n
 			continue
 		}
+
+		n, err = parseDisplay(op, v.OpArg, w)
+		if err != nil {
+			return n, err
+		}
+		if n > 0 {
+			rn += n
+			continue
+		}
 	}
 	return rn, err
 }
diff --git a/go/asm/asm_test.go b/go/asm/asm_test.go
@@ -39,10 +39,31 @@ func TestParserSized(t *testing.T) {
 		t.Fatal(err)
 	}
 	if n != 8 {
-		t.Fatalf("expected 0 byte write count, got %v", n)
+		t.Fatalf("expected 8 byte write count, got %v", n)
 	}
 	rb := r.Bytes()
 	if !bytes.Equal(rb, []byte{0x00, vm.LOAD, 0x03, 0x66, 0x6f, 0x6f, 0x01, 0x2a}) {
 		t.Fatalf("expected 0x00%x012a, got %v", vm.LOAD, rb)
 	}
 }
+
+func TestParseDisplay(t *testing.T) {
+	var b []byte
+	b = vm.NewLine(b, vm.MOUT, []string{"foo", "baz ba zbaz"}, nil, nil)
+	s, err := vm.ToString(b)
+	log.Printf("parsing:\n%s\n", s)
+
+	r := bytes.NewBuffer(nil)
+	n, err := Parse(s, r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != 18 {
+		t.Fatalf("expected 18 byte write count, got %v", n)
+	}
+	rb := r.Bytes()
+	expect := []byte{0x00, vm.MOUT, 0x03, 0x66, 0x6f, 0x6f, 0x0b, 0x62, 0x61, 0x7a, 0x20, 0x62, 0x61, 0x20, 0x7a, 0x62, 0x61, 0x7a}
+	if !bytes.Equal(rb, expect) {
+		t.Fatalf("expected %x, got %x", expect, rb)
+	}
+}
diff --git a/go/vm/debug_test.go b/go/vm/debug_test.go
@@ -16,7 +16,7 @@ func TestToString(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	expect = "CATCH xyzzy 13 1 # invertmatch=true\n"
+	expect = "CATCH xyzzy 13 1\n"
 	if r != expect {
 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
 	}
@@ -26,7 +26,7 @@ func TestToString(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	expect = "CROAK 13 1 # invertmatch=true\n"
+	expect = "CROAK 13 1\n"
 	if r != expect {
 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
 	}
@@ -144,7 +144,7 @@ func TestToStringMultiple(t *testing.T) {
 	}
 	expect := `INCMP 1 foo
 INCMP 2 bar
-CATCH aiee 666 0 # invertmatch=false
+CATCH aiee 666 0
 LOAD inky 42
 HALT
 `