Add EVALUATE MOVE ERASE and tests.

Author: Molorius

README.md

@@ -511,6 +511,8 @@ error if it cannot be cannot be cross compiled.
 * `EMIT`
   * Deferred so a program can output to any interface.
     `EMIT` is used for all printing, such as `.`.
+* `EVALUATE`
+  * Can only run on host.
 * `EXECUTE`
 * `EXIT`
 * `FIND`
@@ -528,6 +530,8 @@ error if it cannot be cannot be cross compiled.
 * `MAX`
 * `MIN`
 * `MOD`
+* `MOVE`
+  * Does not handle cases where the data overlaps.
 * `NEGATE`
 * `OR`
 * `OVER`
@@ -581,6 +585,7 @@ Missing words may be implemented in the future.
 * `DEFER@`
 * `ENDCASE`
 * `ENDOF`
+* `ERASE`
 * `FALSE`
 * `HEX`
 * `IS`

pkg/forth/builtin/02_core.f

@@ -422,3 +422,25 @@
     ALLOT \ change the data space accordingly
 ;
 
+: ERASE ( addr u -- )
+    DUP 0> IF
+        0 DO
+            ( addr )
+            0 OVER ! \ store 0
+            1+ ( addr+1 )
+        LOOP
+        DROP
+    ELSE
+        2DROP
+    THEN
+;
+
+: MOVE ( addr1 addr2 u -- )
+    0 ?DO
+        ( addr1 addr2 )
+        OVER @ ( addr1 addr2 val1 )
+        OVER ! ( addr1 addr2 ) \ store val1
+        1+ SWAP 1+ SWAP ( addr1+1 addr2+1 )
+    LOOP
+    2DROP
+;

pkg/forth/parse.go

@@ -11,6 +11,9 @@ package forth
 type ParseArea struct {
 	area  []byte
 	index int
+
+	savedArea  []byte
+	savedIndex int
 }
 
 // Set up the parse area.
@@ -27,6 +30,24 @@ func (p *ParseArea) Fill(bytes []byte) error {
 	return nil
 }
 
