fix printing of fractionals (not scientific anymore), added -p flag

* reorganized Eval() to return errors and call EvalItem() on each item
* fix negative shift amount error, found with fuzzy testing :)
* added fuzzy testing

Makefile

@@ -51,14 +51,17 @@ install: buildlocal
 	install -o $(UID) -g $(GID) -m 444 $(tool).1 $(PREFIX)/man/man1/
 
 clean:
-	rm -rf $(tool) coverage.out
+	rm -rf $(tool) coverage.out testdata
 
-test:
-	go test -v ./...
+test: clean
+	go test ./... $(ARGS)
+
+testfuzzy: clean
+	go test -fuzz ./... $(ARGS)
 
 singletest:
-	@echo "Call like this: ''make singletest TEST=TestPrepareColumns"
-	go test -run $(TEST)
+	@echo "Call like this: make singletest TEST=TestPrepareColumns ARGS=-v"
+	go test -run $(TEST) $(ARGS)
 
 cover-report:
 	go test ./... -cover -coverprofile=coverage.out

calc.go

@@ -1,5 +1,5 @@
 /*
-Copyright © 2023 Thomas von Dein
+Copyright © 2023-2024 Thomas von Dein
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -20,8 +20,9 @@ package main
 import (
 	"errors"
 	"fmt"
-	"os"
+	"math"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -35,6 +36,8 @@ type Calc struct {
 	showstack    bool
 	intermediate bool
 	notdone      bool // set to true as long as there are items left in the eval loop
+	precision    int
+
 	stack        *Stack
 	history      []string
 	completer    readline.AutoCompleter
@@ -48,27 +51,22 @@ type Calc struct {
 	Funcalls      Funcalls
 	BatchFuncalls Funcalls
 
+	// different kinds of commands, displays nicer in help output
+	StackCommands    Commands
+	SettingsCommands Commands
+	ShowCommands     Commands
+	Commands         Commands
+
 	Vars map[string]float64
 }
 
 // help for lua functions will be added dynamically
-const Help string = `Available commands:
-batch                toggle batch mode (nobatch turns it off)
-debug                toggle debug output (nodebug turns it off)
-showstack            toggle show last 5 items of the stack (noshowtack turns it off)
-dump                 display the stack contents
-clear                clear the whole stack
-shift                remove the last element of the stack
-reverse              reverse the stack elements
-swap                 exchange the last two elements
-vars                 show list of variables
-history              display calculation history
-help|?               show this message
-quit|exit|c-d|c-c    exit program
-
+const Help string = `
 Operators:
 basic operators: + - x * / ^  (* is an alias of x)
 
+Bitwise operators: and or xor < (left shift) > (right shift)
+
 Percent functions:
 %                    percent
 %-                   substract percent
@@ -94,8 +92,9 @@ Register variables:
 // commands, constants and operators,  defined here to feed completion
 // and our mode switch in Eval() dynamically
 const (
-	Commands  string = `dump reverse clear shift undo help history manual exit quit swap debug undebug nodebug batch nobatch showstack noshowstack vars`
+	//Commands  string = `dump reverse clear shift undo help history manual exit quit swap debug undebug nodebug batch nobatch showstack noshowstack vars`
 	Constants string = `Pi Phi Sqrt2 SqrtE SqrtPi SqrtPhi Ln2 Log2E Ln10 Log10E`
+	Precision int    = 2
 )
 
 // That way we can add custom functions to completion
@@ -107,7 +106,6 @@ func GetCompleteCustomFunctions() func(string) []string {
 			completions = append(completions, luafunc)
 		}
 
-		completions = append(completions, strings.Split(Commands, " ")...)
 		completions = append(completions, strings.Split(Constants, " ")...)
 
 		return completions
@@ -126,13 +124,37 @@ func (c *Calc) GetCompleteCustomFuncalls() func(string) []string {
 			completions = append(completions, function)
 		}
 
+		for command := range c.SettingsCommands {
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
+		}
+
+		for command := range c.ShowCommands {
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
+		}
+
+		for command := range c.StackCommands {
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
+		}
+
+		for command := range c.Commands {
+			if len(command) > 1 {
+				completions = append(completions, command)
+			}
+		}
+
 		return completions
 	}
 
 }
 
 func NewCalc() *Calc {
-	c := Calc{stack: NewStack(), debug: false}
+	c := Calc{stack: NewStack(), debug: false, precision: Precision}
 
 	c.Funcalls = DefineFunctions()
 	c.BatchFuncalls = DefineBatchFunctions()
@@ -151,6 +173,8 @@ func NewCalc() *Calc {
 	// pre-calculate mode switching arrays
 	c.Constants = strings.Split(Constants, " ")
 
+	c.SetCommands()
+
 	return &c
 }
 
@@ -202,12 +226,12 @@ func (c *Calc) Prompt() string {
 }
 
 // the actual work horse, evaluate a line of calc command[s]
-func (c *Calc) Eval(line string) {
+func (c *Calc) Eval(line string) error {
 	// remove surrounding whitespace and comments, if any
 	line = strings.TrimSpace(c.Comment.ReplaceAllString(line, ""))
 
 	if line == "" {
-		return
+		return nil
 	}
 
 	items := c.Space.Split(line, -1)
@@ -219,133 +243,8 @@ func (c *Calc) Eval(line string) {
 			c.notdone = false
 		}
 
-		num, err := strconv.ParseFloat(item, 64)
-
-		if err == nil {
-			c.stack.Backup()
-			c.stack.Push(num)
-		} else {
-			if contains(c.Constants, item) {
-				// put the constant onto the stack
-				c.stack.Backup()
-				c.stack.Push(const2num(item))
-				continue
-			}
-
-			if _, ok := c.Funcalls[item]; ok {
-				if err := c.DoFuncall(item); err != nil {
-					fmt.Println(err)
-				} else {
-					c.Result()
-				}
-				continue
-			}
-
-			if c.batch {
-				if _, ok := c.BatchFuncalls[item]; ok {
-					if err := c.DoFuncall(item); err != nil {
-						fmt.Println(err)
-					} else {
-						c.Result()
-					}
-					continue
-				}
-			} else {
-				if _, ok := c.BatchFuncalls[item]; ok {
-					fmt.Println("only supported in batch mode")
-					continue
-				}
-			}
-
-			if contains(c.LuaFunctions, item) {
-				// user provided custom lua functions
-				c.EvalLuaFunction(item)
-				continue
-			}
-
-			regmatches := c.Register.FindStringSubmatch(item)
-			if len(regmatches) == 3 {
-				switch regmatches[1] {
-				case ">":
-					c.PutVar(regmatches[2])
-				case "<":
-					c.GetVar(regmatches[2])
-				}
-				continue
-			}
-
-			// management commands
-			switch item {
-			case "?":
-				fallthrough
-			case "help":
-				fmt.Println(Help)
-				if len(LuaFuncs) > 0 {
-					fmt.Println("Lua functions:")
-					for name, function := range LuaFuncs {
-						fmt.Printf("%-20s %s\n", name, function.help)
-					}
-				}
-			case "dump":
-				c.stack.Dump()
-			case "debug":
-				c.ToggleDebug()
-			case "nodebug":
-				fallthrough
-			case "undebug":
-				c.debug = false
-				c.stack.debug = false
-			case "batch":
-				c.ToggleBatch()
-			case "nobatch":
-				c.batch = false
-			case "clear":
-				c.stack.Backup()
-				c.stack.Clear()
-			case "shift":
-				c.stack.Backup()
-				c.stack.Shift()
-			case "reverse":
-				c.stack.Backup()
-				c.stack.Reverse()
-			case "swap":
-				if c.stack.Len() < 2 {
-					fmt.Println("stack too small, can't swap")
-				} else {
-					c.stack.Backup()
-					c.stack.Swap()
-				}
-			case "undo":
-				c.stack.Restore()
-			case "history":
-				for _, entry := range c.history {
-					fmt.Println(entry)
-				}
-			case "showstack":
-				fallthrough
-			case "show":
-				c.ToggleShow()
-			case "noshowstack":
-				c.showstack = false
-			case "exit":
-				fallthrough
-			case "quit":
-				os.Exit(0)
-			case "manual":
-				man()
-			case "vars":
-				if len(c.Vars) > 0 {
-					fmt.Printf("%-20s     %s\n", "VARIABLE", "VALUE")
-					for k, v := range c.Vars {
-						fmt.Printf("%-20s  -> %.2f\n", k, v)
-					}
-				} else {
-					fmt.Println("no vars registered")
-				}
-
-			default:
-				fmt.Println("unknown command or operator!")
-			}
+		if err := c.EvalItem(item); err != nil {
+			return err
 		}
 	}
 
@@ -358,6 +257,106 @@ func (c *Calc) Eval(line string) {
 		last := c.stack.Last(5)
 		fmt.Printf("stack: %s%s\n", dots, list2str(last))
 	}
+
+	return nil
+}
+
+func (c *Calc) EvalItem(item string) error {
+	num, err := strconv.ParseFloat(item, 64)
+
+	if err == nil {
+		c.stack.Backup()
+		c.stack.Push(num)
+	} else {
+		// try hex
+		var i int
+		_, err := fmt.Sscanf(item, "0x%x", &i)
+		if err == nil {
+			c.stack.Backup()
+			c.stack.Push(float64(i))
+			return nil
+		}
+
+		if contains(c.Constants, item) {
+			// put the constant onto the stack
+			c.stack.Backup()
+			c.stack.Push(const2num(item))
+			return nil
+		}
+
+		if exists(c.Funcalls, item) {
+			if err := c.DoFuncall(item); err != nil {
+				return Error(err.Error())
+			} else {
+				c.Result()
+			}
+			return nil
+		}
+
+		if exists(c.BatchFuncalls, item) {
+			if !c.batch {
+				return Error("only supported in batch mode")
+			}
+
+			if err := c.DoFuncall(item); err != nil {
+				return Error(err.Error())
+			} else {
+				c.Result()
+			}
+			return nil
+		}
+
+		if contains(c.LuaFunctions, item) {
+			// user provided custom lua functions
+			c.EvalLuaFunction(item)
+			return nil
+		}
+
+		regmatches := c.Register.FindStringSubmatch(item)
+		if len(regmatches) == 3 {
+			switch regmatches[1] {
+			case ">":
+				c.PutVar(regmatches[2])
+			case "<":
+				c.GetVar(regmatches[2])
+			}
+			return nil
+		}
+
+		// internal commands
+		// FIXME: propagate errors
+		if exists(c.Commands, item) {
+			c.Commands[item].Func(c)
+			return nil
+		}
+
+		if exists(c.ShowCommands, item) {
+			c.ShowCommands[item].Func(c)
+			return nil
+		}
+
+		if exists(c.StackCommands, item) {
+			c.StackCommands[item].Func(c)
+			return nil
+		}
+
+		if exists(c.SettingsCommands, item) {
+			c.SettingsCommands[item].Func(c)
+			return nil
+		}
+
+		switch item {
+		case "?":
+			fallthrough
+		case "help":
+			c.PrintHelp()
+
+		default:
+			return Error("unknown command or operator")
+		}
+	}
+
+	return nil
 }
 
 // Execute a math function, check if it is defined just in case
@@ -370,7 +369,7 @@ func (c *Calc) DoFuncall(funcname string) error {
 	}
 
 	if function == nil {
-		panic("function not defined but in completion list")
+		return Error("function not defined but in completion list")
 	}
 
 	var args Numbers
@@ -443,7 +442,16 @@ func (c *Calc) Result() float64 {
 			fmt.Print("= ")
 		}
 
-		fmt.Println(c.stack.Last()[0])
+		result := c.stack.Last()[0]
+		truncated := math.Trunc(result)
+		precision := c.precision
+
+		if result == truncated {
+			precision = 0
+		}
+
+		format := fmt.Sprintf("%%.%df\n", precision)
+		fmt.Printf(format, result)
 	}
 
 	return c.stack.Last()[0]
@@ -520,7 +528,7 @@ func (c *Calc) PutVar(name string) {
 }
 
 func (c *Calc) GetVar(name string) {
-	if _, ok := c.Vars[name]; ok {
+	if exists(c.Vars, name) {
 		c.Debug(fmt.Sprintf("retrieve %.2f from %s", c.Vars[name], name))
 		c.stack.Backup()
 		c.stack.Push(c.Vars[name])
@@ -528,3 +536,53 @@ func (c *Calc) GetVar(name string) {
 		fmt.Println("variable doesn't exist")
 	}
 }
+
+func sortcommands(hash Commands) []string {
+	keys := make([]string, 0, len(hash))
+
+	for key := range hash {
+		if len(key) > 1 {
+			keys = append(keys, key)
+		}
+	}
+
+	sort.Strings(keys)
+
+	return keys
+}
+
+func (c *Calc) PrintHelp() {
+	fmt.Println("Available configuration commands:")
+	for _, name := range sortcommands(c.SettingsCommands) {
+		fmt.Printf("%-20s %s\n", name, c.SettingsCommands[name].Help)
+	}
+	fmt.Println()
+
+	fmt.Println("Available show commands:")
+	for _, name := range sortcommands(c.ShowCommands) {
+		fmt.Printf("%-20s %s\n", name, c.ShowCommands[name].Help)
+	}
+	fmt.Println()
+
+	fmt.Println("Available stack manipulation commands:")
+	for _, name := range sortcommands(c.StackCommands) {
+		fmt.Printf("%-20s %s\n", name, c.StackCommands[name].Help)
+	}
+	fmt.Println()
+
+	fmt.Println("Other commands:")
+	for _, name := range sortcommands(c.Commands) {
+		fmt.Printf("%-20s %s\n", name, c.Commands[name].Help)
+	}
+	fmt.Println()
+
+	fmt.Println(Help)
+
+	// append lua functions, if any
+	if len(LuaFuncs) > 0 {
+		fmt.Println("Lua functions:")
+		for name, function := range LuaFuncs {
+			fmt.Printf("%-20s %s\n", name, function.help)
+		}
+	}
+}

calc_test.go

@@ -19,6 +19,8 @@ package main
 
 import (
 	"fmt"
+	"strconv"
+	"strings"
 	"testing"
 
 	lua "github.com/yuin/gopher-lua"
@@ -75,7 +77,9 @@ func TestCommentsAndWhitespace(t *testing.T) {
 
 		t.Run(testname, func(t *testing.T) {
 			for _, line := range tt.cmd {
-				calc.Eval(line)
+				if err := calc.Eval(line); err != nil {
+					t.Errorf(err.Error())
+				}
 			}
 			got := calc.stack.Last()
 
@@ -241,6 +245,45 @@ func TestCalc(t *testing.T) {
 			cmd:  `4 4 + undo *`,
 			exp:  16,
 		},
+
+		// bit tests
+		{
+			name: "bit and",
+			cmd:  `1 3 and`,
+			exp:  1,
+		},
+		{
+			name: "bit or",
+			cmd:  `1 3 or`,
+			exp:  3,
+		},
+		{
+			name: "bit xor",
+			cmd:  `1 3 xor`,
+			exp:  2,
+		},
+
+		// converters
+		{
+			name: "inch-to-cm",
+			cmd:  `111 inch-to-cm`,
+			exp:  281.94,
+		},
+		{
+			name: "gallons-to-liters",
+			cmd:  `111 gallons-to-liters`,
+			exp:  420.135,
+		},
+		{
+			name: "meters-to-yards",
+			cmd:  `111 meters-to-yards`,
+			exp:  1.2139107611548556,
+		},
+		{
+			name: "miles-to-kilometers",
+			cmd:  `111 miles-to-kilometers`,
+			exp:  178.599,
+		},
 	}
 
 	for _, tt := range tests {
@@ -249,7 +292,9 @@ func TestCalc(t *testing.T) {
 
 		t.Run(testname, func(t *testing.T) {
 			calc.batch = tt.batch
-			calc.Eval(tt.cmd)
+			if err := calc.Eval(tt.cmd); err != nil {
+				t.Errorf(err.Error())
+			}
 			got := calc.Result()
 			calc.stack.Clear()
 			if got != tt.exp {
@@ -311,3 +356,60 @@ func TestCalcLua(t *testing.T) {
 		})
 	}
 }
+
+func FuzzEval(f *testing.F) {
+	legal := []string{
+		"dump",
+		"showstack",
+		"help",
+		"Pi 31 *",
+		"SqrtE Pi /",
+		"55.5 yards-to-meters",
+		"2 4 +",
+		"7 8 batch sum",
+		"7 8 %-",
+		"7 8 clear",
+		"7 8 /",
+		"b",
+		"#444",
+		"<X",
+	}
+
+	for _, item := range legal {
+		f.Add(item)
+	}
+
+	calc := NewCalc()
+	var i int
+
+	f.Fuzz(func(t *testing.T, line string) {
+		t.Logf("Stack:\n%v\n", calc.stack.All())
+		if err := calc.EvalItem(line); err == nil {
+			t.Logf("given: <%s>", line)
+			// not corpus and empty?
+			if !contains(legal, line) && len(line) > 0 {
+				item := strings.TrimSpace(calc.Comment.ReplaceAllString(line, ""))
+				_, hexerr := fmt.Sscanf(item, "0x%x", &i)
+				// no comment?
+				if len(item) > 0 {
+					// no known command or function?
+					if _, err := strconv.ParseFloat(item, 64); err != nil {
+						if !contains(calc.Constants, item) &&
+							!exists(calc.Funcalls, item) &&
+							!exists(calc.BatchFuncalls, item) &&
+							!contains(calc.LuaFunctions, item) &&
+							!exists(calc.Commands, item) &&
+							!exists(calc.ShowCommands, item) &&
+							!exists(calc.SettingsCommands, item) &&
+							!exists(calc.StackCommands, item) &&
+							!calc.Register.MatchString(item) &&
+							item != "?" && item != "help" &&
+							hexerr != nil {
+							t.Errorf("Fuzzy input accepted: <%s>", line)
+						}
+					}
+				}
+			}
+		}
+	})
+}

command.go

@@ -0,0 +1,319 @@
+/*
+Copyright © 2023 Thomas von Dein
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+type CommandFunction func(*Calc)
+
+type Command struct {
+	Help string
+	Func CommandFunction
+}
+
+type Commands map[string]*Command
+
+func NewCommand(help string, function CommandFunction) *Command {
+	return &Command{
+		Help: help,
+		Func: function,
+	}
+}
+
+// define all management (that is: non calculation) commands
+func (c *Calc) SetCommands() {
+	c.SettingsCommands = Commands{
+		// Toggles
+		"debug": NewCommand(
+			"toggle debugging",
+			func(c *Calc) {
+				c.ToggleDebug()
+			},
+		),
+
+		"nodebug": NewCommand(
+			"disable debugging",
+			func(c *Calc) {
+				c.debug = false
+				c.stack.debug = false
+			},
+		),
+
+		"batch": NewCommand(
+			"toggle batch mode",
+			func(c *Calc) {
+				c.ToggleBatch()
+			},
+		),
+
+		"nobatch": NewCommand(
+			"disable batch mode",
+			func(c *Calc) {
+				c.batch = false
+			},
+		),
+
+		"showstack": NewCommand(
+			"toggle show last 5 items of the stack",
+			func(c *Calc) {
+				c.ToggleShow()
+			},
+		),
+
+		"noshowstack": NewCommand(
+			"disable display of the stack",
+			func(c *Calc) {
+				c.showstack = false
+			},
+		),
+	}
+
+	c.ShowCommands = Commands{
+		// Display commands
+		"dump": NewCommand(
+			"display the stack contents",
+			func(c *Calc) {
+				c.stack.Dump()
+			},
+		),
+
+		"history": NewCommand(
+			"display calculation history",
+			func(c *Calc) {
+				for _, entry := range c.history {
+					fmt.Println(entry)
+				}
+			},
+		),
+
+		"vars": NewCommand(
+			"show list of variables",
+			func(c *Calc) {
+				if len(c.Vars) > 0 {
+					fmt.Printf("%-20s     %s\n", "VARIABLE", "VALUE")
+					for k, v := range c.Vars {
+						fmt.Printf("%-20s  -> %.2f\n", k, v)
+					}
+				} else {
+					fmt.Println("no vars registered")
+				}
+			},
+		),
+
+		"hex": NewCommand(
+			"show last stack item in hex form (converted to int)",
+			func(c *Calc) {
+				if c.stack.Len() > 0 {
+					fmt.Printf("0x%x\n", int(c.stack.Last()[0]))
+				}
+			},
+		),
+	}
+
+	c.StackCommands = Commands{
+		"clear": NewCommand(
+			"clear the whole stack",
+			func(c *Calc) {
+				c.stack.Backup()
+				c.stack.Clear()
+			},
+		),
+
+		"shift": NewCommand(
+			"remove the last element of the stack",
+			func(c *Calc) {
+				c.stack.Backup()
+				c.stack.Shift()
+			},
+		),
+
+		"reverse": NewCommand(
+			"reverse the stack elements",
+			func(c *Calc) {
+				c.stack.Backup()
+				c.stack.Reverse()
+			},
+		),
+
+		"swap": NewCommand(
+			"exchange the last two elements",
+			func(c *Calc) {
+				if c.stack.Len() < 2 {
+					fmt.Println("stack too small, can't swap")
+				} else {
+					c.stack.Backup()
+					c.stack.Swap()
+				}
+			},
+		),
+
+		"undo": NewCommand(
+			"undo last operation",
+			func(c *Calc) {
+				c.stack.Restore()
+			},
+		),
+
+		"dup": NewCommand(
+			"duplicate last stack item",
+			func(c *Calc) {
+				item := c.stack.Last()
+				if len(item) == 1 {
+					c.stack.Backup()
+					c.stack.Push(item[0])
+				} else {
+					fmt.Println("stack empty")
+				}
+			},
+		),
+
+		"edit": NewCommand(
+			"edit the stack interactively",
+			func(c *Calc) {
+				if c.stack.Len() == 0 {
+					fmt.Println("empty stack")
+					return
+				}
+
+				c.stack.Backup()
+
+				// put the stack contents into a tmp file
+				tmp, err := os.CreateTemp("", "stack")
+				if err != nil {
+					fmt.Println(err)
+					return
+				}
+				defer os.Remove(tmp.Name())
+
+				comment := `# add or remove numbers as you wish.
+# each number must be on its own line.
+# numbers must be floating point formatted.
+`
+				_, err = tmp.WriteString(comment)
+				if err != nil {
+					fmt.Println(err)
+					return
+				}
+
+				for _, item := range c.stack.All() {
+					_, err = fmt.Fprintf(tmp, "%f\n", item)
+					if err != nil {
+						fmt.Println(err)
+						return
+					}
+				}
+
+				tmp.Close()
+
+				// determine which editor to use
+				editor := "vi"
+				enveditor, present := os.LookupEnv("EDITOR")
+				if present {
+					if editor != "" {
+						if _, err := os.Stat(editor); err == nil {
+							editor = enveditor
+						}
+					}
+				}
+
+				// execute editor with our tmp file containing current stack
+				cmd := exec.Command(editor, tmp.Name())
+
+				cmd.Stdin = os.Stdin
+				cmd.Stdout = os.Stdout
+				cmd.Stderr = os.Stderr
+
+				err = cmd.Run()
+				if err != nil {
+					fmt.Println("could not run editor command: ", err)
+					return
+				}
+
+				// read the file back in
+				modified, err := os.Open(tmp.Name())
+				if err != nil {
+					fmt.Println("Error opening file:", err)
+					return
+				}
+				defer modified.Close()
+
+				// reset the stack
+				c.stack.Clear()
+
+				// and put the new contents (if legit) back onto the stack
+				scanner := bufio.NewScanner(modified)
+				for scanner.Scan() {
+					line := strings.TrimSpace(c.Comment.ReplaceAllString(scanner.Text(), ""))
+					if line == "" {
+						continue
+					}
+
+					num, err := strconv.ParseFloat(line, 64)
+					if err != nil {
+						fmt.Printf("%s is not a floating point number!\n", line)
+						continue
+					}
+
+					c.stack.Push(num)
+				}
+
+				if err := scanner.Err(); err != nil {
+					fmt.Println("Error reading from file:", err)
+				}
+			},
+		),
+	}
+
+	// general commands
+	c.Commands = Commands{
+		"exit": NewCommand(
+			"exit program",
+			func(c *Calc) {
+				os.Exit(0)
+			},
+		),
+
+		"manual": NewCommand(
+			"show manual",
+			func(c *Calc) {
+				man()
+			},
+		),
+	}
+
+	// aliases
+	c.Commands["quit"] = c.Commands["exit"]
+
+	c.SettingsCommands["d"] = c.SettingsCommands["debug"]
+	c.SettingsCommands["b"] = c.SettingsCommands["batch"]
+	c.SettingsCommands["s"] = c.SettingsCommands["showstack"]
+
+	c.ShowCommands["h"] = c.ShowCommands["history"]
+	c.ShowCommands["p"] = c.ShowCommands["dump"]
+	c.ShowCommands["v"] = c.ShowCommands["vars"]
+
+	c.StackCommands["c"] = c.StackCommands["clear"]
+	c.StackCommands["u"] = c.StackCommands["undo"]
+}

funcs.go

@@ -387,6 +387,93 @@ func DefineFunctions() Funcalls {
 				return NewR(math.Hypot(arg[0], arg[1]), nil)
 			},
 			2),
+
+		// converters of all kinds
+		"cm-to-inch": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]/2.54, nil)
+			},
+			1),
+
+		"inch-to-cm": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]*2.54, nil)
+			},
+			1),
+
+		"gallons-to-liters": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]*3.785, nil)
+			},
+			1),
+
+		"liters-to-gallons": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]/3.785, nil)
+			},
+			1),
+
+		"yards-to-meters": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]*91.44, nil)
+			},
+			1),
+
+		"meters-to-yards": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]/91.44, nil)
+			},
+			1),
+
+		"miles-to-kilometers": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]*1.609, nil)
+			},
+			1),
+
+		"kilometers-to-miles": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(arg[0]/1.609, nil)
+			},
+			1),
+
+		"or": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(float64(int(arg[0])|int(arg[1])), nil)
+			},
+			2),
+
+		"and": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(float64(int(arg[0])&int(arg[1])), nil)
+			},
+			2),
+
+		"xor": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(float64(int(arg[0])^int(arg[1])), nil)
+			},
+			2),
+
+		"<": NewFuncall(
+			func(arg Numbers) R {
+				// Shift by negative number provibited, so check it.
+				// Note that we check agains uint64 overflow as well here
+				if arg[1] < 0 || uint64(arg[1]) > math.MaxInt64 {
+					return NewR(0, errors.New("negative shift amount"))
+				}
+				return NewR(float64(int(arg[0])<<int(arg[1])), nil)
+			},
+			2),
+
+		">": NewFuncall(
+			func(arg Numbers) R {
+				if arg[1] < 0 || uint64(arg[1]) > math.MaxInt64 {
+					return NewR(0, errors.New("negative shift amount"))
+				}
+				return NewR(float64(int(arg[0])>>int(arg[1])), nil)
+			},
+			2),
 	}
 
 	// aliases

go.mod

@@ -4,7 +4,9 @@ go 1.20
 
 require (
 	github.com/chzyer/readline v1.5.1 // indirect
+	github.com/rogpeppe/go-internal v1.11.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/yuin/gopher-lua v1.1.0 // indirect
-	golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 // indirect
+	golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f // indirect
+	golang.org/x/tools v0.1.12 // indirect
 )

go.sum

@@ -2,9 +2,15 @@ github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwys
 github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
 github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
 github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/yuin/gopher-lua v1.1.0 h1:BojcDhfyDWgU2f2TOzYK/g5p2gxMrku8oupLDqlnSqE=
 github.com/yuin/gopher-lua v1.1.0/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5 h1:y/woIyUBFbpQGKS0u1aHF/40WUDnek3fPOyD08H5Vng=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

main.go

@@ -1,5 +1,5 @@
 /*
-Copyright © 2023 Thomas von Dein
+Copyright © 2023-2024 Thomas von Dein
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -30,7 +30,7 @@ import (
 	lua "github.com/yuin/gopher-lua"
 )
 
-const VERSION string = "2.0.8"
+const VERSION string = "2.1.0"
 
 const Usage string = `This is rpn, a reverse polish notation calculator cli.
 
@@ -42,15 +42,21 @@ Options:
   -s, --stack           show last 5 items of the stack (off by default)
   -i  --intermediate    print intermediate results
   -m, --manual          show manual
+  -c, --config <file>   load <file> containing LUA code
+  -p, --precision <int> floating point number precision (default 2)
   -v, --version         show version
   -h, --help            show help
 
 When <operator>  is given, batch  mode ist automatically  enabled. Use
 this only when working with stdin. E.g.: echo "2 3 4 5" | rpn +
 
-Copyright (c) 2023 T.v.Dein`
+Copyright (c) 2023-2024 T.v.Dein`
 
 func main() {
+	os.Exit(Main())
+}
+
+func Main() int {
 	calc := NewCalc()
 
 	showversion := false
@@ -69,17 +75,18 @@ func main() {
 	flag.BoolVarP(&showmanual, "manual", "m", false, "show manual")
 	flag.StringVarP(&configfile, "config", "c",
 		os.Getenv("HOME")+"/.rpn.lua", "config file (lua format)")
+	flag.IntVarP(&calc.precision, "precision", "p", Precision, "floating point precision")
 
 	flag.Parse()
 
 	if showversion {
 		fmt.Printf("This is rpn version %s\n", VERSION)
-		return
+		return 0
 	}
 
 	if showhelp {
 		fmt.Println(Usage)
-		return
+		return 0
 	}
 
 	if enabledebug {
@@ -88,7 +95,7 @@ func main() {
 
 	if showmanual {
 		man()
-		os.Exit(0)
+		return 0
 	}
 
 	// the lua state object is global, instanciate it early
@@ -101,14 +108,25 @@ func main() {
 		luarunner := NewInterpreter(configfile, enabledebug)
 		luarunner.InitLua()
 		calc.SetInt(luarunner)
+		if calc.debug {
+			fmt.Println("loaded config")
+		}
+	} else {
+		if calc.debug {
+			fmt.Println(err)
+		}
 	}
 
 	if len(flag.Args()) > 1 {
 		// commandline calc operation, no readline etc needed
 		// called like rpn 2 2 +
 		calc.stdin = true
-		calc.Eval(strings.Join(flag.Args(), " "))
-		return
+		if err := calc.Eval(strings.Join(flag.Args(), " ")); err != nil {
+			fmt.Println(err)
+			return 1
+		}
+
+		return 0
 	}
 
 	// interactive mode, need readline
@@ -141,7 +159,10 @@ func main() {
 			break
 		}
 
-		calc.Eval(line)
+		err = calc.Eval(line)
+		if err != nil {
+			fmt.Println(err)
+		}
 		rl.SetPrompt(calc.Prompt())
 	}
 
@@ -150,8 +171,13 @@ func main() {
 		// echo 1 2 3 4 | rpn +
 		// batch mode enabled automatically
 		calc.batch = true
-		calc.Eval(flag.Args()[0])
+		if err = calc.Eval(flag.Args()[0]); err != nil {
+			fmt.Println(err)
+			return 1
 		}
+	}
+
+	return 0
 }
 
 func inputIsStdin() bool {

main_test.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"os"
+	"testing"
+
+	"github.com/rogpeppe/go-internal/testscript"
+)
+
+func TestMain(m *testing.M) {
+	os.Exit(testscript.RunMain(m, map[string]func() int{
+		"testrpn": Main,
+	}))
+}
+
+func TestRpn(t *testing.T) {
+	testscript.Run(t, testscript.Params{
+		Dir: "t",
+	})
+}

rpn.go

@@ -13,6 +13,8 @@ SYNOPSIS
           -s, --stack           show last 5 items of the stack (off by default)
           -i  --intermediate    print intermediate results
           -m, --manual          show manual
+          -c, --config <file>   load <file> containing LUA code
+          -p, --precision <int> floating point number precision (default 2)
           -v, --version         show version
           -h, --help            show help
     
@@ -105,6 +107,9 @@ DESCRIPTION
     If the first parameter to rpn is a math operator or function, batch mode
     is enabled automatically, see last example.
 
+    You can enter integers, floating point numbers (positive or negative) or
+    hex numbers (prefixed with 0x).
+
   STACK MANIPULATION
     There are lots of stack manipulation commands provided. The most
     important one is undo which goes back to the stack before the last math
@@ -129,6 +134,14 @@ DESCRIPTION
         x                    multiply (alias: *)
         ^                    power
 
+    Bitwise operators:
+
+        and                  bitwise and
+        or                   bitwise or
+        xor                  bitwise xor
+        <                    left shift
+        >                    right shift
+
     Percent functions:
 
         %                    percent
@@ -150,18 +163,44 @@ DESCRIPTION
         log10 log1p log2 logb pow round roundtoeven sin sinh tan tanh trunc y0
         y1 copysign dim hypot
 
-    Commands:
+    Conversion functions:
+
+        cm-to-inch
+        inch-to-cm
+        gallons-to-liters
+        liters-to-gallons
+        yards-to-meters
+        meters-to-yards
+        miles-to-kilometers
+        kilometers-to-miles
+
+    Configuration Commands:
 
         [no]batch            toggle batch mode (nobatch turns it off)
         [no]debug            toggle debug output (nodebug turns it off)
         [no]showstack        show the last 5 items of the stack (noshowtack turns it off)
+
+    Show commands:
+
         dump                 display the stack contents
+        hex                  show last stack item in hex form (converted to int)
+        history              display calculation history
+        vars                 show list of variables
+
+    Stack manipulation commands:
+
         clear                clear the whole stack
         shift                remove the last element of the stack
         reverse              reverse the stack elements
         swap                 exchange the last two stack elements
-        history              display calculation history
+        dup                  duplicate last stack item
+        undo                 undo last operation
+        edit                 edit the stack interactively using vi or $EDITOR
+
+    Other commands:
+
         help|?               show this message
+        manual               show manual
         quit|exit|c-d|c-c    exit program
 
     Register variables:
@@ -171,6 +210,17 @@ DESCRIPTION
 
     Refer to https://pkg.go.dev/math for details about those functions.
 
+    There are also a number of shortcuts for some commands available:
+
+        d    debug
+        b    batch
+        s    showstack
+        h    history
+        p    dump (aka print)
+        v    vars
+        c    clear
+        u    undo
+
 INTERACTIVE REPL
     While you can use rpn in the command-line, the best experience you'll
     have is the interactive repl (read eval print loop). Just execute "rpn"
@@ -261,6 +311,15 @@ EXTENDING RPN USING LUA
     So you can't open files, execute other programs or open a connection to
     the outside!
 
+CONFIGURATION
+    rpn can be configured via command line flags (see usage above). Most of
+    the flags are also available as interactive commands, such as "--batch"
+    has the same effect as the batch command.
+
+    The floating point number precision option "-p, --precision" however is
+    not available as interactive command, it MUST be configured on the
+    command line, if needed. The default precision is 2.
+
 GETTING HELP
     In interactive mode you can enter the help command (or ?) to get a short
     help along with a list of all supported operators and functions.
@@ -280,7 +339,7 @@ LICENSE
     This software is licensed under the GNU GENERAL PUBLIC LICENSE version
     3.
 
-    Copyright (c) 2023 by Thomas von Dein
+    Copyright (c) 2023-2024 by Thomas von Dein
 
     This software uses the following GO modules:
 

rpn.pod

@@ -12,6 +12,8 @@ rpn - Programmable command-line calculator using reverse polish notation
       -s, --stack           show last 5 items of the stack (off by default)
       -i  --intermediate    print intermediate results
       -m, --manual          show manual
+      -c, --config <file>   load <file> containing LUA code
+      -p, --precision <int> floating point number precision (default 2)
       -v, --version         show version
       -h, --help            show help
     
@@ -109,6 +111,9 @@ Example of batch mode usage:
 If the first parameter to rpn is a math operator or function, batch
 mode is enabled automatically, see last example.
 
+You can enter integers, floating  point numbers (positive or negative)
+or hex numbers (prefixed with 0x).
+
 =head2 STACK MANIPULATION
 
 There are lots of stack manipulation commands provided. The most
@@ -136,6 +141,14 @@ Basic operators:
     x                    multiply (alias: *)
     ^                    power
 
+Bitwise operators:
+
+    and                  bitwise and
+    or                   bitwise or
+    xor                  bitwise xor
+    <                    left shift
+    >                    right shift
+
 Percent functions:
 
     %                    percent
@@ -157,18 +170,44 @@ Math functions:
     log10 log1p log2 logb pow round roundtoeven sin sinh tan tanh trunc y0
     y1 copysign dim hypot
 
-Commands:
+Conversion functions:
+
+    cm-to-inch
+    inch-to-cm
+    gallons-to-liters
+    liters-to-gallons
+    yards-to-meters
+    meters-to-yards
+    miles-to-kilometers
+    kilometers-to-miles
+
+Configuration Commands:
 
     [no]batch            toggle batch mode (nobatch turns it off)
     [no]debug            toggle debug output (nodebug turns it off)
     [no]showstack        show the last 5 items of the stack (noshowtack turns it off)
+
+Show commands:
+
     dump                 display the stack contents
+    hex                  show last stack item in hex form (converted to int)
+    history              display calculation history
+    vars                 show list of variables
+
+Stack manipulation commands:
+
     clear                clear the whole stack
     shift                remove the last element of the stack
     reverse              reverse the stack elements
     swap                 exchange the last two stack elements
-    history              display calculation history
+    dup                  duplicate last stack item
+    undo                 undo last operation
+    edit                 edit the stack interactively using vi or $EDITOR
+
+Other commands:
+
     help|?               show this message
+    manual               show manual
     quit|exit|c-d|c-c    exit program
 
 
@@ -179,6 +218,17 @@ Register variables:
 
 Refer to https://pkg.go.dev/math for details about those functions.
 
+There are also a number of shortcuts for some commands available:
+
+    d    debug
+    b    batch
+    s    showstack
+    h    history
+    p    dump (aka print)
+    v    vars
+    c    clear
+    u    undo
+
 =head1 INTERACTIVE REPL
 
 While you can use rpn in the command-line, the best experience you'll
@@ -294,6 +344,16 @@ B<Please note, that io, networking and system stuff is not allowed
 though. So you can't open files, execute other programs or open a
 connection to the outside!>
 
+=head1 CONFIGURATION
+
+B<rpn> can be configured via command line flags (see usage
+above). Most of the flags are also available as interactive commands,
+such as C<--batch> has the same effect as the B<batch> command.
+
+The floating point number  precision option C<-p, --precision> however
+is not available as interactive command,  it MUST be configured on the
+command line, if needed. The default precision is 2.
+
 =head1 GETTING HELP
 
 In interactive mode you can enter the B<help> command (or B<?>) to get
@@ -316,7 +376,7 @@ L<https://github.com/TLINDEN/rpnc/issues>.
 
 This software is licensed under the GNU GENERAL PUBLIC LICENSE version 3.
 
-Copyright (c) 2023 by Thomas von Dein
+Copyright (c) 2023-2024 by Thomas von Dein
 
 This software uses the following GO modules:
 

t/cmdline-command.txtar

@@ -0,0 +1,2 @@
+exec testrpn 1 2 dump
+stdout 'Stack revision 2 .0x'

t/cmdline-invalidcommand.txtar

@@ -0,0 +1,2 @@
+! exec testrpn 1 2 dumb
+stdout 'unknown command or operator'

t/cmdline-precision.txtar

@@ -0,0 +1,2 @@
+exec testrpn -p 4 2 3 /
+stdout '0.6667\n'

t/cmdline-short-stack.txtar

@@ -0,0 +1,2 @@
+! exec testrpn 4 +
+stdout 'stack doesn''t provide enough arguments'

t/cmdlinecalc-debug.txtar

@@ -0,0 +1,2 @@
+exec testrpn -d 44 55 *
+stdout 'push to stack: 2420.00\n'

t/cmdlinecalc-divzero.txtar

@@ -0,0 +1,2 @@
+! exec testrpn 100 50 50 - /
+stdout 'division by null'

t/cmdlinecalc-lua.txtar

@@ -0,0 +1,16 @@
+exec testrpn -d -c test.lua 3 5 lower
+stdout '3\n'
+
+-- test.lua --
+function lower(a,b)
+    if a < b then
+        return a
+    else
+        return b
+    end
+end
+
+function init()
+    -- expects 2 args
+    register("lower", 2, "lower")
+end

t/cmdlinecalc.txtar

@@ -0,0 +1,2 @@
+exec testrpn 44 55 *
+stdout '2420\n'

t/getman.txtar

@@ -0,0 +1,2 @@
+exec testrpn -m
+stdout 'This software is licensed under the GNU GENERAL PUBLIC LICENSE'

t/getusage.txtar

@@ -0,0 +1,2 @@
+exec testrpn -h
+stdout 'This is rpn'

t/getversion.txtar

@@ -0,0 +1,2 @@
+exec testrpn -v
+stdout 'This is rpn version'

t/stdin-batch-cmd.txtar

@@ -0,0 +1,4 @@
+exec echo 1 2 3 4 5 batch median
+stdin stdout
+exec testrpn
+[unix] stdout '3\n'

t/stdin-batch.txtar

@@ -0,0 +1,4 @@
+exec echo 1 2 3 4 5
+stdin stdout
+[unix] exec testrpn median
+[unix] stdout '3\n'

t/stdin-calc.txtar

@@ -0,0 +1,4 @@
+exec echo 10 10 +
+stdin stdout
+exec testrpn
+[unix] stdout '20\n'

t/stdin-help.txtar

@@ -0,0 +1,6 @@
+stdin input.txt
+exec testrpn
+[unix] stdout 'Available configuration commands'
+
+-- input.txt --
+?

t/stdin-use-vars.txtar

@@ -0,0 +1,13 @@
+stdin input.txt
+exec testrpn
+[unix] stdout '28\n'
+
+-- input.txt --
+10
+10
++
+>SUM
+clear
+8
+<SUM
++

t/stdint-explicit-batch.txtar

@@ -0,0 +1,4 @@
+exec echo 1 2 3 4 5 median
+stdin stdout
+exec testrpn -b
+[unix] stdout '3\n'

t/test.lua

@@ -0,0 +1,13 @@
+-- simple function, return the lower number of the two operands
+function lower(a,b)
+    if a < b then
+        return a
+    else
+        return b
+    end
+end
+
+function init()
+    -- expects 2 args
+    register("lower", 2, "lower")
+end  

util.go

@@ -23,16 +23,24 @@ import (
 	"strings"
 )
 
-// find an item in a list
-func contains(s []string, e string) bool {
-	for _, a := range s {
-		if a == e {
+// find an item in a list, generic variant
+func contains[E comparable](s []E, v E) bool {
+	for _, vs := range s {
+		if v == vs {
 			return true
 		}
 	}
 	return false
 }
 
+// look if a key in a map exists, generic variant
+func exists[K comparable, V any](m map[K]V, v K) bool {
+	if _, ok := m[v]; ok {
+		return true
+	}
+	return false
+}
+
 func const2num(name string) float64 {
 	switch name {
 	case "Pi":
@@ -63,3 +71,7 @@ func const2num(name string) float64 {
 func list2str(list Numbers) string {
 	return strings.Trim(strings.Join(strings.Fields(fmt.Sprint(list)), " "), "[]")
 }
+
+func Error(m string) error {
+	return fmt.Errorf("Error: %s!", m)
+}