Standardize errors, remove unused code.

Author: Molorius

pkg/forth/cell.go

@@ -37,7 +37,7 @@ type CellNumber struct {
 }
 
 func (c CellNumber) Execute(vm *VirtualMachine) error {
-	return fmt.Errorf("Cannot directly execute a number")
+	return fmt.Errorf("cannot directly execute a number")
 }
 
 func (c CellNumber) String() string {
@@ -52,7 +52,7 @@ func (c CellNumber) AddToList(u *Ulp) error {
 }
 
 func (c CellNumber) BuildExecution(u *Ulp) (string, error) {
-	return "", fmt.Errorf("Cannot directly execute number")
+	return "", fmt.Errorf("cannot directly execute number")
 }
 
 func (c CellNumber) OutputReference(u *Ulp) (string, error) {
@@ -75,19 +75,19 @@ func (c CellAddress) Execute(vm *VirtualMachine) error {
 	switch w := c.Entry.Word.(type) {
 	case *WordForth:
 		if c.Offset >= len(w.Cells) {
-			return fmt.Errorf("Trying to get data from outside of allocated data.")
+			return fmt.Errorf("trying to get data from outside of allocated data")
 		}
 		if c.Entry.Flag.Data {
 			return vm.Stack.Push(w.Cells[c.Offset])
 		}
 		return w.ExecuteOffset(vm, c.Offset)
 	case *WordPrimitive:
 		if c.Offset != 0 {
-			return fmt.Errorf("Cannot execute a primitive word at an offset.")
+			return fmt.Errorf("cannot execute a primitive word at an offset")
 		}
 		return w.Execute(vm)
 	default:
-		return fmt.Errorf("Cannot execute word type %t", c.Entry.Word)
+		return fmt.Errorf("cannot execute word type %t", c.Entry.Word)
 	}
 }
 
@@ -108,7 +108,7 @@ func (c CellAddress) BuildExecution(u *Ulp) (string, error) {
 	case UlpCompileTargetSubroutine:
 		return fmt.Sprintf("jump %s", name), nil
 	default:
-		return "", fmt.Errorf("Unknown compile target %d, please file a bug report", u.compileTarget)
+		return "", fmt.Errorf("unknown compile target %d, please file a bug report", u.compileTarget)
 	}
 }
 
@@ -200,12 +200,12 @@ func (c CellLiteral) BuildExecution(u *Ulp) (string, error) {
 	case UlpCompileTargetSubroutine:
 		return fmt.Sprintf("move r0, %s\r\n%sjump __add_to_stack", name, safeCall()), nil
 	default:
-		return "", fmt.Errorf("Unknown compile target %d, please file a bug report", u.compileTarget)
+		return "", fmt.Errorf("unknown compile target %d, please file a bug report", u.compileTarget)
 	}
 }
 
 func (c CellLiteral) OutputReference(u *Ulp) (string, error) {
-	return "", fmt.Errorf("Cannot refer to a CellLiteral, please file a bug report")
+	return "", fmt.Errorf("cannot refer to a CellLiteral, please file a bug report")
 }
 
 func (c CellLiteral) IsRecursive(check *WordForth) bool {
@@ -232,7 +232,7 @@ func (c *CellDestination) BuildExecution(u *Ulp) (string, error) {
 }
 
 func (c *CellDestination) OutputReference(u *Ulp) (string, error) {
-	return "", fmt.Errorf("Cannot refer to a destination, please file a bug report")
+	return "", fmt.Errorf("cannot refer to a destination, please file a bug report")
 }
 
 func (c *CellDestination) IsRecursive(check *WordForth) bool {
@@ -281,12 +281,12 @@ func (c *CellBranch) BuildExecution(u *Ulp) (string, error) {
 	case UlpCompileTargetSubroutine:
 		return fmt.Sprintf("move r2, %s\r\njump r2", c.dest.name(u)), nil
 	default:
-		return "", fmt.Errorf("Unknown compile target %d, please file a bug report", u.compileTarget)
+		return "", fmt.Errorf("unknown compile target %d, please file a bug report", u.compileTarget)
 	}
 }
 
 func (c *CellBranch) OutputReference(u *Ulp) (string, error) {
-	return "", fmt.Errorf("Cannot refer to a branch, please file a bug report")
+	return "", fmt.Errorf("cannot refer to a branch, please file a bug report")
 }
 
 func (c *CellBranch) IsRecursive(check *WordForth) bool {
@@ -330,12 +330,12 @@ func (c *CellBranch0) BuildExecution(u *Ulp) (string, error) {
 	case UlpCompileTargetSubroutine:
 		return fmt.Sprintf("move r1, %s\r\n%sjump __branch_if", c.dest.name(u), safeCall()), nil
 	default:
-		return "", fmt.Errorf("Unknown compile target %d, please file a bug report", u.compileTarget)
+		return "", fmt.Errorf("unknown compile target %d, please file a bug report", u.compileTarget)
 	}
 }
 
 func (c *CellBranch0) OutputReference(u *Ulp) (string, error) {
-	return "", fmt.Errorf("Cannot refer to a conditional branch, please file a bug report")
+	return "", fmt.Errorf("cannot refer to a conditional branch, please file a bug report")
 }
 
 func (c *CellBranch0) IsRecursive(check *WordForth) bool {
@@ -353,7 +353,7 @@ type CellTailCall struct {
 }
 
 func (c *CellTailCall) Execute(vm *VirtualMachine) error {
-	return fmt.Errorf("Cannot directly execute a tail call, please file a bug repot")
+	return fmt.Errorf("cannot directly execute a tail call, please file a bug repot")
 }
 
 func (c *CellTailCall) AddToList(u *Ulp) error {
@@ -369,12 +369,12 @@ func (c *CellTailCall) BuildExecution(u *Ulp) (string, error) {
 		// put the address after the docol
 		return fmt.Sprintf("move r2, %s\r\njump r2", c.dest.Entry.BodyLabel()), nil
 	default:
-		return "", fmt.Errorf("Unknown compile target %d, please file a bug report", u.compileTarget)
+		return "", fmt.Errorf("unknown compile target %d, please file a bug report", u.compileTarget)
 	}
 }
 
 func (c *CellTailCall) OutputReference(u *Ulp) (string, error) {
-	return "", fmt.Errorf("Cannot refer to a tail call, please file a bug report")
+	return "", fmt.Errorf("cannot refer to a tail call, please file a bug report")
 }
 
 func (c *CellTailCall) IsRecursive(check *WordForth) bool {

pkg/forth/dictionary.go

@@ -58,7 +58,7 @@ func (d *Dictionary) Setup(vm *VirtualMachine) error {
 
 func (d *Dictionary) AddEntry(entry *DictionaryEntry) error {
 	if d.Entries == nil {
-		return fmt.Errorf("Dictionary not set up when adding entry, please file a bug report.")
+		return fmt.Errorf("dictionary not set up when adding entry, please file a bug report")
 	}
 	name := entry.Name
 	if name != "" {
@@ -88,7 +88,7 @@ func (d *Dictionary) standardizeName(name string) string {
 
 func (d *Dictionary) FindName(name string) (*DictionaryEntry, error) {
 	if d.Entries == nil {
-		return nil, fmt.Errorf("Dictionary not set up when finding name, please file a bug report.")
+		return nil, fmt.Errorf("dictionary not set up when finding name, please file a bug report")
 	}
 	nameLower := d.standardizeName(name)
 	same, ok := d.entryMap[nameLower]
@@ -100,14 +100,14 @@ func (d *Dictionary) FindName(name string) (*DictionaryEntry, error) {
 			}
 		}
 	}
-	return nil, fmt.Errorf("%s not found in dictionary.", name)
+	return nil, fmt.Errorf("%s not found in dictionary", name)
 }
 
 func (d *Dictionary) LastForthWord() (*WordForth, error) {
 	lastEntry := d.Entries[len(d.Entries)-1]
 	last, ok := lastEntry.Word.(*WordForth)
 	if !ok {
-		return nil, fmt.Errorf("The last word in dictionary is not a Forth word.")
+		return nil, fmt.Errorf("the last word in dictionary is not a Forth word")
 	}
 	return last, nil
 }

pkg/forth/optimize.go

@@ -101,10 +101,10 @@ func (o *Optimizer) removeDeferred() error {
 			}
 			data, ok := address.Entry.Word.(*WordForth)
 			if !ok {
-				return fmt.Errorf("error reading a deferred word, please file a bug report.")
+				return fmt.Errorf("error reading a deferred word, please file a bug report")
 			}
 			if len(data.Cells) < 1 {
-				return fmt.Errorf("deferred word not allocated, please file a bug report.")
+				return fmt.Errorf("deferred word not allocated, please file a bug report")
 			}
 			embedded := data.Cells[0]
 			exit := w.Cells[len(w.Cells)-1]

pkg/forth/stack.go

@@ -38,7 +38,7 @@ func (s *Stack) Push(c Cell) error {
 func (s *Stack) Pop() (Cell, error) {
 	last := len(s.stack) - 1
 	if last < 0 {
-		return nil, fmt.Errorf("Attempted to pop empty stack.")
+		return nil, fmt.Errorf("attempted to pop empty stack")
 	}
 	c := s.stack[last]
 	s.stack = s.stack[:last]
@@ -53,7 +53,7 @@ func (s *Stack) PopNumber() (uint16, error) {
 	}
 	cellNumber, ok := cell.(CellNumber)
 	if !ok {
-		return 0, fmt.Errorf("Could not convert cell to number: %s type %T", cell, cell)
+		return 0, fmt.Errorf("could not convert cell to number: %s type %T", cell, cell)
 	}
 	return cellNumber.Number, nil
 }
@@ -66,7 +66,7 @@ func (s *Stack) Depth() int {
 // Set the stack depth. Must not be greater than current depth.
 func (s *Stack) SetDepth(depth int) error {
 	if depth > len(s.stack) {
-		return fmt.Errorf("Cannot arbitrarily increase stack depth.")
+		return fmt.Errorf("cannot arbitrarily increase stack depth")
 	}
 	s.stack = s.stack[:depth]
 	return nil

pkg/forth/ulpBuild.go

@@ -29,56 +29,7 @@ const (
 	UlpCompileTargetSubroutine
 )
 
-type ulpAsm struct {
-	name string
-	asm  []string
-}
-
-func (uAsm ulpAsm) build() string {
-	var sb strings.Builder
-	sb.WriteString(uAsm.name)
-	sb.WriteString(":\r\n")
-	for _, asm := range uAsm.asm {
-		if !strings.Contains(asm, ":") {
-			sb.WriteString("    ")
-		}
-		sb.WriteString(asm)
-		sb.WriteString("\r\n")
-	}
-	return sb.String()
-}
-
-type ulpForthCell struct {
-	cell Cell
-	name string
-}
-
-type ulpForth struct {
-	name  string
-	cells []ulpForthCell
-}
-
-func (uForth ulpForth) build() string {
-	var sb strings.Builder
-	sb.WriteString(uForth.name)
-	sb.WriteString(":\r\n")
-	for _, cell := range uForth.cells {
-		if strings.Contains(cell.name, ":") {
-			sb.WriteString("  ")
-		} else {
-			sb.WriteString("    .int ")
-		}
-		sb.WriteString(cell.name)
-		sb.WriteString("\r\n")
-	}
-	return sb.String()
-}
-
 type Ulp struct {
-	// output strings
-	assembly []ulpAsm
-	forth    []ulpForth
-	data     map[string]string
 	outCount int
 
 	// output definitions
@@ -88,51 +39,19 @@ type Ulp struct {
 	literals      map[string]string
 
 	// current state of compilation
-	compileType   UlpCompileType
 	compileTarget UlpCompileTarget
 }
 
-func (u *Ulp) build() string {
-	var sb strings.Builder
-	// header
-	sb.WriteString(u.buildInterpreter())
-	// assembly
-	sb.WriteString("\r\n.text\r\n")
-	sb.WriteString("__asmwords_start:\r\n")
-	for _, asm := range u.assembly {
-		sb.WriteString(asm.build())
-	}
-	sb.WriteString("__asmwords_end:\r\n\r\n")
-	// forth
-	sb.WriteString(".data\r\n")
-	sb.WriteString("__forthwords_start:\r\n")
-	for _, forth := range u.forth {
-		sb.WriteString(forth.build())
-	}
-	sb.WriteString("__forthwords_end:\r\n\r\n")
-	// data
-	sb.WriteString("__forthdata_start:\r\n")
-	for _, d := range u.data {
-		sb.WriteString(d)
-		sb.WriteString("\r\n")
-	}
-	sb.WriteString("__forthdata_end:\r\n")
-	return sb.String()
-}
-
 // Build the assembly using the word passed in as the main function.
 // Note that the virtual machine will be unusable after this.
 func (u *Ulp) BuildAssembly(vm *VirtualMachine, word string) (string, error) {
 	// put back into interpret state and compile the main ulp program
-	u.assembly = make([]ulpAsm, 0)
-	u.forth = make([]ulpForth, 0)
-	u.data = make(map[string]string)
 
 	vm.State.Set(uint16(StateInterpret))
 	// create the VM.INIT word without an EXIT
 	err := vm.Execute([]byte(" BL WORD VM.INIT --CREATE-FORTH ] VM.STACK.INIT " + word + " BEGIN HALT AGAIN [ LAST HIDE "))
 	if err != nil {
-		return "", errors.Join(fmt.Errorf("could not compile the supporting words for ulp cross-compiling."), err)
+		return "", errors.Join(fmt.Errorf("could not compile the supporting words for ulp cross-compiling"), err)
 	}
 	u.compileTarget = UlpCompileTargetToken
 	return u.buildAssemblyHelper(vm, u.buildInterpreter())
@@ -143,7 +62,7 @@ func (u *Ulp) BuildAssemblySrt(vm *VirtualMachine, word string) (string, error)
 	// create the VM.INIT word without an EXIT
 	err := vm.Execute([]byte(" BL WORD VM.INIT --CREATE-FORTH ] " + word + " BEGIN HALT AGAIN [ LAST HIDE "))
 	if err != nil {
-		return "", errors.Join(fmt.Errorf("could not compile the supporting words for ulp cross-compiling."), err)
+		return "", errors.Join(fmt.Errorf("could not compile the supporting words for ulp cross-compiling"), err)
 	}
 	u.compileTarget = UlpCompileTargetSubroutine
 	return u.buildAssemblyHelper(vm, u.buildInterpreterSrt())
@@ -273,7 +192,7 @@ func (u *Ulp) buildLiterals() (string, error) {
 	case UlpCompileTargetSubroutine:
 		return "", nil // literals are compiled along the way, not as a final list
 	default:
-		return "", fmt.Errorf("Unknown compile target %d, please file a bug report", u.compileTarget)
+		return "", fmt.Errorf("unknown compile target %d, please file a bug report", u.compileTarget)
 	}
 }
 

pkg/forth/utils.go

@@ -12,7 +12,7 @@ import "fmt"
 func GetCellNumber(c Cell) (CellNumber, error) {
 	cellNumber, ok := c.(CellNumber)
 	if !ok {
-		return CellNumber{}, fmt.Errorf("Attempted to convert cell to number: %v", c)
+		return CellNumber{}, fmt.Errorf("attempted to convert cell to number: %v", c)
 	}
 	return cellNumber, nil
 }

pkg/forth/vm.go

@@ -106,7 +106,7 @@ var builtinsEsp32 embed.FS
 func (vm *VirtualMachine) buildEmbed(f embed.FS, name string) error {
 	dirEntries, err := f.ReadDir(name)
 	if err != nil {
-		return errors.Join(fmt.Errorf("Error while opening embedded directory."), err)
+		return errors.Join(fmt.Errorf("error while opening embedded directory"), err)
 	}
 	for _, entry := range dirEntries {
 		// don't look in subdirectories (for now)
@@ -162,7 +162,7 @@ func (w writerNoNewline) Write(p []byte) (int, error) {
 func (vm *VirtualMachine) ReplSetup() error {
 	rl, err := readline.New("")
 	if err != nil {
-		return errors.Join(fmt.Errorf("Unable to start readline, please file a bug report."), err)
+		return errors.Join(fmt.Errorf("unable to start readline, please file a bug report"), err)
 	}
 	vm.repl = rl
 	return nil
@@ -264,7 +264,7 @@ func (vm *VirtualMachine) executeLine(bytes []byte) error {
 		case StateExit:
 			return nil // the repl will exit after reading the state
 		default:
-			return fmt.Errorf("Unknown state %d", state)
+			return fmt.Errorf("unknown state %d", state)
 		}
 	}
 }