Bruce/nomsu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some stuff changed to allow escaped args and some other ports from the

Browse Source 
two_defs branch.
This commit is contained in:
Bruce Hill 2017-12-04 17:35:47 -08:00
parent 8c0816995a
commit b3b8c4d731
7 changed files with 549 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/collections.nom
View File

@ -93,7 +93,7 @@ rule [dict from entries %items] =:
%dict -> (%pair -> 1) = (%pair -> 2) %dict -> (%pair -> 1) = (%pair -> 2)
%dict %dict
compile [dict %items] to: compile [dict %items, d %items] to:
if ((%items's "type") == "Thunk"): if ((%items's "type") == "Thunk"):
%item_codes = [] %item_codes = []
for %func_call in (%items's "value"): for %func_call in (%items's "value"):

49
lib/control_flow.nom
View File

@ -218,11 +218,48 @@ compile [when %branch_value == ? %body] to code:
|end --when == ? |end --when == ?
%result %result
# With statement # Try/except
compile [with %thing = %value %action] to code: ".." compile [..]
try %action and if it succeeds %success or if it fails %fallback
try %action and if it fails %fallback or if it succeeds %success
..to code: ".."
|do |do
| local old_value = \(%thing as lua); | local fell_through = false;
| \(%thing as lua) = \(%value as lua); | local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements); | \(%action as lua statements)
| \(%thing as lua) = old_value; | fell_through = true;
| end, nomsu, vars);
| if ok then
| \(%success as lua statements)
| end
| if not ok then
| \(%fallback as lua statements)
| elseif not fell_through then
| return ret1, ret2;
| end
|end |end
parse [try %action] as:
try %action and if it succeeds {pass} or if it fails {pass}
parse [try %action and if it fails %fallback] as:
try %action and if it succeeds {pass} or if it fails %fallback
parse [try %action and if it succeeds %success] as:
try %action and if it succeeds %success or if it fails {pass}
# Do/finally:
compile [do %action then always %final_action] to code: ".."
|do
| local fell_through = false;
| local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements)
| fell_through = true;
| end, nomsu, vars);
| local ok2, _ = pcall(function(nomsu, vars)
| \(%final_action as lua statements)
| end, nomsu, vars);
| if not ok then nomsu:error(ret1); end
| if not ok2 then nomsu:error(ret2); end
| if not fell_through then
| return ret1, ret2;
| end
|end

56
lib/permissions.nom
View File