+func (p *ParseArea) Save() error {
+	p.savedArea = p.area
+	p.savedIndex = p.index
+	// reset the area
+	p.area = nil
+	p.index = 0
+	return nil
+}
+
+func (p *ParseArea) Restore() error {
+	p.area = p.savedArea
+	p.index = p.savedIndex
+	// reset the saved area
+	p.savedArea = nil
+	p.savedIndex = 0
+	return nil
+}
+
 func (p *ParseArea) Word(delimiter byte) ([]byte, error) {
 	// trim starting whitespace
 	startIndex := p.index

pkg/forth/primitive.go

@@ -74,7 +74,7 @@ func PrimitiveSetup(vm *VirtualMachine) error {
 				if !ok {
 					return EntryError(entry, "requires an address cell")
 				}
-				name, err := cellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
+				name, err := countedCellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
 				if err != nil {
 					return JoinEntryError(err, entry, "could not parse name")
 				}
@@ -130,7 +130,7 @@ func PrimitiveSetup(vm *VirtualMachine) error {
 				if !ok {
 					return EntryError(entry, "requires an address cell")
 				}
-				name, err := cellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
+				name, err := countedCellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
 				if err != nil {
 					return JoinEntryError(err, entry, "could not parse name")
 				}
@@ -510,7 +510,7 @@ func PrimitiveSetup(vm *VirtualMachine) error {
 				if !ok {
 					return EntryError(entry, "requires an address cell")
 				}
-				name, err := cellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
+				name, err := countedCellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
 				if err != nil {
 					return JoinEntryError(err, entry, "could not convert input to string")
 				}
@@ -548,6 +548,45 @@ func PrimitiveSetup(vm *VirtualMachine) error {
 				return nil
 			},
 		},
+		{
+			name: "EVALUATE",
+			goFunc: func(vm *VirtualMachine, entry *DictionaryEntry) error {
+				// get the size
+				size, err := vm.Stack.PopNumber()
+				if err != nil {
+					return PopError(err, entry)
+				}
+				// get the code
+				cell, err := vm.Stack.Pop()
+				if err != nil {
+					return JoinEntryError(err, entry, "could not pop code")
+				}
+				cellAddr, ok := cell.(CellAddress)
+				if !ok {
+					return EntryError(entry, "requires code")
+				}
+				code, err := cellsToString(cellAddr.Entry.Word.(*WordForth).Cells, int(size), cellAddr.UpperByte)
+				if err != nil {
+					return JoinEntryError(err, entry, "could not parse code")
+				}
+				// save the parse area
+				err = vm.ParseArea.Save()
+				if err != nil {
+					return JoinEntryError(err, entry, "could not save parse area")
+				}
+				// execute
+				err = vm.Execute([]byte(code))
+				if err != nil {
+					return JoinEntryError(err, entry, "error while executing: %s", code)
+				}
+				// restore parse area
+				err = vm.ParseArea.Restore()
+				if err != nil {
+					return JoinEntryError(err, entry, "could not restore parse area")
+				}
+				return nil
+			},
+		},
 		{
 			name: "EXECUTE",
 			goFunc: func(vm *VirtualMachine, entry *DictionaryEntry) error {
@@ -610,7 +649,7 @@ func PrimitiveSetup(vm *VirtualMachine) error {
 				if !ok {
 					return EntryError(entry, "requires a name")
 				}
-				name, err := cellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
+				name, err := countedCellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
 				if err != nil {
 					return JoinEntryError(err, entry, "could not parse name")
 				}
@@ -1365,6 +1404,12 @@ func PrimitiveSetup(vm *VirtualMachine) error {
 							return nil
 						}
 						return EntryError(entry, "could not subtract %s type %T from %s type %T due to types", right, right, left, left)
+					case CellNumber:
+						err = vm.Stack.Push(CellAddress{r.Entry, r.Offset - int(l.Number), false})
+						if err != nil {
+							return PushError(err, entry)
+						}
+						return nil
 					default:
 						return EntryError(entry, "could not subtract %s type %T from %s type %T due to types", right, right, left, left)
 					}
@@ -2491,7 +2536,7 @@ func parseWord(vm *VirtualMachine, entry *DictionaryEntry) (string, error) {
 	if !ok {
 		return "", EntryError(entry, "name argument needs to be an address to a string")
 	}
-	name, err := cellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
+	name, err := countedCellsToString(cellAddr.Entry.Word.(*WordForth).Cells)
 	if err != nil {
 		return "", JoinEntryError(err, entry, "could not parse name")
 	}
@@ -2511,7 +2556,7 @@ func parseAssembly(vm *VirtualMachine, entry *DictionaryEntry) ([]string, error)
 		}
 		switch c := cell.(type) {
 		case CellAddress:
-			substr, err := cellsToString(c.Entry.Word.(*WordForth).Cells)
+			substr, err := countedCellsToString(c.Entry.Word.(*WordForth).Cells)
 			if err != nil {
 				return nil, JoinEntryError(err, entry, "could not convert input to string")
 			}

pkg/forth/suite_test.go

@@ -454,8 +454,25 @@ func TestSuite(t *testing.T) {
 		// ENDCASE does not have any tests
 		// ENDOF does not have any tests
 		// ENVIRONMENT?
-		// ERASE
-		// EVALUATE
+		// ERASE does not have any tests
+		{
+			name: "EVALUATE",
+			setup: `
+				: GE1 S" 123" ; IMMEDIATE
+				: GE2 S" 123 1+" ; IMMEDIATE
+				: GE3 S" : GE4 345 ;" ;
+				: GE5 EVALUATE ; IMMEDIATE
+				T{ GE1 EVALUATE -> 123 }T \ TEST EVALUATE IN INTERPRET STATE
+				T{ GE2 EVALUATE -> 124 }T
+				T{ GE3 EVALUATE ->     }T
+				T{ GE4          -> 345 }T
+
+				T{ : GE6 GE1 GE5 ; -> }T \ TEST EVALUATE IN COMPILE STATE
+				T{ GE6 -> 123 }T
+				T{ : GE7 GE2 GE5 ; -> }T
+				T{ GE7 -> 124 }T
+			`,
+		},
 		// EXECUTE does not have any tests
 		// EXIT does not have any tests
 		{
@@ -660,7 +677,38 @@ func TestSuite(t *testing.T) {
 			`,
 		},
 		// MOD
-		// MOVE
+		{
+			name: "MOVE",
+			setup: `
+				T{ 20 BUFFER: FBUF -> }T
+				T{ 20 FBUF ! 20 FBUF 1+ ! 20 FBUF 2 + ! -> }T
+				T{ : SEEBUF FBUF @ FBUF 1+ @ FBUF 2 + @ ; -> }T
+				T{ 20 BUFFER: SBUF -> }T
+				T{ 12 SBUF ! 34 SBUF 1+ ! 56 SBUF 2 + ! -> }T
+			`,
+			code: `
+				// The actual test suite is wrong for forths in which
+				// the address units are greater than the character size.
+				// This test is modified to work with that.
+				T{ FBUF FBUF 3 CHARS MOVE -> }T \ BIZARRE SPECIAL CASE
+				T{ SEEBUF -> 20 20 20 }T
+				T{ SBUF FBUF 0 CHARS MOVE -> }T
+				T{ SEEBUF -> 20 20 20 }T
+
+				T{ SBUF FBUF 1 CHARS MOVE -> }T
+				T{ SEEBUF -> 12 20 20 }T
+
+				T{ SBUF FBUF 3 MOVE -> }T
+				T{ SEEBUF -> 12 34 56 }T
+
+				// TODO fix the overlapping case
+				// T{ FBUF FBUF 1+ 2 MOVE -> }T
+				// T{ SEEBUF -> 12 12 34 }T
+
+				// T{ FBUF CHAR+ FBUF 2 CHARS MOVE -> }T
+				// T{ SEEBUF -> 12 34 34 }T
+			`,
+		},
 		// M*
 		{
 			name: "-",

pkg/forth/utils.go

@@ -51,14 +51,29 @@ func cellsToBytes(cells []Cell) ([]byte, error) {
 	return out, nil
 }
 
-func cellsToString(cells []Cell) (string, error) {
+func countedCellsToString(cells []Cell) (string, error) {
 	bytes, err := cellsToBytes(cells)
 	if err != nil {
 		return "", err
 	}
 	length := bytes[0]
-	if length < 0 || int(length+1) > len(bytes) {
-		return "", fmt.Errorf("counted string length is invalid: %d", length)
+	return bytesToString(bytes[1:], int(length))
+}
+
+func cellsToString(cells []Cell, length int, upper bool) (string, error) {
+	bytes, err := cellsToBytes(cells)
+	if err != nil {
+		return "", err
+	}
+	if upper {
+		return bytesToString(bytes[1:], length)
+	}
+	return bytesToString(bytes, length)
+}
+
+func bytesToString(bytes []byte, length int) (string, error) {
+	if length < 0 || length > len(bytes) {
+		return "", fmt.Errorf("string length is invalid: %d", length)
 	}
-	return string(bytes[1 : length+1]), nil
+	return string(bytes[:length]), nil
 }