add getvar instruction, fix call (untested), make less work with strings and update documentation

M  README.md
M  standardbefehlssatz.lua
A  util/standartbefehlssatz_doc.lua

README.md

@@ -9,9 +9,55 @@ true/false: boolean (immediate)
 $hello nwae: string (immediate)  
 nodolla: either a label is called so (immediate) or it's a variable
 
+```
+Types:
+
+e   anything
+v   any variable
+ve  any set variable
+s   string
+vs  string variable
+n   number
+vn  number variable
+ui  unsigned integer number
+b   bool
+vn  bool variable
 
 
-How to use this mod:
+Instructions:
+
+mov          <v to>, <e from>              Copies from into to.
+getvar       <vs varname>[, <ve exists>]   Sets varname to the current variable called <varname> if it's set. If exists is passed, it's set to a bool indicating whether the variable was set.
+add          <vn to>, <n from>             to += from
+add          <vb to>, <b from>             to = to and from
+add          <vs to>, <s from>             to = to .. from
+mul          <vn to>, <n from>             to *= from
+mul          <vb to>, <b from>             to = to or from
+mul          <vs str>, <n cnt>             str = str:rep(from)
+neg          <vn num>                      num = -num
+neg          <vb var>                      var = not var
+neg          <vs str>                      str = str:rev()
+inv          <vn num>                      num = 1 / num
+mod          <vn num>, <n dv>              num = num % dv
+jmp          <ui p>[, <e c>]               If c is not false, the instruction pointer is set to p. To disallow infinite loops, the program is interrupted after changing the ip, the mod should then consider restarting it.
+call         <ui p>                        push the ip, then jmp p; used to execute subroutines
+ret                                        pop something, then jmp there; used to exit subroutines
+push         <e a>[, <e b>[, <e c>[…]]]  put values onto the stack; from left to right
+pop          <v a>[, <v b>[, <v c>[…]]]  takes values from the stack and sets the passed variables to them; from left to right
+equal        <v a>, <e b>                  a = a == b
+less         <vn a>, <n b>                 a = a < b; after executing, a is a bool
+less         <vs a>, <s b>                 a = a < b; less also works for strings
+usleep       <n t>                         aborts the program for at least floor(max(0, t)) ms
+sleep        <n t>                         executes usleep with t * 1000000 as argument
+get_us_time  <v to>                        stores minetest.get_us_time() into to; can be used to measure time differences
+tostring     <ve var>                      var = tostring(var)
+print        <e a>[, <e b>[, <e c>[…]]]  adds variables to the log, seperated by \t, \n is added at the end
+flush                                      Output the log, this should vary for every mod.
+```
+
+
+
+How mods can use this mod:
 
 ```
 local mylog = print
@@ -26,13 +72,13 @@ local function mystart(parsed_code)
 			return true
 		end
 	end, parsed_code)
+	thread:suscitate()
 	mykeepalive(thread)
 end
 
 mystart(parsed_code)
 
 local function mykeepalive(thread)
-	thread:suscitate()
 	if not thread.stopped then
 		return
 	end

standardbefehlssatz.lua

@@ -12,6 +12,15 @@ s = {
 		return true, params[2]
 	end,
 
+	getvar = function(params, faden)
+		local p = params[1]
+		if type(p) ~= "string" then
+			return false, UAT
+		end
+		p = faden.vars[p]
+		return true, {p, params[2] and p ~= nil}
+	end,
+
 	add = function(params, faden)
 		if #params ~= 2 then
 			return false, WNOA
@@ -144,7 +153,7 @@ s = {
 		if not subsucc then
 			return false, SE .. msg
 		end
-		subsucc,msg = s.jmp({msg}, faden)
+		subsucc,msg = s.jmp(msg, faden)
 		if not subsucc then
 			return false, SE .. msg
 		end
@@ -194,8 +203,14 @@ s = {
 			return false, WNOA
 		end
 		local p1,p2 = unpack(params)
-		if type(p1) ~= "number"
+		local t1 = type(p1)
-		or type(p2) ~= "number" then
+		local t2 = type(p2)
+		if t1 ~= t2 then
+			return false, "different argument types"
+		end
+
+		if t1 ~= "number"
+		and t1 ~= "string" then
 			return false, UAT
 		end
 		return true, p1 < p2

util/standartbefehlssatz_doc.lua

@@ -0,0 +1,66 @@
+local types = {
+	{"e", "anything"},
+	{"v", "any variable"},
+	{"ve", "any set variable"},
+	{"s", "string"},
+	{"vs", "string variable"},
+	{"n", "number"},
+	{"vn", "number variable"},
+	{"ui", "unsigned integer number"},
+	{"b", "bool"},
+	{"vn", "bool variable"}
+}
+
+local instr = {
+	{"mov", "<v to>, <e from>", "Copies from into to."},
+	{"getvar", "<vs varname>[, <ve exists>]", "Sets varname to the current variable called <varname> if it's set. If exists is passed, it's set to a bool indicating whether the variable was set."},
+	{"add", "<vn to>, <n from>", "to += from"},
+	{"add", "<vb to>, <b from>", "to = to and from"},
+	{"add", "<vs to>, <s from>", "to = to .. from"},
+	{"mul", "<vn to>, <n from>", "to *= from"},
+	{"mul", "<vb to>, <b from>", "to = to or from"},
+	{"mul", "<vs str>, <n cnt>", "str = str:rep(from)"},
+	{"neg", "<vn num>", "num = -num"},
+	{"neg", "<vb var>", "var = not var"},
+	{"neg", "<vs str>", "str = str:rev()"},
+	{"inv", "<vn num>", "num = 1 / num"},
+	{"mod", "<vn num>, <n dv>", "num = num % dv"},
+	{"jmp", "<ui p>[, <e c>]", "If c is not false, the instruction pointer is set to p. To disallow infinite loops, the program is interrupted after changing the ip, the mod should then consider restarting it."},
+	{"call", "<ui p>", "push the ip, then jmp p; used to execute subroutines"},
+	{"ret", "", "pop something, then jmp there; used to exit subroutines"},
+	{"push", "<e a>[, <e b>[, <e c>[…]]]", "put values onto the stack; from left to right"},
+	{"pop", "<v a>[, <v b>[, <v c>[…]]]", "takes values from the stack and sets the passed variables to them; from left to right"},
+	{"equal", "<v a>, <e b>", "a = a == b"},
+	{"less", "<vn a>, <n b>", "a = a < b; after executing, a is a bool"},
+	{"less", "<vs a>, <s b>", "a = a < b; less also works for strings"},
+	{"usleep", "<n t>", "aborts the program for at least floor(max(0, t)) ms"},
+	{"sleep", "<n t>", "executes usleep with t * 1000000 as argument"},
+	{"get_us_time", "<v to>", "stores minetest.get_us_time() into to; can be used to measure time differences"},
+	{"tostring", "<ve var>", "var = tostring(var)"},
+	{"print", "<e a>[, <e b>[, <e c>[…]]]", "adds variables to the log, seperated by \\t, \\n is added at the end"},
+	{"flush", "", "Output the log, this should vary for every mod."},
+}
+
+local mbl = 0
+local mal = 0
+for i = 1,#instr do
+	local bef = instr[i]
+	mbl = math.max(#bef[1], mbl)
+	mal = math.max(#bef[2], mal)
+end
+
+local mtl = 2
+
+local o = "Types:\n\n"
+for i = 1,#types do
+	local t = types[i]
+	o = o .. t[1] .. (" "):rep(mtl - #t[1] + 2) .. t[2] .. "\n"
+end
+
+o = o .. "\n\nInstructions:\n\n"
+for i = 1,#instr do
+	i = instr[i]
+	o = o .. i[1] .. (" "):rep(mbl - #i[1] + 2) .. i[2] .. (" "):rep(mal - #i[2] + 2) .. i[3] .. "\n"
+end
+
+print(o)