Merge branch 'master' into feature/add-converters

* added:

- converters
- bitwise operators
- hex input and output support

calc.go

@@ -20,8 +20,8 @@ package main
 import (
 	"errors"
 	"fmt"
-	"os"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -48,27 +48,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:
+const Help string = `
-batch                toggle batch mode
-debug                toggle debug output
-show                 show the last 5 items of the stack
-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
-
 Operators:
 basic operators: + - x * / ^  (* is an alias of x)
 
+Bitwise operators: and or xor < (left shift) > (right shift)
+
 Percent functions:
 %                    percent
 %-                   substract percent
@@ -94,7 +89,7 @@ Register variables:
 // 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 show 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`
 )
 
@@ -107,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
@@ -126,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
 	}
 
@@ -151,6 +161,8 @@ func NewCalc() *Calc {
 	// pre-calculate mode switching arrays
 	c.Constants = strings.Split(Constants, " ")
 
+	c.SetCommands()
+
 	return &c
 }
 
@@ -225,6 +237,15 @@ func (c *Calc) Eval(line string) {
 			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()
@@ -274,65 +295,32 @@ func (c *Calc) Eval(line string) {
 				continue
 			}
 
-			// management commands
+			// 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
+			}
+
 			switch item {
 			case "?":
 				fallthrough
 			case "help":
-				fmt.Println(Help)
+				c.PrintHelp()
-				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 "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 "show":
-				c.ToggleShow()
-			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!")
@@ -519,3 +507,51 @@ 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 {
+		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

@@ -241,6 +241,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 {

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"]
+}

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

main.go

@@ -30,7 +30,7 @@ import (
 	lua "github.com/yuin/gopher-lua"
 )
 
-const VERSION string = "2.0.7"
+const VERSION string = "2.0.10"
 
 const Usage string = `This is rpn, a reverse polish notation calculator cli.
 

rpn.go

@@ -105,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
@@ -129,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
@@ -150,18 +161,33 @@ DESCRIPTION
         log10 log1p log2 logb pow round roundtoeven sin sinh tan tanh trunc y0
         y1 copysign dim hypot
 
-    Commands:
+    Conversion functions:
 
-        batch                toggle batch mode
+        cm-to-inch
-        debug                toggle debug output
+        inch-to-cm
-        dump                 display the stack contents
+        gallons-to-liters
-        clear                clear the whole stack
+        liters-to-gallons
-        shift                remove the last element of the stack
+        yards-to-meters
-        reverse              reverse the stack elements
+        meters-to-yards
-        swap                 exchange the last two stack elements
+        miles-to-kilometers
-        show                 show the last 5 items of the stack
+        kilometers-to-miles
-        history              display calculation history
+
-        help|?               show this message
+    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:

rpn.pod

@@ -109,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
@@ -136,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
@@ -157,18 +168,40 @@ Math functions:
     log10 log1p log2 logb pow round roundtoeven sin sinh tan tanh trunc y0
     y1 copysign dim hypot
 
-Commands:
+Conversion functions:
 
-    batch                toggle batch mode
+    cm-to-inch
-    debug                toggle debug output
+    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
-    show                 show the last 5 items of the stack
+    dup                  duplicate last stack item
-    history              display calculation history
+    undo                 undo last operation
+
+Other commands:
     help|?               show this message
+    manual               show manual
     quit|exit|c-d|c-c    exit program