Merge branch 'master' into feature/add-converters

* added:

- converters
- bitwise operators
- hex input and output support

Makefile

@@ -57,8 +57,8 @@ test:
 	go test -v ./...
 
 singletest:
-	@echo "Call like this: ''make singletest TEST=TestPrepareColumns MOD=lib"
+	@echo "Call like this: ''make singletest TEST=TestPrepareColumns"
-	go test -run $(TEST) github.com/tlinden/rpn/$(MOD)
+	go test -run $(TEST)
 
 cover-report:
 	go test ./... -cover -coverprofile=coverage.out

README.md

@@ -15,10 +15,18 @@ Features:
 - various stack manipulation commands
 - basic math operators
 - advanced math functions (not yet complete)
-- provides interactive repl
 - can be used on the commandline
 - can calculate data in batch mode (also from STDIN)
 - extensible with custom LUA functions
+- provides interactive repl
+- completion
+- history
+- comments (comment character is `#`)
+- variables
+
+## Demo
+
+![asciicast](demo/demo.gif)
 
 ## Working principle
 
@@ -217,10 +225,15 @@ the `register()` function to register your functions to the
 calculator. This function takes these parameters:
 
 - function name
-- number of arguments expected (1,2 or -1 allowed), -1 means batch
+- number of arguments expected (see below)
-  mode
 - help text
 