@ -3,52 +3,16 @@ require "lib/control_flow.nom"
require "lib/operators.nom" require "lib/operators.nom"
require "lib/collections.nom" require "lib/collections.nom"
# Permission functions rule [called by %whitelist] =:
rule [standardize rules %rules] =: if ((%whitelist's "type") != "List"): %whitelist = [%whitelist]
if ((type of %rules) == "string"): %rules = [%rules] %defs = (..)
%stubs = (nomsu "get_stubs" [%rules]) dict ([(nomsu's "defs")->(nomsu "get_stub" [%]), yes] for all %whitelist)
%result = [] for %caller in (nomsu's "callstack"):
for %stub in %stubs: if (%caller == "#macro"): do next %caller
%def = ((nomsu's "defs")->%stub) if (%defs -> (nomsu "get_stub" [%caller's 1])): return (yes)
if %def: return (no)
%aliases = (%def's "aliases")
for all %aliases: add % to %result
..else: add %def to %result
unique %result
rule [restrict %rules to within %elite_rules] =: parse [fail unless called by %whitelist] as:
%rules = (standardize rules %rules) unless (called by %whitelist): error "Failed to find \(%whitelist) in callstack."
%elite_rules = (standardize rules %elite_rules)
for all (flatten [%elite_rules, %rules]):
assert ((nomsu's "defs") has key %) "Undefined function: \(%)"
for %rule in %rules:
assert (nomsu "check_permission" [%]) ".."
|You do not have permission to restrict permissions for function: \(%)
((nomsu) ->* ["defs",%rule,"whiteset"]) = (..)
dict ([%, yes] for all %elite_rules)
rule [allow %elite_rules to use %rules] =:
%rules = (standardize rules %rules)
%elite_rules = (standardize rules %elite_rules)
for all (flatten [%elite_rules, %rules]):
assert ((nomsu's "defs") has key %) "Undefined function: \(%)"
for %rule in %rules:
assert (nomsu "check_permission" [%rule]) ".."
|You do not have permission to grant permissions for function: \(%rule)
%whiteset = ((nomsu) ->* ["defs",%rule,"whiteset"])
if (not %whiteset): go to next %rule
for all %elite_rules: %whiteset -> % = (yes)
rule [forbid %pleb_rules to use %rules] =:
%rules = (standardize rules %rules)
%pleb_rules = (standardize rules %pleb_rules)
for all (flatten [%pleb_rules, %used]):
assert ((nomsu's "defs") has key %) "Undefined function: \(%)"
for all %rules:
assert (nomsu "check_permission" [%]) ".."
|You do not have permission to grant permissions for function: \(%)
%whiteset = ((nomsu) ->* ["defs",%,"whiteset"])
assert %whiteset ".."
|Cannot individually restrict permissions for \(%) because it is currently
|available to everyone. Perhaps you meant to use "restrict % to within %" instead?
for all %pleb_rules: %whiteset's % = (nil)

21
lib/utils.nom
View File

@ -130,24 +130,3 @@ lua> ".."
| end; | end;
|end; |end;
compile [try %action and if it fails %fallback] to code: ".."
|do
| local _write_err = nomsu.write_err
| nomsu.write_err = function() end;
| local had_return = true;
| local ok, ret1, ret2 = pcall(function(nomsu, vars)
| local ret
| \(%action as lua statements)
| had_return = false;
| return ret;
| end, nomsu, vars);
| nomsu.write_err = _write_err;
| if not ok then
| \(%fallback as lua statements)
| elseif had_return then
| return ret1, ret2;
| else
| ret = ret1;
| end
|end

42
lib/utils2.nom
View File

@ -2,9 +2,51 @@ require "lib/metaprogramming.nom"
require "lib/utils.nom" require "lib/utils.nom"
require "lib/control_flow.nom" require "lib/control_flow.nom"
require "lib/operators.nom" require "lib/operators.nom"
require "lib/collections.nom"
compile [say %str] to: compile [say %str] to:
if ((%str's "type") == "String"): if ((%str's "type") == "String"):
"nomsu:writeln(\(%str as lua))" "nomsu:writeln(\(%str as lua))"
..else: ..else:
"nomsu:writeln(nomsu:stringify(\(%str as lua)))" "nomsu:writeln(nomsu:stringify(\(%str as lua)))"
compile [do %action] to code:
if ((%action's "type") == "Thunk"):
%action as lua statements
..else:
"(\(%action as lua))(nomsu, vars);"
# With statement
compile [with %assignments %action] to code:
%data = []
for %i = %assignment in (%assignments' "value"):
%tokens = (%assignment's "value")
%var = (%tokens -> 1)
%eq = (%tokens -> 2)
assert (=lua "vars.eq and vars.eq.type == 'Word' and vars.eq.value == '='") ".."
|Invalid format for 'with' statement. List entries must have the form %var = (value)
%value = (%tokens -> 3)
add (d{i=%i; var=%var; value=%value}) to %data
%foo = (..)
join (..)
"local old_value\(%->"i") = \((%->"var") as lua); \((%->"var") as lua) = \((%->"value") as lua);"
..for all %data
..with glue "\n "
".."
|do
| \(%foo)
| local fell_through = false;
| local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements);
| fell_through = true;
| end, nomsu, vars);
| \(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ")
| if not ok then nomsu:error(ret1); end
| if not fell_through then
| return ret1, ret2;
| end
|end
parse [with %thing = %value %action] as: with [%thing = %value] %action

376
nomsu.lua
View File

@ -19,6 +19,19 @@ do
local _obj_0 = table local _obj_0 = table
insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat
end end
if _VERSION == "Lua 5.1" then
local xp = xpcall
local xpcall
xpcall = function(f, errhandler, ...)
local args = {
n = select("#", ...),
...
}
return xp(function(...)
return f(unpack(args, 1, args.n))
end), errhandler
end
end
lpeg.setmaxstack(10000) lpeg.setmaxstack(10000)
local P, V, S, Cg, C, Cp, B, Cmt local P, V, S, Cg, C, Cp, B, Cmt
P, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt P, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt
@ -166,12 +179,23 @@ local defs = {
return pos, tostring(CURRENT_FILE) .. ":" .. tostring(line_no) return pos, tostring(CURRENT_FILE) .. ":" .. tostring(line_no)
end, end,
FunctionCall = function(src, line_no, value, errors) FunctionCall = function(src, line_no, value, errors)
local stub = concat((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #value do
local t = value[_index_0]
_accum_0[_len_0] = (t.type == "Word" and t.value or "%")
_len_0 = _len_0 + 1
end
return _accum_0
end)(), " ")
return { return {
type = "FunctionCall", type = "FunctionCall",
src = src, src = src,
line_no = line_no, line_no = line_no,
value = value, value = value,
errors = errors errors = errors,
stub = stub
} }
end, end,
error = function(src, pos, errors, err_msg) error = function(src, pos, errors, err_msg)
@ -241,12 +265,22 @@ do
end end
assert(type(thunk) == 'function', "Bad thunk: " .. tostring(repr(thunk))) assert(type(thunk) == 'function', "Bad thunk: " .. tostring(repr(thunk)))
local canonical_args = nil local canonical_args = nil
local canonical_escaped_args = nil
local aliases = { } local aliases = { }
self.def_number = self.def_number + 1 self.__class.def_number = self.__class.def_number + 1
local def = {
thunk = thunk,
src = src,
is_macro = is_macro,
aliases = { },
def_number = self.__class.def_number,
defs = self.defs
}
local where_defs_go = ((getmetatable(self.defs) or { }).__newindex) or self.defs
for _index_0 = 1, #signature do for _index_0 = 1, #signature do
local _des_0 = signature[_index_0] local _des_0 = signature[_index_0]
local stub, arg_names local stub, arg_names, escaped_args
stub, arg_names = _des_0[1], _des_0[2] stub, arg_names, escaped_args = _des_0[1], _des_0[2], _des_0[3]
assert(stub, "NO STUB FOUND: " .. tostring(repr(signature))) assert(stub, "NO STUB FOUND: " .. tostring(repr(signature)))
if self.debug then if self.debug then
self:writeln(tostring(colored.bright("DEFINING RULE:")) .. " " .. tostring(colored.underscore(colored.magenta(repr(stub)))) .. " " .. tostring(colored.bright("WITH ARGS")) .. " " .. tostring(colored.dim(repr(arg_names)))) self:writeln(tostring(colored.bright("DEFINING RULE:")) .. " " .. tostring(colored.underscore(colored.magenta(repr(stub)))) .. " " .. tostring(colored.bright("WITH ARGS")) .. " " .. tostring(colored.dim(repr(arg_names))))
@ -263,38 +297,104 @@ do
else else
canonical_args = utils.set(arg_names) canonical_args = utils.set(arg_names)
end end
insert(aliases, stub) if canonical_escaped_args then
self.defs[stub] = { assert(utils.equivalent(escaped_args, canonical_escaped_args), "Mismatched escaped args")
thunk = thunk, else
canonical_escaped_args = escaped_args
def.escaped_args = escaped_args
end
insert(def.aliases, stub)
local stub_def = setmetatable({
stub = stub, stub = stub,
arg_names = arg_names, arg_names = arg_names,
src = src, escaped_args = escaped_args
is_macro = is_macro, }, {
aliases = aliases, __index = def
def_number = self.def_number })
} rawset(where_defs_go, stub, stub_def)
end end
end, end,
defmacro = function(self, signature, thunk, src) defmacro = function(self, signature, thunk, src)
return self:def(signature, thunk, src, true) return self:def(signature, thunk, src, true)
end, end,
serialize_defs = function(self, after) scoped = function(self, thunk)
local old_defs = self.defs
self.defs = setmetatable({ }, {
__index = old_defs
})
local ok, ret1, ret2 = pcall(thunk, self)
self.defs = old_defs
if not ok then
self:error(ret1)
end
return ret1, ret2
end,
serialize_defs = function(self, scope, after)
if scope == nil then
scope = nil
end
if after == nil then if after == nil then
after = 0 after = 0
end end
defs = { } scope = scope or self.defs
for _, def in pairs(self.defs) do local defs_by_num = { }
defs[def.def_number] = def.src or "" for stub, def in pairs(scope) do
if def and stub:sub(1, 1) ~= "#" then
defs_by_num[def.def_number] = def
end
end
local keys
do
local _accum_0 = { }
local _len_0 = 1
for k, v in pairs(defs_by_num) do
_accum_0[_len_0] = k
_len_0 = _len_0 + 1
end
keys = _accum_0
end end
local keys = utils.keys(defs)
table.sort(keys) table.sort(keys)
local buff = { } local buff = { }
for _index_0 = 1, #keys do local k_i = 1
local i = keys[_index_0] local _using = nil
if i > after and #defs[i] > 0 then local _using_do = { }
insert(buff, defs[i]) for k_i, i in ipairs(keys) do
local _continue_0 = false
repeat
if i <= after then
_continue_0 = true
break
end
local def = defs_by_num[i]
if def.defs == scope then
if def.src then
insert(buff, def.src)
end
_continue_0 = true
break
end
if _using == def.defs then
if def.src then
insert(_using_do, def.src)
end
else
_using = def.defs
_using_do = {
def.src
}
end
if k_i == #keys or defs_by_num[keys[k_i + 1]].defs ~= _using then
insert(buff, "using:\n " .. tostring(self:indent(self:serialize_defs(_using))) .. "\n..do:\n " .. tostring(self:indent(concat(_using_do, "\n"))))
end
_continue_0 = true
until true
if not _continue_0 then
break
end end
end end
for k, v in pairs(scope["#vars"] or { }) do
insert(buff, "<@" .. tostring(k) .. "> = " .. tostring(self:value_to_nomsu(v)))
end
return concat(buff, "\n") return concat(buff, "\n")
end, end,
call = function(self, stub, line_no, ...) call = function(self, stub, line_no, ...)
@ -306,7 +406,7 @@ do
stub, stub,
line_no line_no
}) })
if def == nil then if not (def) then
self:error("Attempt to call undefined function: " .. tostring(stub)) self:error("Attempt to call undefined function: " .. tostring(stub))
end end
if not (def.is_macro) then if not (def.is_macro) then
@ -326,14 +426,16 @@ do
self:write(tostring(colored.bright("CALLING")) .. " " .. tostring(colored.magenta(colored.underscore(stub))) .. " ") self:write(tostring(colored.bright("CALLING")) .. " " .. tostring(colored.magenta(colored.underscore(stub))) .. " ")
self:writeln(tostring(colored.bright("WITH ARGS:")) .. " " .. tostring(colored.dim(repr(args)))) self:writeln(tostring(colored.bright("WITH ARGS:")) .. " " .. tostring(colored.dim(repr(args))))
end end
local old_defs
old_defs, self.defs = self.defs, def.defs
local rets = { local rets = {
thunk(self, args) thunk(self, args)
} }
self.defs = old_defs
remove(self.callstack) remove(self.callstack)
return unpack(rets) return unpack(rets)
end, end,
run_macro = function(self, tree) run_macro = function(self, tree)
local stub = self:get_stub(tree)
local args local args
do do
local _accum_0 = { } local _accum_0 = { }
@ -349,14 +451,55 @@ do
args = _accum_0 args = _accum_0
end end
if self.debug then if self.debug then
self:write(tostring(colored.bright("RUNNING MACRO")) .. " " .. tostring(colored.underscore(colored.magenta(stub))) .. " ") self:write(tostring(colored.bright("RUNNING MACRO")) .. " " .. tostring(colored.underscore(colored.magenta(tree.stub))) .. " ")
self:writeln(tostring(colored.bright("WITH ARGS:")) .. " " .. tostring(colored.dim(repr(args)))) self:writeln(tostring(colored.bright("WITH ARGS:")) .. " " .. tostring(colored.dim(repr(args))))
end end
insert(self.callstack, "#macro") insert(self.callstack, "#macro")
local expr, statement = self:call(stub, tree.line_no, unpack(args)) local expr, statement = self:call(tree.stub, tree.line_no, unpack(args))
remove(self.callstack) remove(self.callstack)
return expr, statement return expr, statement
end, end,
dedent = function(self, code)
if not (code:find("\n")) then
return code
end
local spaces, indent_spaces = math.huge, math.huge
for line in code:gmatch("\n([^\n]*)") do
local _continue_0 = false
repeat
if line:match("^%s*#.*") then
_continue_0 = true
break
else
do
local s = line:match("^(%s*)%.%..*")
if s then
spaces = math.min(spaces, #s)
else
do
s = line:match("^(%s*)%S.*")
if s then
indent_spaces = math.min(indent_spaces, #s)
end
end
end
end
end
_continue_0 = true
until true
if not _continue_0 then
break
end
end
if spaces ~= math.huge and spaces < indent_spaces then
return (code:gsub("\n" .. (" "):rep(spaces), "\n"))
else
return (code:gsub("\n" .. (" "):rep(indent_spaces), "\n "))
end
end,
indent = function(self, code)
return (code:gsub("\n", "\n "))
end,
assert_permission = function(self, stub) assert_permission = function(self, stub)
local fn_def = self.defs[stub] local fn_def = self.defs[stub]
if not (fn_def) then if not (fn_def) then
@ -451,7 +594,7 @@ do
local ok, expr, statements = pcall(self.tree_to_lua, self, statement) local ok, expr, statements = pcall(self.tree_to_lua, self, statement)
if not ok then if not ok then
self:errorln(tostring(colored.red("Error occurred in statement:")) .. "\n" .. tostring(colored.bright(colored.yellow(statement.src)))) self:errorln(tostring(colored.red("Error occurred in statement:")) .. "\n" .. tostring(colored.bright(colored.yellow(statement.src))))
self:error(expr) error(expr)
end end
local code_for_statement = ([[return (function(nomsu, vars) local code_for_statement = ([[return (function(nomsu, vars)
%s %s
@ -480,7 +623,7 @@ end);]]):format(statements or "", expr or "ret")
if not ok then if not ok then
self:errorln(tostring(colored.red("Error occurred in statement:")) .. "\n" .. tostring(colored.yellow(statement.src))) self:errorln(tostring(colored.red("Error occurred in statement:")) .. "\n" .. tostring(colored.yellow(statement.src)))
self:errorln(debug.traceback()) self:errorln(debug.traceback())
self:error(ret) error(ret)
end end
if statements then if statements then
insert(buffer, statements) insert(buffer, statements)
@ -514,10 +657,6 @@ end);]]):format(concat(buffer, "\n"))
if force_inline == nil then if force_inline == nil then
force_inline = false force_inline = false
end end
local indent
indent = function(s)
return s:gsub("\n", "\n ")
end
assert(tree, "No tree provided.") assert(tree, "No tree provided.")
if not tree.type then if not tree.type then
self:errorln(debug.traceback()) self:errorln(debug.traceback())
@ -553,7 +692,7 @@ end);]]):format(concat(buffer, "\n"))
return _accum_0 return _accum_0
end)(), "; ")), true end)(), "; ")), true
else else
return ":" .. indent("\n" .. concat((function() return ":" .. self:indent("\n" .. concat((function()
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
local _list_0 = tree.value local _list_0 = tree.value
@ -569,17 +708,23 @@ end);]]):format(concat(buffer, "\n"))
local buff = "" local buff = ""
local sep = "" local sep = ""
local inline = true local inline = true
local do_arg local line_len = 0
do_arg = function(arg) end
local _list_0 = tree.value local _list_0 = tree.value
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
local arg = _list_0[_index_0] local arg = _list_0[_index_0]
local arg_inline local arg_inline
nomsu, arg_inline = self:tree_to_nomsu(arg, force_inline) nomsu, arg_inline = self:tree_to_nomsu(arg, force_inline)
buff = buff .. sep if sep == " " and line_len + #nomsu > 80 then
sep = "\n.."
end
if not (sep == " " and not arg_inline and nomsu:sub(1, 1) == ":") then
buff = buff .. sep
end
if arg_inline then if arg_inline then
sep = " " sep = " "
line_len = line_len + (1 + #nomsu)
else else
line_len = 0
inline = false inline = false
sep = "\n.." sep = "\n.."
end end
@ -587,7 +732,7 @@ end);]]):format(concat(buffer, "\n"))
if arg_inline then if arg_inline then
buff = buff .. "(" .. tostring(nomsu) .. ")" buff = buff .. "(" .. tostring(nomsu) .. ")"
else else
buff = buff .. "(..)\n " .. tostring(indent(nomsu)) buff = buff .. "(..)\n " .. tostring(self:indent(nomsu))
end end
else else
buff = buff .. nomsu buff = buff .. nomsu
@ -658,6 +803,41 @@ end);]]):format(concat(buffer, "\n"))
return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type)) return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type))
end end
end, end,
value_to_nomsu = function(self, value)
local _exp_0 = type(value)
if "nil" == _exp_0 then
return "(nil)"
elseif "bool" == _exp_0 then
return value and "(yes)" or "(no)"
elseif "number" == _exp_0 then
return repr(value)
elseif "table" == _exp_0 then
if utils.is_list(value) then
return "[" .. tostring(concat((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #value do
local v = value[_index_0]
_accum_0[_len_0] = self:value_to_nomsu(v)
_len_0 = _len_0 + 1
end
return _accum_0
end)(), ", ")) .. "]"
else
return "(d{" .. tostring(concat((function()
local _accum_0 = { }
local _len_0 = 1
for k, v in pairs(value) do
_accum_0[_len_0] = tostring(self:value_to_nomsu(k)) .. "=" .. tostring(self:value_to_nomsu(v))
_len_0 = _len_0 + 1
end
return _accum_0
end)(), "; ")) .. "})"
end
else
return error("Unsupported value_to_nomsu type: " .. tostring(type(value)))
end
end,
tree_to_lua = function(self, tree) tree_to_lua = function(self, tree)
assert(tree, "No tree provided.") assert(tree, "No tree provided.")
if not tree.type then if not tree.type then
@ -668,7 +848,7 @@ end);]]):format(concat(buffer, "\n"))
if "File" == _exp_0 then if "File" == _exp_0 then
return error("Should not be converting File to lua through this function.") return error("Should not be converting File to lua through this function.")
elseif "Nomsu" == _exp_0 then elseif "Nomsu" == _exp_0 then
return "nomsu:parse(" .. tostring(repr(tree.value.src)) .. ").value[1]", nil return "nomsu:parse(" .. tostring(repr(tree.value.src)) .. ", " .. tostring(repr(CURRENT_FILE)) .. ").value[1]", nil
elseif "Thunk" == _exp_0 then elseif "Thunk" == _exp_0 then
local lua_bits = { } local lua_bits = { }
local _list_0 = tree.value local _list_0 = tree.value
@ -688,24 +868,42 @@ local ret;
return ret; return ret;
end)]]):format(concat(lua_bits, "\n")) end)]]):format(concat(lua_bits, "\n"))
elseif "FunctionCall" == _exp_0 then elseif "FunctionCall" == _exp_0 then
local stub = self:get_stub(tree) local def = self.defs[tree.stub]
local def = self.defs[stub]
if def and def.is_macro then if def and def.is_macro then
local expr, statement = self:run_macro(tree) local expr, statement = self:run_macro(tree)
if def.whiteset then if def.whiteset then
if expr then if expr then
expr = "(nomsu:assert_permission(" .. tostring(repr(stub)) .. ") and " .. tostring(expr) .. ")" expr = "(nomsu:assert_permission(" .. tostring(repr(tree.stub)) .. ") and " .. tostring(expr) .. ")"
end end
if statement then if statement then
statement = "nomsu:assert_permission(" .. tostring(repr(stub)) .. ");\n" .. statement statement = "nomsu:assert_permission(" .. tostring(repr(tree.stub)) .. ");\n" .. statement
end end
end end
return expr, statement return expr, statement
end end
local args = { local args = {
repr(stub), repr(tree.stub),
repr(tree.line_no) repr(tree.line_no)
} }
local arg_names, escaped_args
if def then
arg_names, escaped_args = def.arg_names, def.escaped_args
else
arg_names, escaped_args = (function()
local _accum_0 = { }
local _len_0 = 1
local _list_0 = tree.value
for _index_0 = 1, #_list_0 do
local w = _list_0[_index_0]
if w.type == "Word" then
_accum_0[_len_0] = w.value
_len_0 = _len_0 + 1
end
end
return _accum_0
end)(), { }
end
local arg_num = 1
local _list_0 = tree.value local _list_0 = tree.value
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
local _continue_0 = false local _continue_0 = false
@ -715,11 +913,18 @@ end)]]):format(concat(lua_bits, "\n"))
_continue_0 = true _continue_0 = true
break break
end end
if escaped_args[arg_names[arg_num]] then
arg = {
type = "Nomsu",
value = arg
}
end
local expr, statement = self:tree_to_lua(arg) local expr, statement = self:tree_to_lua(arg)
if statement then if statement then
self:error("Cannot use [[" .. tostring(arg.src) .. "]] as a function argument, since it's not an expression.") self:error("Cannot use [[" .. tostring(arg.src) .. "]] as a function argument, since it's not an expression.")
end end
insert(args, expr) insert(args, expr)
arg_num = arg_num + 1
_continue_0 = true _continue_0 = true
until true until true
if not _continue_0 then if not _continue_0 then
@ -883,41 +1088,38 @@ end)]]):format(concat(lua_bits, "\n"))
self:error("Nothing to get stub from") self:error("Nothing to get stub from")
end end
if type(x) == 'string' then if type(x) == 'string' then
local stub = x:gsub("([" .. tostring(wordbreaker) .. "]+)", " %1 "):gsub("%%%S+", "%%"):gsub("%s+", " "):gsub("^%s*", ""):gsub("%s*$", "") x = x:gsub("\n%s*%.%.", " "):gsub("([" .. tostring(wordbreaker) .. "]+)", " %1 "):gsub("%s+", " ")
x = x:gsub("^%s*", ""):gsub("%s*$", "")
local stub = x:gsub("%%%S+", "%%"):gsub("\\", "")
local arg_names local arg_names
do do
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
for arg in x:gmatch("%%([^%s']*)") do for arg in x:gmatch("%%([^%s]*)") do
_accum_0[_len_0] = arg _accum_0[_len_0] = arg
_len_0 = _len_0 + 1 _len_0 = _len_0 + 1
end end
arg_names = _accum_0 arg_names = _accum_0
end end
return stub, arg_names local escaped_args = utils.set((function()
local _accum_0 = { }
local _len_0 = 1
for arg in x:gmatch("\\%%([^%s]*)") do
_accum_0[_len_0] = arg
_len_0 = _len_0 + 1
end
return _accum_0
end)())
return stub, arg_names, escaped_args
end
if type(x) ~= 'table' then
self:error("Invalid type for getting stub: " .. tostring(type(x)) .. " for:\n" .. tostring(repr(x)))
end end
local _exp_0 = x.type local _exp_0 = x.type
if "String" == _exp_0 then if "String" == _exp_0 then
return self:get_stub(x.value) return self:get_stub(x.value)
elseif "FunctionCall" == _exp_0 then elseif "FunctionCall" == _exp_0 then
local stub, arg_names = { }, { }, { } return self:get_stub(x.src)
local _list_0 = x.value
for _index_0 = 1, #_list_0 do
local token = _list_0[_index_0]
local _exp_1 = token.type
if "Word" == _exp_1 then
insert(stub, token.value)
elseif "Var" == _exp_1 then
insert(stub, "%")
if arg_names then
insert(arg_names, token.value)
end
else
insert(stub, "%")
arg_names = nil
end
end
return concat(stub, " "), arg_names
else else
return self:error("Unsupported get stub type: " .. tostring(x.type) .. " for " .. tostring(repr(x))) return self:error("Unsupported get stub type: " .. tostring(x.type) .. " for " .. tostring(repr(x)))
end end
@ -974,11 +1176,11 @@ end)]]):format(concat(lua_bits, "\n"))
end)) end))
end, end,
error = function(self, msg) error = function(self, msg)
self:errorln((colored.red("ERROR!"))) local error_msg = colored.red("ERROR!")
if msg then if msg then
self:errorln(colored.bright(colored.yellow(colored.onred(msg)))) error_msg = error_msg .. ("\n" .. (colored.bright(colored.yellow(colored.onred(msg)))))
end end
self:errorln("Callstack:") error_msg = error_msg .. "\nCallstack:"
local maxlen = utils.max((function() local maxlen = utils.max((function()
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
@ -994,12 +1196,12 @@ end)]]):format(concat(lua_bits, "\n"))
end)()) end)())
for i = #self.callstack, 1, -1 do for i = #self.callstack, 1, -1 do
if self.callstack[i] ~= "#macro" then if self.callstack[i] ~= "#macro" then
self:errorln(" " .. tostring(("%-" .. tostring(maxlen) .. "s"):format(self.callstack[i][2])) .. "| " .. tostring(self.callstack[i][1])) error_msg = error_msg .. "\n " .. tostring(("%-" .. tostring(maxlen) .. "s"):format(self.callstack[i][2])) .. "| " .. tostring(self.callstack[i][1])
end end
end end
self:errorln(" <top level>") error_msg = error_msg .. "\n <top level>"
self.callstack = { } self.callstack = { }
return error() return error(error_msg, 3)
end, end,
typecheck = function(self, vars, varname, desired_type) typecheck = function(self, vars, varname, desired_type)
local x = vars[varname] local x = vars[varname]
@ -1009,17 +1211,19 @@ end)]]):format(concat(lua_bits, "\n"))
if type(x) == 'table' and x.type == desired_type then if type(x) == 'table' and x.type == desired_type then
return x return x
end end
return self:error("Invalid type for %" .. tostring(varname) .. ". Expected " .. tostring(desired_type) .. ", but got " .. tostring(x.type) .. ".") return self:error("Invalid type for %" .. tostring(varname) .. ". Expected " .. tostring(desired_type) .. ", but got " .. tostring(repr(x)) .. ".")
end, end,
initialize_core = function(self) initialize_core = function(self)
local nomsu_string_as_lua local nomsu_string_as_lua
nomsu_string_as_lua = function(self, code) nomsu_string_as_lua = function(self, code, tree)
local concat_parts = { } local concat_parts = { }
local _list_0 = code.value local _list_0 = code.value
for _index_0 = 1, #_list_0 do for _index_0 = 1, #_list_0 do
local bit = _list_0[_index_0] local bit = _list_0[_index_0]
if type(bit) == "string" then if type(bit) == "string" then
insert(concat_parts, bit) insert(concat_parts, bit)
elseif type(bit) == "table" and bit.type == "FunctionCall" and bit.src == "__src__" then
insert(concat_parts, repr(tree.src))
else else
local expr, statement = self:tree_to_lua(bit) local expr, statement = self:tree_to_lua(bit)
if statement then if statement then
@ -1070,12 +1274,13 @@ end)]]):format(concat(lua_bits, "\n"))
self:def("run file %filename", run_file) self:def("run file %filename", run_file)
local _require local _require
_require = function(self, vars) _require = function(self, vars)
if not self.loaded_files[vars.filename] then local loaded = self.defs["#loaded_files"]
self.loaded_files[vars.filename] = run_file(self, { if not loaded[vars.filename] then
loaded[vars.filename] = run_file(self, {
filename = vars.filename filename = vars.filename
}) or true }) or true
end end
return self.loaded_files[vars.filename] return loaded[vars.filename]
end end
return self:def("require %filename", _require) return self:def("require %filename", _require)
end end
@ -1089,10 +1294,21 @@ end)]]):format(concat(lua_bits, "\n"))
self.write_err = function(self, ...) self.write_err = function(self, ...)
return io.stderr:write(...) return io.stderr:write(...)
end end
self.defs = setmetatable({ }, { self.defs = {
__index = parent and parent.defs ["#vars"] = { },
}) ["#loaded_files"] = { }
self.def_number = 0 }
if parent then
setmetatable(self.defs, {
__index = parent.defs
})
setmetatable(self.defs["#vars"], {
__index = parent["#vars"]
})
setmetatable(self.defs["#loaded_files"], {
__index = parent["#loaded_files"]
})
end
self.callstack = { } self.callstack = { }
self.debug = false self.debug = false
self.utils = utils self.utils = utils
@ -1102,9 +1318,6 @@ end)]]):format(concat(lua_bits, "\n"))
self.stringify = function(self, ...) self.stringify = function(self, ...)
return utils.stringify(...) return utils.stringify(...)
end end
self.loaded_files = setmetatable({ }, {
__index = parent and parent.loaded_files
})
if not parent then if not parent then
return self:initialize_core() return self:initialize_core()
end end
@ -1121,6 +1334,7 @@ end)]]):format(concat(lua_bits, "\n"))
}) })
_base_0.__class = _class_0 _base_0.__class = _class_0
local self = _class_0 local self = _class_0
self.def_number = 0
self.unescape_string = function(self, str) self.unescape_string = function(self, str)
return str:gsub("\\(.)", (function(c) return str:gsub("\\(.)", (function(c)
return STRING_ESCAPES[c] or c return STRING_ESCAPES[c] or c

222
nomsu.moon
View File

@ -19,6 +19,12 @@ colors = setmetatable({}, {__index:->""})
colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..msg..colors.reset)}) colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..msg..colors.reset)})
{:insert, :remove, :concat} = table {:insert, :remove, :concat} = table
--pcall = (fn,...)-> true, fn(...) --pcall = (fn,...)-> true, fn(...)
if _VERSION == "Lua 5.1"
xp = xpcall
xpcall = (f, errhandler, ...)->
args = {n:select("#", ...), ...}
return xp((...)-> f(unpack(args,1,args.n))), errhandler
--pcall = (fn, ...) -> xpcall(fn, debug.traceback, ...)
-- TODO: -- TODO:
-- Maybe get GOTOs working at file scope. -- Maybe get GOTOs working at file scope.
@ -28,7 +34,6 @@ colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..msg..col
-- better scoping? -- better scoping?
-- better error reporting -- better error reporting
-- fix propagation of filename for error reporting -- fix propagation of filename for error reporting
-- add line numbers of function calls
-- type checking? -- type checking?
-- Fix compiler bug that breaks when file ends with a block comment -- Fix compiler bug that breaks when file ends with a block comment
-- Add compiler options for optimization level (compile-fast vs. run-fast, etc.) -- Add compiler options for optimization level (compile-fast vs. run-fast, etc.)
@ -162,7 +167,8 @@ defs =
for _ in src\sub(1,pos)\gmatch("\n") do line_no += 1 for _ in src\sub(1,pos)\gmatch("\n") do line_no += 1
return pos, "#{CURRENT_FILE}:#{line_no}" return pos, "#{CURRENT_FILE}:#{line_no}"
FunctionCall: (src, line_no, value, errors)-> FunctionCall: (src, line_no, value, errors)->
{type: "FunctionCall", :src, :line_no, :value, :errors} stub = concat([(t.type == "Word" and t.value or "%") for t in *value], " ")
{type: "FunctionCall", :src, :line_no, :value, :errors, :stub}
error: (src,pos,errors,err_msg)-> error: (src,pos,errors,err_msg)->
line_no = 1 line_no = 1
for _ in src\sub(1,-#errors)\gmatch("\n") do line_no += 1 for _ in src\sub(1,-#errors)\gmatch("\n") do line_no += 1
@ -190,17 +196,21 @@ setmetatable(defs, {
nomsu = re.compile(nomsu, defs) nomsu = re.compile(nomsu, defs)
class NomsuCompiler class NomsuCompiler
@def_number: 0
new:(parent)=> new:(parent)=>
@write = (...)=> io.write(...) @write = (...)=> io.write(...)
@write_err = (...)=> io.stderr\write(...) @write_err = (...)=> io.stderr\write(...)
@defs = setmetatable({}, {__index:parent and parent.defs}) -- Use # to prevent someone from defining a function that has a namespace collision.
@def_number = 0 @defs = {["#vars"]:{}, ["#loaded_files"]:{}}
if parent
setmetatable(@defs, {__index:parent.defs})
setmetatable(@defs["#vars"], {__index:parent["#vars"]})
setmetatable(@defs["#loaded_files"], {__index:parent["#loaded_files"]})
@callstack = {} @callstack = {}
@debug = false @debug = false
@utils = utils @utils = utils
@repr = (...)=> repr(...) @repr = (...)=> repr(...)
@stringify = (...)=> utils.stringify(...) @stringify = (...)=> utils.stringify(...)
@loaded_files = setmetatable({}, {__index:parent and parent.loaded_files})
if not parent if not parent
@initialize_core! @initialize_core!
@ -219,9 +229,12 @@ class NomsuCompiler
signature = @get_stubs signature signature = @get_stubs signature
assert type(thunk) == 'function', "Bad thunk: #{repr thunk}" assert type(thunk) == 'function', "Bad thunk: #{repr thunk}"
canonical_args = nil canonical_args = nil
canonical_escaped_args = nil
aliases = {} aliases = {}
@def_number += 1 @@def_number += 1
for {stub, arg_names} in *signature def = {:thunk, :src, :is_macro, aliases:{}, def_number:@@def_number, defs:@defs}
where_defs_go = ((getmetatable(@defs) or {}).__newindex) or @defs
for {stub, arg_names, escaped_args} in *signature
assert stub, "NO STUB FOUND: #{repr signature}" assert stub, "NO STUB FOUND: #{repr signature}"
if @debug then @writeln "#{colored.bright "DEFINING RULE:"} #{colored.underscore colored.magenta repr(stub)} #{colored.bright "WITH ARGS"} #{colored.dim repr(arg_names)}" if @debug then @writeln "#{colored.bright "DEFINING RULE:"} #{colored.underscore colored.magenta repr(stub)} #{colored.bright "WITH ARGS"} #{colored.dim repr(arg_names)}"
for i=1,#arg_names-1 do for j=i+1,#arg_names for i=1,#arg_names-1 do for j=i+1,#arg_names
@ -229,22 +242,58 @@ class NomsuCompiler
if canonical_args if canonical_args
assert utils.equivalent(utils.set(arg_names), canonical_args), "Mismatched args" assert utils.equivalent(utils.set(arg_names), canonical_args), "Mismatched args"
else canonical_args = utils.set(arg_names) else canonical_args = utils.set(arg_names)
insert aliases, stub if canonical_escaped_args
@defs[stub] = {:thunk, :stub, :arg_names, :src, :is_macro, :aliases, def_number:@def_number} assert utils.equivalent(escaped_args, canonical_escaped_args), "Mismatched escaped args"
else
canonical_escaped_args = escaped_args
def.escaped_args = escaped_args
insert def.aliases, stub
stub_def = setmetatable({:stub, :arg_names, :escaped_args}, {__index:def})
rawset(where_defs_go, stub, stub_def)
defmacro: (signature, thunk, src)=> defmacro: (signature, thunk, src)=>
@def(signature, thunk, src, true) @def(signature, thunk, src, true)
serialize_defs: (after=0)=> scoped: (thunk)=>
defs = {} old_defs = @defs
for _, def in pairs(@defs) @defs = setmetatable({}, {__index:old_defs})
defs[def.def_number] = def.src or "" ok, ret1, ret2 = pcall thunk, @
keys = utils.keys(defs) @defs = old_defs
if not ok then @error(ret1)
return ret1, ret2
serialize_defs: (scope=nil, after=0)=>
scope or= @defs
defs_by_num = {}
for stub, def in pairs(scope)
if def and stub\sub(1,1) != "#"
defs_by_num[def.def_number] = def
keys = [k for k,v in pairs(defs_by_num)]
table.sort(keys) table.sort(keys)
buff = {} buff = {}
for i in *keys k_i = 1
if i > after and #defs[i] > 0 _using = nil
insert buff, defs[i] _using_do = {}
for k_i,i in ipairs(keys)
if i <= after then continue
def = defs_by_num[i]
if def.defs == scope
if def.src
insert buff, def.src
continue
if _using == def.defs
if def.src
insert _using_do, def.src
else
_using = def.defs
_using_do = {def.src}
if k_i == #keys or defs_by_num[keys[k_i+1]].defs != _using
insert buff, "using:\n #{@indent @serialize_defs(_using)}\n..do:\n #{@indent concat(_using_do, "\n")}"
for k,v in pairs(scope["#vars"] or {})
insert buff, "<@#{k}> = #{@value_to_nomsu v}"
return concat buff, "\n" return concat buff, "\n"
call: (stub,line_no,...)=> call: (stub,line_no,...)=>
@ -254,7 +303,7 @@ class NomsuCompiler
if def and def.is_macro and @callstack[#@callstack] != "#macro" if def and def.is_macro and @callstack[#@callstack] != "#macro"
@error "Attempt to call macro at runtime: #{stub}\nThis can be caused by using a macro in a function that is defined before the macro." @error "Attempt to call macro at runtime: #{stub}\nThis can be caused by using a macro in a function that is defined before the macro."
insert @callstack, {stub, line_no} insert @callstack, {stub, line_no}
if def == nil unless def
@error "Attempt to call undefined function: #{stub}" @error "Attempt to call undefined function: #{stub}"
unless def.is_macro unless def.is_macro
@assert_permission(stub) @assert_permission(stub)
@ -263,22 +312,41 @@ class NomsuCompiler
if @debug if @debug
@write "#{colored.bright "CALLING"} #{colored.magenta(colored.underscore stub)} " @write "#{colored.bright "CALLING"} #{colored.magenta(colored.underscore stub)} "
@writeln "#{colored.bright "WITH ARGS:"} #{colored.dim repr(args)}" @writeln "#{colored.bright "WITH ARGS:"} #{colored.dim repr(args)}"
-- TODO: optimize, but still allow multiple return values? old_defs, @defs = @defs, def.defs
rets = {thunk(self,args)} rets = {thunk(self,args)}
@defs = old_defs
remove @callstack remove @callstack
return unpack(rets) return unpack(rets)
run_macro: (tree)=> run_macro: (tree)=>
stub = @get_stub tree
args = [arg for arg in *tree.value when arg.type != "Word"] args = [arg for arg in *tree.value when arg.type != "Word"]
if @debug if @debug
@write "#{colored.bright "RUNNING MACRO"} #{colored.underscore colored.magenta(stub)} " @write "#{colored.bright "RUNNING MACRO"} #{colored.underscore colored.magenta(tree.stub)} "
@writeln "#{colored.bright "WITH ARGS:"} #{colored.dim repr args}" @writeln "#{colored.bright "WITH ARGS:"} #{colored.dim repr args}"
insert @callstack, "#macro" insert @callstack, "#macro"
expr, statement = @call(stub, tree.line_no, unpack(args)) expr, statement = @call(tree.stub, tree.line_no, unpack(args))
remove @callstack remove @callstack
return expr, statement return expr, statement
dedent: (code)=>
unless code\find("\n")
return code
spaces, indent_spaces = math.huge, math.huge
for line in code\gmatch("\n([^\n]*)")
if line\match("^%s*#.*")
continue
elseif s = line\match("^(%s*)%.%..*")
spaces = math.min(spaces, #s)
elseif s = line\match("^(%s*)%S.*")
indent_spaces = math.min(indent_spaces, #s)
if spaces != math.huge and spaces < indent_spaces
return (code\gsub("\n"..(" ")\rep(spaces), "\n"))
else
return (code\gsub("\n"..(" ")\rep(indent_spaces), "\n "))
indent: (code)=>
(code\gsub("\n","\n "))
assert_permission: (stub)=> assert_permission: (stub)=>
fn_def = @defs[stub] fn_def = @defs[stub]
unless fn_def unless fn_def
@ -343,7 +411,7 @@ class NomsuCompiler
ok,expr,statements = pcall(@tree_to_lua, self, statement) ok,expr,statements = pcall(@tree_to_lua, self, statement)
if not ok if not ok
@errorln "#{colored.red "Error occurred in statement:"}\n#{colored.bright colored.yellow statement.src}" @errorln "#{colored.red "Error occurred in statement:"}\n#{colored.bright colored.yellow statement.src}"
@error(expr) error(expr)
code_for_statement = ([[ code_for_statement = ([[
return (function(nomsu, vars) return (function(nomsu, vars)
%s %s
@ -365,7 +433,7 @@ end);]])\format(statements or "", expr or "ret")
if not ok if not ok
@errorln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow statement.src}" @errorln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow statement.src}"
@errorln debug.traceback! @errorln debug.traceback!
@error(ret) error(ret)
if statements if statements
insert buffer, statements insert buffer, statements
if expr if expr
@ -392,8 +460,6 @@ end);]])\format(concat(buffer, "\n"))
tree_to_nomsu: (tree, force_inline=false)=> tree_to_nomsu: (tree, force_inline=false)=>
-- Return <nomsu code>, <is safe for inline use> -- Return <nomsu code>, <is safe for inline use>
indent = (s)->
s\gsub("\n","\n ")
assert tree, "No tree provided." assert tree, "No tree provided."
if not tree.type if not tree.type
@errorln debug.traceback() @errorln debug.traceback()
@ -410,27 +476,31 @@ end);]])\format(concat(buffer, "\n"))
if force_inline if force_inline
return "{#{concat([@tree_to_nomsu(v, true) for v in *tree.value], "; ")}", true return "{#{concat([@tree_to_nomsu(v, true) for v in *tree.value], "; ")}", true
else else
return ":"..indent("\n"..concat([@tree_to_nomsu v for v in *tree.value], "\n")), false return ":"..@indent("\n"..concat([@tree_to_nomsu v for v in *tree.value], "\n")), false
when "FunctionCall" when "FunctionCall"
buff = "" buff = ""
sep = "" sep = ""
inline = true inline = true
do_arg = (arg)-> line_len = 0
for arg in *tree.value for arg in *tree.value
nomsu, arg_inline = @tree_to_nomsu(arg, force_inline) nomsu, arg_inline = @tree_to_nomsu(arg, force_inline)
buff ..= sep if sep == " " and line_len + #nomsu > 80
sep = "\n.."
unless sep == " " and not arg_inline and nomsu\sub(1,1) == ":"
buff ..= sep
if arg_inline if arg_inline
sep = " " sep = " "
line_len += 1 + #nomsu
else else
line_len = 0
inline = false inline = false
sep = "\n.." sep = "\n.."
if arg.type == 'FunctionCall' if arg.type == 'FunctionCall'
if arg_inline if arg_inline
buff ..= "(#{nomsu})" buff ..= "(#{nomsu})"
else else
buff ..= "(..)\n #{indent nomsu}" buff ..= "(..)\n #{@indent nomsu}"
else else
buff ..= nomsu buff ..= nomsu
return buff, inline return buff, inline
@ -491,6 +561,22 @@ end);]])\format(concat(buffer, "\n"))
else else
@error("Unknown/unimplemented thingy: #{tree.type}") @error("Unknown/unimplemented thingy: #{tree.type}")
value_to_nomsu: (value)=>
switch type(value)
when "nil"
return "(nil)"
when "bool"
return value and "(yes)" or "(no)"
when "number"
return repr(value)
when "table"
if utils.is_list(value)
return "[#{concat [@value_to_nomsu(v) for v in *value], ", "}]"
else
return "(d{#{concat ["#{@value_to_nomsu(k)}=#{@value_to_nomsu(v)}" for k,v in pairs(value)], "; "}})"
else
error("Unsupported value_to_nomsu type: #{type(value)}")
tree_to_lua: (tree)=> tree_to_lua: (tree)=>
-- Return <lua code for value>, <additional lua code> -- Return <lua code for value>, <additional lua code>
assert tree, "No tree provided." assert tree, "No tree provided."
@ -502,7 +588,7 @@ end);]])\format(concat(buffer, "\n"))
error("Should not be converting File to lua through this function.") error("Should not be converting File to lua through this function.")
when "Nomsu" when "Nomsu"
return "nomsu:parse(#{repr tree.value.src}).value[1]", nil return "nomsu:parse(#{repr tree.value.src}, #{repr CURRENT_FILE}).value[1]", nil
when "Thunk" when "Thunk"
lua_bits = {} lua_bits = {}
@ -518,23 +604,31 @@ return ret;
end)]])\format(concat(lua_bits, "\n")) end)]])\format(concat(lua_bits, "\n"))
when "FunctionCall" when "FunctionCall"
stub = @get_stub(tree) def = @defs[tree.stub]
def = @defs[stub]
if def and def.is_macro if def and def.is_macro
expr, statement = @run_macro(tree) expr, statement = @run_macro(tree)
if def.whiteset if def.whiteset
if expr if expr
expr = "(nomsu:assert_permission(#{repr stub}) and #{expr})" expr = "(nomsu:assert_permission(#{repr tree.stub}) and #{expr})"
if statement if statement
statement = "nomsu:assert_permission(#{repr stub});\n"..statement statement = "nomsu:assert_permission(#{repr tree.stub});\n"..statement
return expr, statement return expr, statement
args = {repr(stub), repr(tree.line_no)} args = {repr(tree.stub), repr(tree.line_no)}
local arg_names, escaped_args
if def
arg_names, escaped_args = def.arg_names, def.escaped_args
else
arg_names, escaped_args = [w.value for w in *tree.value when w.type == "Word"], {}
arg_num = 1
for arg in *tree.value for arg in *tree.value
if arg.type == 'Word' then continue if arg.type == 'Word' then continue
if escaped_args[arg_names[arg_num]]
arg = {type:"Nomsu", value:arg}
expr,statement = @tree_to_lua arg expr,statement = @tree_to_lua arg
if statement if statement
@error "Cannot use [[#{arg.src}]] as a function argument, since it's not an expression." @error "Cannot use [[#{arg.src}]] as a function argument, since it's not an expression."
insert args, expr insert args, expr
arg_num += 1
return @@comma_separated_items("nomsu:call(", args, ")"), nil return @@comma_separated_items("nomsu:call(", args, ")"), nil
when "String" when "String"
@ -658,27 +752,22 @@ end)]])\format(concat(lua_bits, "\n"))
get_stub: (x)=> get_stub: (x)=>
if not x if not x
@error "Nothing to get stub from" @error "Nothing to get stub from"
-- Returns a single stub ("say %"), and list of arg names ({"msg"}) from a single rule def -- Returns a single stub ("say %"), list of arg names ({"msg"}), and set of arg
-- names that should not be evaluated from a single rule def
-- (e.g. "say %msg") or function call (e.g. FunctionCall({Word("say"), Var("msg"))) -- (e.g. "say %msg") or function call (e.g. FunctionCall({Word("say"), Var("msg")))
if type(x) == 'string' if type(x) == 'string'
stub = x\gsub("([#{wordbreaker}]+)"," %1 ")\gsub("%%%S+","%%")\gsub("%s+"," ")\gsub("^%s*","")\gsub("%s*$","") -- Standardize format to stuff separated by spaces
arg_names = [arg for arg in x\gmatch("%%([^%s']*)")] x = x\gsub("\n%s*%.%.", " ")\gsub("([#{wordbreaker}]+)", " %1 ")\gsub("%s+"," ")
return stub, arg_names x = x\gsub("^%s*","")\gsub("%s*$","")
stub = x\gsub("%%%S+","%%")\gsub("\\","")
arg_names = [arg for arg in x\gmatch("%%([^%s]*)")]
escaped_args = utils.set [arg for arg in x\gmatch("\\%%([^%s]*)")]
return stub, arg_names, escaped_args
if type(x) != 'table'
@error "Invalid type for getting stub: #{type(x)} for:\n#{repr x}"
switch x.type switch x.type
when "String" then return @get_stub(x.value) when "String" then return @get_stub(x.value)
when "FunctionCall" when "FunctionCall" then return @get_stub(x.src)
stub, arg_names = {}, {}, {}
for token in *x.value
switch token.type
when "Word"
insert stub, token.value
when "Var"
insert stub, "%"
if arg_names then insert arg_names, token.value
else
insert stub, "%"
arg_names = nil
return concat(stub," "), arg_names
else @error "Unsupported get stub type: #{x.type} for #{repr x}" else @error "Unsupported get stub type: #{x.type} for #{repr x}"
get_stubs: (x)=> get_stubs: (x)=>
@ -699,31 +788,33 @@ end)]])\format(concat(lua_bits, "\n"))
if verboten == "_" then "__" else ("_%x")\format(verboten\byte!)) if verboten == "_" then "__" else ("_%x")\format(verboten\byte!))
error: (msg)=> error: (msg)=>
@errorln (colored.red "ERROR!") error_msg = colored.red "ERROR!"
if msg if msg
@errorln(colored.bright colored.yellow colored.onred msg) error_msg ..= "\n" .. (colored.bright colored.yellow colored.onred msg)
@errorln("Callstack:") error_msg ..= "\nCallstack:"
maxlen = utils.max([#c[2] for c in *@callstack when c != "#macro"]) maxlen = utils.max([#c[2] for c in *@callstack when c != "#macro"])
for i=#@callstack,1,-1 for i=#@callstack,1,-1
if @callstack[i] != "#macro" if @callstack[i] != "#macro"
@errorln " #{"%-#{maxlen}s"\format @callstack[i][2]}| #{@callstack[i][1]}" error_msg ..= "\n #{"%-#{maxlen}s"\format @callstack[i][2]}| #{@callstack[i][1]}"
@errorln " <top level>" error_msg ..= "\n <top level>"
@callstack = {} @callstack = {}
error! error error_msg, 3
typecheck: (vars, varname, desired_type)=> typecheck: (vars, varname, desired_type)=>
x = vars[varname] x = vars[varname]
if type(x) == desired_type then return x if type(x) == desired_type then return x
if type(x) == 'table' and x.type == desired_type then return x if type(x) == 'table' and x.type == desired_type then return x
@error "Invalid type for %#{varname}. Expected #{desired_type}, but got #{x.type}." @error "Invalid type for %#{varname}. Expected #{desired_type}, but got #{repr x}."
initialize_core: => initialize_core: =>
-- Sets up some core functionality -- Sets up some core functionality
nomsu_string_as_lua = (code)=> nomsu_string_as_lua = (code, tree)=>
concat_parts = {} concat_parts = {}
for bit in *code.value for bit in *code.value
if type(bit) == "string" if type(bit) == "string"
insert concat_parts, bit insert concat_parts, bit
elseif type(bit) == "table" and bit.type == "FunctionCall" and bit.src == "__src__"
insert concat_parts, repr(tree.src)
else else
expr, statement = @tree_to_lua bit expr, statement = @tree_to_lua bit
if statement if statement
@ -763,9 +854,10 @@ end)]])\format(concat(lua_bits, "\n"))
@def "run file %filename", run_file @def "run file %filename", run_file
_require = (vars)=> _require = (vars)=>
if not @loaded_files[vars.filename] loaded = @defs["#loaded_files"]
@loaded_files[vars.filename] = run_file(self, {filename:vars.filename}) or true if not loaded[vars.filename]
return @loaded_files[vars.filename] loaded[vars.filename] = run_file(self, {filename:vars.filename}) or true
return loaded[vars.filename]
@def "require %filename", _require @def "require %filename", _require