revert exists(), unused

* re-organized command structure
* added 'dup' command

README.md

@@ -225,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
-  mode
+- number of arguments expected (see below)
 - 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"
 
@@ -48,24 +48,17 @@ 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
-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
-
+const Help string = `
 Operators:
 basic operators: + - x * / ^  (* is an alias of x)
 
@@ -94,7 +87,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 +100,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 +118,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,16 +159,18 @@ func NewCalc() *Calc {
 	// pre-calculate mode switching arrays
 	c.Constants = strings.Split(Constants, " ")
 
-	for name := range LuaFuncs {
-		c.LuaFunctions = append(c.LuaFunctions, name)
-	}
+	c.SetCommands()
 
 	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() {
@@ -259,7 +269,7 @@ func (c *Calc) Eval(line string) {
 
 			if contains(c.LuaFunctions, item) {
 				// user provided custom lua functions
-				c.luafunc(item)
+				c.EvalLuaFunction(item)
 				continue
 			}
 
@@ -274,65 +284,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)
-				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")
-				}
+				c.PrintHelp()
 
 			default:
 				fmt.Println("unknown command or operator!")
@@ -393,6 +370,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()
@@ -442,12 +423,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:
@@ -465,7 +448,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)
@@ -478,7 +469,9 @@ func (c *Calc) luafunc(funcname string) {
 		c.History("%s(*) = %f", funcname, x)
 	}
 
-	c.stack.Push(x)
+	if dopush {
+		c.stack.Push(x)
+	}
 
 	c.Result()
 }
@@ -503,3 +496,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

@@ -20,6 +20,8 @@ package main
 import (
 	"fmt"
 	"testing"
+
+	lua "github.com/yuin/gopher-lua"
 )
 
 func TestCommentsAndWhitespace(t *testing.T) {
@@ -104,6 +106,7 @@ func TestCalc(t *testing.T) {
 		exp   float64
 		batch bool
 	}{
+		// ops
 		{
 			name: "plus",
 			cmd:  `15 15 +`,
@@ -144,6 +147,8 @@ func TestCalc(t *testing.T) {
 			cmd:  `400 20 %+`,
 			exp:  480,
 		},
+
+		// math tests
 		{
 			name: "mod",
 			cmd:  `9 2 mod`,
@@ -164,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`,
@@ -194,6 +213,34 @@ 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,
+		},
 	}
 
 	for _, tt := range tests {
@@ -212,3 +259,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,201 @@
+/*
+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")
+				}
+			},
+		),
+	}
+
+	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"]
+}

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  

interpreter.go

@@ -25,7 +25,8 @@ import (
 )
 
 type Interpreter struct {
-	debug bool
+	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.5"
+const VERSION string = "2.0.9"
 
 const Usage string = `This is rpn, a reverse polish notation calculator cli.
 
@@ -98,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)
-		calc.SetInt(I)
+		luarunner := NewInterpreter(configfile, enabledebug)
+		luarunner.InitLua()
+		calc.SetInt(luarunner)
 	}
 
 	if len(flag.Args()) > 1 {

rpn.go

@@ -152,14 +152,15 @@ DESCRIPTION
 
     Commands:
 
-        batch                toggle batch mode
-        debug                toggle debug output
+        [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)
         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 stack elements
-        show                 show the last 5 items of the stack
+        dup                  duplicate last stack item
         history              display calculation history
         help|?               show this message
         quit|exit|c-d|c-c    exit program
@@ -210,7 +211,6 @@ COMMENTS
 
     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
@@ -245,8 +245,13 @@ EXTENDING RPN USING LUA
 
     *   function name
 
-    *   number of arguments expected (1,2 or -1 allowed), -1 means batch
-        mode.
+    *   number of arguments expected (see below)
+
+        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

@@ -159,14 +159,15 @@ Math functions:
 
 Commands:
 
-    batch                toggle batch mode
-    debug                toggle debug output
+    [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)
     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 stack elements
-    show                 show the last 5 items of the stack
+    dup                  duplicate last stack item
     history              display calculation history
     help|?               show this message
     quit|exit|c-d|c-c    exit program
@@ -273,8 +274,13 @@ function name
 
 =item *
 
-number of arguments expected (1,2 or -1 allowed), -1 means batch
-mode.
+number of arguments expected (see below)
+
+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