+Number of expected arguments can be:
+
+- 0: expect 1 argument but do NOT modify the stack
+- 1-n: do a singular calculation
+- -1: batch mode work with all numbers on the stack 
+
 Please [refer to the lua language
 reference](https://www.lua.org/manual/5.4/) for more details about
 LUA.

calc.go

@@ -20,8 +20,8 @@ package main
 import (
 	"errors"
 	"fmt"
-	"os"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -32,34 +32,38 @@ type Calc struct {
 	debug        bool
 	batch        bool
 	stdin        bool
+	showstack    bool
+	intermediate bool
+	notdone      bool // set to true as long as there are items left in the eval loop
 	stack        *Stack
 	history      []string
 	completer    readline.AutoCompleter
 	interpreter  *Interpreter
 	Space        *regexp.Regexp
+	Comment      *regexp.Regexp
+	Register     *regexp.Regexp
 	Constants    []string
 	LuaFunctions []string
 
 	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:
+const Help string = `
-batch                toggle batch mode
-debug                toggle debug output
-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
-history              display calculation history
-help|?               show this message
-quit|exit|c-d|c-c    exit program
-
 Operators:
 basic operators: + - x * / ^  (* is an alias of x)
 
+Bitwise operators: and or xor < (left shift) > (right shift)
+
 Percent functions:
 %                    percent
 %-                   substract percent
@@ -76,12 +80,16 @@ sum                  sum of all values (alias: +)
 max                  max of all values
 min                  min of all values
 mean                 mean of all values (alias: avg)
-median               median of all values`
+median               median of all values
+
+Register variables:
+>NAME                Put last stack element into variable NAME
+<NAME                Retrieve variable NAME and put onto stack`
 
 // commands, constants and operators,  defined here to feed completion
 // and our mode switch in Eval() dynamically
 const (
-	Commands  string = `dump reverse debug undebug clear batch shift undo help history manual exit quit swap`
+	//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`
 )
 
@@ -94,7 +102,6 @@ func GetCompleteCustomFunctions() func(string) []string {
 			completions = append(completions, luafunc)
 		}
 
-		completions = append(completions, strings.Split(Commands, " ")...)
 		completions = append(completions, strings.Split(Constants, " ")...)
 
 		return completions
@@ -113,6 +120,22 @@ func (c *Calc) GetCompleteCustomFuncalls() func(string) []string {
 			completions = append(completions, function)
 		}
 
+		for command := range c.SettingsCommands {
+			completions = append(completions, command)
+		}
+
+		for command := range c.ShowCommands {
+			completions = append(completions, command)
+		}
+
+		for command := range c.StackCommands {
+			completions = append(completions, command)
+		}
+
+		for command := range c.Commands {
+			completions = append(completions, command)
+		}
+
 		return completions
 	}
 
@@ -123,6 +146,7 @@ func NewCalc() *Calc {
 
 	c.Funcalls = DefineFunctions()
 	c.BatchFuncalls = DefineBatchFunctions()
+	c.Vars = map[string]float64{}
 
 	c.completer = readline.NewPrefixCompleter(
 		// custom lua functions
@@ -131,20 +155,24 @@ func NewCalc() *Calc {
 	)
 
 	c.Space = regexp.MustCompile(`\s+`)
+	c.Comment = regexp.MustCompile(`#.*`) // ignore everything after #
+	c.Register = regexp.MustCompile(`^([<>])([A-Z][A-Z0-9]*)`)
 
 	// pre-calculate mode switching arrays
 	c.Constants = strings.Split(Constants, " ")
 
-	for name := range LuaFuncs {
+	c.SetCommands()
-		c.LuaFunctions = append(c.LuaFunctions, name)
-	}
 
 	return &c
 }
 
-// setup the interpreter, called from main()
+// setup the interpreter, called from main(), import lua functions
 func (c *Calc) SetInt(I *Interpreter) {
 	c.interpreter = I
+
+	for name := range LuaFuncs {
+		c.LuaFunctions = append(c.LuaFunctions, name)
+	}
 }
 
 func (c *Calc) ToggleDebug() {
@@ -162,14 +190,21 @@ func (c *Calc) ToggleStdin() {
 	c.stdin = !c.stdin
 }
 
+func (c *Calc) ToggleShow() {
+	c.showstack = !c.showstack
+}
+
 func (c *Calc) Prompt() string {
 	p := "\033[31m»\033[0m "
 	b := ""
+
 	if c.batch {
 		b = "->batch"
 	}
+
 	d := ""
 	v := ""
+
 	if c.debug {
 		d = "->debug"
 		v = fmt.Sprintf("/rev%d", c.stack.rev)
@@ -180,19 +215,37 @@ func (c *Calc) Prompt() string {
 
 // the actual work horse, evaluate a line of calc command[s]
 func (c *Calc) Eval(line string) {
-	line = strings.TrimSpace(line)
+	// remove surrounding whitespace and comments, if any
+	line = strings.TrimSpace(c.Comment.ReplaceAllString(line, ""))
 
 	if line == "" {
 		return
 	}
 
-	for _, item := range c.Space.Split(line, -1) {
+	items := c.Space.Split(line, -1)
+
+	for pos, item := range items {
+		if pos+1 < len(items) {
+			c.notdone = true
+		} else {
+			c.notdone = false
+		}
+
 		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))
+				continue
+			}
+
 			if contains(c.Constants, item) {
 				// put the constant onto the stack
 				c.stack.Backup()
@@ -227,61 +280,63 @@ func (c *Calc) Eval(line string) {
 
 			if contains(c.LuaFunctions, item) {
 				// user provided custom lua functions
-				c.luafunc(item)
+				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
+			}
+
+			// internal commands
+			if _, ok := c.Commands[item]; ok {
+				c.Commands[item].Func(c)
+				continue
+			}
+
+			if _, ok := c.ShowCommands[item]; ok {
+				c.ShowCommands[item].Func(c)
+				continue
+			}
+
+			if _, ok := c.StackCommands[item]; ok {
+				c.StackCommands[item].Func(c)
+				continue
+			}
+
+			if _, ok := c.SettingsCommands[item]; ok {
+				c.SettingsCommands[item].Func(c)
 				continue
 			}
 
-			// management commands
 			switch item {
 			case "?":
 				fallthrough
 			case "help":
-				fmt.Println(Help)
+				c.PrintHelp()
-				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 "undebug":
-				c.debug = false
-			case "batch":
-				c.ToggleBatch()
-			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 "exit":
-				fallthrough
-			case "quit":
-				os.Exit(0)
-			case "manual":
-				man()
 			default:
 				fmt.Println("unknown command or operator!")
 			}
 		}
 	}
+
+	if c.showstack && !c.stdin {
+		dots := ""
+
+		if c.stack.Len() > 5 {
+			dots = "... "
+		}
+		last := c.stack.Last(5)
+		fmt.Printf("stack: %s%s\n", dots, list2str(last))
+	}
 }
 
 // Execute a math function, check if it is defined just in case
@@ -326,6 +381,10 @@ func (c *Calc) DoFuncall(funcname string) error {
 		return R.Err
 	}
 
+	// don't forget to backup!
+	c.stack.Backup()
+
+	// "pop"
 	if batch {
 		// get rid of stack
 		c.stack.Clear()
@@ -355,11 +414,16 @@ func (c *Calc) History(format string, args ...any) {
 
 // print the result
 func (c *Calc) Result() float64 {
+	// we only  print the result if it's either  a final result or
+	// (if it is intermediate) if -i has been given
+	if c.intermediate || !c.notdone {
+		// only needed in repl
 		if !c.stdin {
 			fmt.Print("= ")
 		}
 
 		fmt.Println(c.stack.Last()[0])
+	}
 
 	return c.stack.Last()[0]
 }
@@ -370,12 +434,14 @@ func (c *Calc) Debug(msg string) {
 	}
 }
 
-func (c *Calc) luafunc(funcname string) {
+func (c *Calc) EvalLuaFunction(funcname string) {
 	// called from calc loop
 	var x float64
 	var err error
 
 	switch c.interpreter.FuncNumArgs(funcname) {
+	case 0:
+		fallthrough
 	case 1:
 		x, err = c.interpreter.CallLuaFunc(funcname, c.stack.Last())
 	case 2:
@@ -393,7 +459,15 @@ func (c *Calc) luafunc(funcname string) {
 
 	c.stack.Backup()
 
+	dopush := true
+
 	switch c.interpreter.FuncNumArgs(funcname) {
+	case 0:
+		a := c.stack.Last()
+		if len(a) == 1 {
+			c.History("%s(%f) = %f", funcname, a, x)
+		}
+		dopush = false
 	case 1:
 		a := c.stack.Pop()
 		c.History("%s(%f) = %f", funcname, a, x)
@@ -406,7 +480,78 @@ func (c *Calc) luafunc(funcname string) {
 		c.History("%s(*) = %f", funcname, x)
 	}
 
+	if dopush {
 		c.stack.Push(x)
+	}
 
 	c.Result()
 }
+
+func (c *Calc) PutVar(name string) {
+	last := c.stack.Last()
+
+	if len(last) == 1 {
+		c.Debug(fmt.Sprintf("register %.2f in %s", last[0], name))
+		c.Vars[name] = last[0]
+	} else {
+		fmt.Println("empty stack")
+	}
+}
+
+func (c *Calc) GetVar(name string) {
+	if _, ok := c.Vars[name]; ok {
+		c.Debug(fmt.Sprintf("retrieve %.2f from %s", c.Vars[name], name))
+		c.stack.Backup()
+		c.stack.Push(c.Vars[name])
+	} else {
+		fmt.Println("variable doesn't exist")
+	}
+}
+
+func sortcommands(hash Commands) []string {
+	keys := make([]string, 0, len(hash))
+
+	for key := range hash {
+		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

@@ -20,8 +20,83 @@ package main
 import (
 	"fmt"
 	"testing"
+
+	lua "github.com/yuin/gopher-lua"
 )
 
+func TestCommentsAndWhitespace(t *testing.T) {
+	calc := NewCalc()
+
+	var tests = []struct {
+		name string
+		cmd  []string
+		exp  float64 // last element of the stack
+	}{
+		{
+			name: "whitespace prefix",
+			cmd:  []string{"  5"},
+			exp:  5.0,
+		},
+		{
+			name: "whitespace postfix",
+			cmd:  []string{"5  "},
+			exp:  5.0,
+		},
+		{
+			name: "whitespace both",
+			cmd:  []string{"  5   "},
+			exp:  5.0,
+		},
+		{
+			name: "comment line w/ spaces",
+			cmd:  []string{"5", "   #   19"},
+			exp:  5.0,
+		},
+		{
+			name: "comment line w/o spaces",
+			cmd:  []string{"5", `#19`},
+			exp:  5.0,
+		},
+		{
+			name: "inline comment w/ spaces",
+			cmd:  []string{"5   #   19"},
+			exp:  5.0,
+		},
+		{
+			name: "inline comment w/o spaces",
+			cmd:  []string{"5#19"},
+			exp:  5.0,
+		},
+	}
+
+	for _, tt := range tests {
+		testname := fmt.Sprintf("%s .(expect %.2f)",
+			tt.name, tt.exp)
+
+		t.Run(testname, func(t *testing.T) {
+			for _, line := range tt.cmd {
+				calc.Eval(line)
+			}
+			got := calc.stack.Last()
+
+			if len(got) > 0 {
+				if got[0] != tt.exp {
+					t.Errorf("parsing failed:\n+++  got: %f\n--- want: %f",
+						got, tt.exp)
+				}
+			}
+
+			if calc.stack.Len() != 1 {
+				t.Errorf("invalid stack size:\n+++  got: %d\n--- want: 1",
+					calc.stack.Len())
+			}
+
+		})
+
+		calc.stack.Clear()
+	}
+}
+
 func TestCalc(t *testing.T) {
 	calc := NewCalc()
 
@@ -31,6 +106,7 @@ func TestCalc(t *testing.T) {
 		exp   float64
 		batch bool
 	}{
+		// ops
 		{
 			name: "plus",
 			cmd:  `15 15 +`,
@@ -71,6 +147,8 @@ func TestCalc(t *testing.T) {
 			cmd:  `400 20 %+`,
 			exp:  480,
 		},
+
+		// math tests
 		{
 			name: "mod",
 			cmd:  `9 2 mod`,
@@ -91,6 +169,20 @@ func TestCalc(t *testing.T) {
 			cmd:  `6 4 dim`,
 			exp:  2,
 		},
+
+		// constants tests
+		{
+			name: "pitimes2",
+			cmd:  `Pi 2 *`,
+			exp:  6.283185307179586,
+		},
+		{
+			name: "pi+sqrt2",
+			cmd:  `Pi Sqrt2 +`,
+			exp:  4.555806215962888,
+		},
+
+		// batch tests
 		{
 			name:  "batch-sum",
 			cmd:   `2 2 2 2 sum`,
@@ -121,6 +213,73 @@ func TestCalc(t *testing.T) {
 			exp:   5,
 			batch: true,
 		},
+
+		// stack tests
+		{
+			name: "use-vars",
+			cmd:  `10 >TEN clear 5 <TEN *`,
+			exp:  50,
+		},
+		{
+			name: "reverse",
+			cmd:  `100 500 reverse -`,
+			exp:  400,
+		},
+		{
+			name: "swap",
+			cmd:  `2 16 swap /`,
+			exp:  8,
+		},
+		{
+			name:  "clear batch",
+			cmd:   "1 1 1 1 1 clear 1 1 sum",
+			exp:   2,
+			batch: true,
+		},
+		{
+			name: "undo",
+			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 {
@@ -139,3 +298,55 @@ func TestCalc(t *testing.T) {
 		})
 	}
 }
+
+func TestCalcLua(t *testing.T) {
+	var tests = []struct {
+		function string
+		stack    []float64
+		exp      float64
+	}{
+		{
+			function: "lower",
+			stack:    []float64{5, 6},
+			exp:      5.0,
+		},
+		{
+			function: "parallelresistance",
+			stack:    []float64{100, 200, 300},
+			exp:      54.54545454545455,
+		},
+	}
+
+	calc := NewCalc()
+	L = lua.NewState(lua.Options{SkipOpenLibs: true})
+	defer L.Close()
+
+	luarunner := NewInterpreter("example.lua", false)
+	luarunner.InitLua()
+	calc.SetInt(luarunner)
+
+	for _, tt := range tests {
+		testname := fmt.Sprintf("lua-%s", tt.function)
+
+		t.Run(testname, func(t *testing.T) {
+			calc.stack.Clear()
+			for _, item := range tt.stack {
+				calc.stack.Push(item)
+			}
+
+			calc.EvalLuaFunction(tt.function)
+
+			got := calc.stack.Last()
+
+			if calc.stack.Len() != 1 {
+				t.Errorf("invalid stack size:\n+++  got: %d\n--- want: 1",
+					calc.stack.Len())
+			}
+
+			if got[0] != tt.exp {
+				t.Errorf("lua function %s failed:\n+++  got: %f\n--- want: %f",
+					tt.function, got, tt.exp)
+			}
+		})
+	}
+}

command.go

@@ -0,0 +1,210 @@
+/*
+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 (
+	"fmt"
+	"os"
+)
+
+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")
+				}
+			},
+		),
+	}
+
+	// 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["undebug"] = c.SettingsCommands["nodebug"]
+	c.SettingsCommands["show"] = c.SettingsCommands["showstack"]
+}

demo/Makefile

@@ -0,0 +1,7 @@
+#
+
+
+all:
+	asciinema rec --cols 80 --row 25 -c "env - PS1='> ' PATH=..:$PATH /bin/bash --norc --noprofile" --overwrite demo.cast
+	agg demo.cast demo.gif
+

demo/demo.cast

@@ -0,0 +1,3 @@
+{"version": 2, "width": 80, "height": 25, "timestamp": 1699358215, "env": {"SHELL": "/bin/bash", "TERM": "tmux-256color"}}
+[0.005628, "o", "> "]
+[0.941195, "o", "exit\r\n"]

demo/sessions.txt

@@ -0,0 +1,18 @@
+# demo sessions, used to create an interactive rpn recording
+
+# part 1: interactive
+
+# put some numbers onto the stack
+2 4 6
+8
+10
+
+# take a look at the stack
+dump
+
+# add the last 2
++
+
+# multiply the result and the previous
+*
+

example.lua

@@ -0,0 +1,38 @@
+-- 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
+
+-- calculate parallel resistance. Batch  function (registered with -1,
+-- see below). Takes a table as parameter.
+--
+-- Formula: 1/( (1/R1) + (1/R2) + ...)
+function parallelresistance(list)
+    sumres = 0
+    
+    for i, value in ipairs(list) do
+        sumres = sumres + 1 / value
+    end
+
+    return 1 / sumres
+end
+
+-- converter example
+function inch2centimeter(inches)
+    return inches * 2.54
+end
+
+function init()
+    -- expects 2 args
+    register("lower", 2, "lower")
+
+    -- expects a list of all numbers on the stack, batch mode
+    register("parallelresistance", -1, "parallel resistance")
+
+    -- expects 1 arg, but doesn't pop()
+    register("inch2centimeter", 0)
+end  

funcs.go

@@ -387,6 +387,85 @@ 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 {
+				return NewR(float64(int(arg[0])<<int(arg[1])), nil)
+			},
+			2),
+
+		">": NewFuncall(
+			func(arg Numbers) R {
+				return NewR(float64(int(arg[0])>>int(arg[1])), nil)
+			},
+			2),
 	}
 
 	// aliases

interpreter.go

@@ -26,6 +26,7 @@ import (
 
 type Interpreter struct {
 	debug  bool
+	script string
 }
 
 // LUA interpreter, instanciated in main()
@@ -42,8 +43,12 @@ type LuaFunction struct {
 // have access to the interpreter instance
 var LuaFuncs map[string]LuaFunction
 
+func NewInterpreter(script string, debug bool) *Interpreter {
+	return &Interpreter{debug: debug, script: script}
+}
+
 // initialize the lua environment properly
-func InitLua(config string, debug bool) *Interpreter {
+func (i *Interpreter) InitLua() {
 	// we only  load a subset of lua Open  modules and don't allow
 	// net, system or io stuff
 	for _, pair := range []struct {
@@ -66,7 +71,7 @@ func InitLua(config string, debug bool) *Interpreter {
 	}
 
 	// load the lua config (which we expect to contain init() and math functions)
-	if err := L.DoFile(config); err != nil {
+	if err := L.DoFile(i.script); err != nil {
 		panic(err)
 	}
 
@@ -84,8 +89,6 @@ func InitLua(config string, debug bool) *Interpreter {
 	}); err != nil {
 		panic(err)
 	}
-
-	return &Interpreter{debug: debug}
 }
 
 func (i *Interpreter) Debug(msg string) {
@@ -113,6 +116,8 @@ func (i *Interpreter) CallLuaFunc(funcname string, items []float64) (float64, er
 		funcname, LuaFuncs[funcname].numargs))
 
 	switch LuaFuncs[funcname].numargs {
+	case 0:
+		fallthrough
 	case 1:
 		// 1 arg variant
 		if err := L.CallByParam(lua.P{

main.go

@@ -30,7 +30,7 @@ import (
 	lua "github.com/yuin/gopher-lua"
 )
 
-const VERSION string = "2.0.2"
+const VERSION string = "2.0.10"
 
 const Usage string = `This is rpn, a reverse polish notation calculator cli.
 
@@ -39,6 +39,8 @@ Usage: rpn [-bdvh] [<operator>]
 Options:
   -b, --batchmode     enable batch mode
   -d, --debug         enable debug mode
+  -s, --stack         show last 5 items of the stack (off by default)
+  -i  --intermediate  print intermediate results
   -m, --manual        show manual
   -v, --version       show version
   -h, --help          show help
@@ -58,6 +60,9 @@ func main() {
 	configfile := ""
 
 	flag.BoolVarP(&calc.batch, "batchmode", "b", false, "batch mode")
+	flag.BoolVarP(&calc.showstack, "show-stack", "s", false, "show stack")
+	flag.BoolVarP(&calc.intermediate, "showin-termediate", "i", false,
+		"show intermediate results")
 	flag.BoolVarP(&enabledebug, "debug", "d", false, "debug mode")
 	flag.BoolVarP(&showversion, "version", "v", false, "show version")
 	flag.BoolVarP(&showhelp, "help", "h", false, "show usage")
@@ -93,8 +98,9 @@ func main() {
 	// our config file is interpreted  as lua code, only functions can
 	// be defined, init() will be called by InitLua().
 	if _, err := os.Stat(configfile); err == nil {
-		I := InitLua(configfile, enabledebug)
+		luarunner := NewInterpreter(configfile, enabledebug)
-		calc.SetInt(I)
+		luarunner.InitLua()
+		calc.SetInt(luarunner)
 	}
 
 	if len(flag.Args()) > 1 {

rpn.go

@@ -2,7 +2,7 @@ package main
 
 var manpage = `
 NAME
-    rpn - Reverse Polish Notation Calculator for the commandline
+    rpn - Programmable command-line calculator using reverse polish notation
 
 SYNOPSIS
         Usage: rpn [-bdvh] [<operator>]
@@ -10,6 +10,9 @@ SYNOPSIS
         Options:
           -b, --batchmode     enable batch mode
           -d, --debug         enable debug mode
+          -s, --stack         show last 5 items of the stack (off by default)
+          -i  --intermediate  print intermediate results
+          -m, --manual        show manual
           -v, --version       show version
           -h, --help          show help
     
@@ -102,6 +105,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
@@ -111,7 +117,9 @@ DESCRIPTION
     switch or debug toggle command), then the backup stack is also being
     displayed.
 
-    The stack can be reversed using the reverse command.
+    The stack can be reversed using the reverse command. However, sometimes
+    only the last two values are in the wrong order. Use the swap command to
+    exchange them.
 
     You can use the shift command to remove the last number from the stack.
 
@@ -124,6 +132,14 @@ DESCRIPTION
         x                    multiply (alias: *)
         ^                    power
 
+    Bitwise operators:
+
+        and                  bitwise and
+        or                   bitwise or
+        xor                  bitwise xor
+        <                    left shift
+        >                    right shift
+
     Percent functions:
 
         %                    percent
@@ -145,8 +161,89 @@ DESCRIPTION
         log10 log1p log2 logb pow round roundtoeven sin sinh tan tanh trunc y0
         y1 copysign dim hypot
 
+    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 dup duplicate last stack item undo
+    undo last operation
+
+    Other commands: help|? show this message manual show manual
+    quit|exit|c-d|c-c exit program
+
+    Register variables:
+
+        >NAME                Put last stack element into variable NAME
+        <NAME                Retrieve variable NAME and put onto stack
+
     Refer to https://pkg.go.dev/math for details about those functions.
 
+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"
+    and you'll be there.
+
+    In interactive mode you can use TAB completion to complete commands,
+    operators and functions. There's also a history, which allows you to
+    repeat complicated calculations (as long as you've entered them in one
+    line).
+
+    There are also a lot of key bindings, here are the most important ones:
+
+    ctrl-c + ctrl-d
+        Exit interactive rpn
+
+    ctrl-z
+        Send rpn to the backgound.
+
+    ctrl-a
+        Beginning of line.
+
+    ctrl-e
+        End of line.
+
+    ctrl-l
+        Clear the screen.
+
+    ctrl-r
+        Search through history.
+
+COMMENTS
+    Lines starting with "#" are being ignored as comments. You can also
+    append comments to rpn input, e.g.:
+
+       # a comment
+       123   # another comment
+
+    In this case only 123 will be added to the stack.
+
+VARIABLES
+    You can register the last item of the stack into a variable. Variable
+    names must be all caps. Use the ">NAME" command to put a value into
+    variable "NAME". Use "<NAME" to retrieve the value of variable "NAME"
+    and put it onto the stack.
+
+    The command vars can be used to get a list of all variables.
+
 EXTENDING RPN USING LUA
     You can use a lua script with lua functions to extend the calculator. By
     default the tool looks for "~/.rpn.lua". You can also specify a script
@@ -173,8 +270,13 @@ EXTENDING RPN USING LUA
 
     *   function name
 
-    *   number of arguments expected (1,2 or -1 allowed), -1 means batch
+    *   number of arguments expected (see below)
-        mode.
+
+        Number of expected arguments can be:
+
+            - 0: expect 1 argument but do NOT modify the stack
+            - 1-n: do a singular calculation
+            - -1: batch mode work with all numbers on the stack
 
     *   help text
 

rpn.pod

@@ -1,6 +1,6 @@
 =head1 NAME 
 
-rpn - Reverse Polish Notation Calculator for the commandline
+rpn - Programmable command-line calculator using reverse polish notation
 
 =head1 SYNOPSIS
 
@@ -9,6 +9,9 @@ rpn - Reverse Polish Notation Calculator for the commandline
     Options:
       -b, --batchmode     enable batch mode
       -d, --debug         enable debug mode
+      -s, --stack         show last 5 items of the stack (off by default)
+      -i  --intermediate  print intermediate results
+      -m, --manual        show manual
       -v, --version       show version
       -h, --help          show help
     
@@ -106,6 +109,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
@@ -133,6 +139,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
@@ -154,8 +168,111 @@ Math functions:
     log10 log1p log2 logb pow round roundtoeven sin sinh tan tanh trunc y0
     y1 copysign dim hypot
 
+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
+    dup                  duplicate last stack item
+    undo                 undo last operation
+
+Other commands:
+    help|?               show this message
+    manual               show manual
+    quit|exit|c-d|c-c    exit program
+
+
+Register variables:
+
+    >NAME                Put last stack element into variable NAME
+    <NAME                Retrieve variable NAME and put onto stack
+
 Refer to https://pkg.go.dev/math for details about those functions.
 
+=head1 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
+C<rpn> and you'll be there.
+
+In interactive mode you can use TAB completion to complete commands,
+operators and functions. There's also a history, which allows you to
+repeat complicated calculations (as long as you've entered them in one
+line).
+
+There are also a lot of key bindings, here are the most important
+ones:
+
+=over
+
+=item ctrl-c + ctrl-d
+
+Exit interactive rpn
+
+=item ctrl-z
+
+Send rpn to the backgound.
+
+=item ctrl-a
+
+Beginning of line.
+
+=item ctrl-e
+
+End of line.
+
+=item ctrl-l
+
+Clear the screen.
+
+=item ctrl-r
+
+Search through history.
+
+=back
+
+=head1 COMMENTS
+
+Lines starting with  C<#> are being ignored as comments.  You can also
+append comments to rpn input, e.g.:
+
+   # a comment
+   123   # another comment
+
+In this case only 123 will be added to the stack.
+
+=head1 VARIABLES
+
+You can register the last item  of the stack into a variable. Variable
+names must be  all caps. Use the  ">NAME" command to put  a value into
+variable "NAME". Use "<NAME" to  retrieve the value of variable "NAME"
+and put it onto the stack.
+
+The command B<vars> can be used to get a list of all variables.
+
 =head1 EXTENDING RPN USING LUA
 
 You can use a lua script with lua functions to extend the
@@ -189,8 +306,13 @@ function name
 
 =item *
 
-number of arguments expected (1,2 or -1 allowed), -1 means batch
+number of arguments expected (see below)
-mode.
+
+Number of expected arguments can be:
+
+    - 0: expect 1 argument but do NOT modify the stack
+    - 1-n: do a singular calculation
+    - -1: batch mode work with all numbers on the stack 
 
 =item *
 

stack.go

@@ -195,14 +195,24 @@ func (s *Stack) Backup() {
 	// make a backup, because the elements in list.List{} are pointers
 	// and lead to unexpected  results. The methid here works reliably
 	// at least.
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	s.Debug(fmt.Sprintf("backing up %d items from rev %d",
+		s.linklist.Len(), s.rev))
+
 	s.backup = list.List{}
 	for e := s.linklist.Front(); e != nil; e = e.Next() {
-		s.backup.PushBack(e.Value)
+		s.backup.PushBack(e.Value.(float64))
 	}
+
 	s.backuprev = s.rev
 }
 
 func (s *Stack) Restore() {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
 	if s.rev == 0 {
 		fmt.Println("error: stack is empty.")
 		return
@@ -211,15 +221,26 @@ func (s *Stack) Restore() {
 	s.Debug(fmt.Sprintf("restoring stack to revision %d", s.backuprev))
 
 	s.rev = s.backuprev
-	s.linklist = s.backup
+
+	s.linklist = list.List{}
+	for e := s.backup.Front(); e != nil; e = e.Next() {
+		s.linklist.PushBack(e.Value.(float64))
+	}
 }
 
 func (s *Stack) Reverse() {
-	newstack := list.List{}
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	items := []float64{}
 
 	for e := s.linklist.Front(); e != nil; e = e.Next() {
-		newstack.PushFront(e.Value)
+		tail := s.linklist.Back()
+		items = append(items, tail.Value.(float64))
+		s.linklist.Remove(tail)
 	}
 
-	s.linklist = newstack
+	for i := len(items) - 1; i >= 0; i-- {
+		s.linklist.PushFront(items[i])
+	}
 }

test.lua

@@ -1,17 +0,0 @@
-function add(a,b)
-  return a + b
-end
-
-function test(a)
-  return a
-end  
-
-function parallelresistance(a,b)
-  return 1.0 / (a * b)
-end
-
-function init()
-  register("add", 2, "addition")
-  register("test", 1, "test")
-  register("parallelresistance", 2, "parallel resistance")
-end