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

Overhaul of error reporting and removing nomsu:call(stub, line_no, ...) in favor of nomsu.defs[stub].fn(...)

Browse Source
This commit is contained in:
Bruce Hill 2018-01-11 01:03:52 -08:00
parent 53a9d4eae8
commit c0333ca315
5 changed files with 315 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
lib/metaprogramming.nom
View File

@ -19,7 +19,7 @@ immediately:
immediately:
lua> ".."
nomsu:defmacro("compile %macro_def to %body", function(nomsu, \%macro_def, \%body)
nomsu:defmacro("compile %macro_def to %body", \(__line_no__), function(nomsu, \%macro_def, \%body)
nomsu:assert(\%macro_def.type == "List",
"Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type));
nomsu:assert(\%body.type == "Block",
@ -33,13 +33,14 @@ immediately:
%s
end
local function macro_wrapper(...) return {expr=macro(...)}; end
nomsu:defmacro(%s, macro_wrapper, %s);
end]]):format(args, body_lua, signature, nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
nomsu:defmacro(%s, %s, macro_wrapper, %s);
end]]):format(args, body_lua, signature, nomsu:repr(\%macro_def:get_line_no()),
nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
return {statements=lua};
end, \(__src__ 1));
lua> ".."
nomsu:defmacro("compile %macro_def to code %body", function(nomsu, \%macro_def, \%body)
nomsu:defmacro("compile %macro_def to code %body", \(__line_no__), function(nomsu, \%macro_def, \%body)
nomsu:assert(\%macro_def.type == "List",
"Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type));
nomsu:assert(\%body.type == "Block",
@ -53,8 +54,9 @@ immediately:
%s
end
local function macro_wrapper(...) return {statements=macro(...)}; end
nomsu:defmacro(%s, macro_wrapper, %s);
end]]):format(args, body_lua, signature, nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
nomsu:defmacro(%s, %s, macro_wrapper, %s);
end]]):format(args, body_lua, signature, nomsu:repr(\%macro_def:get_line_no()),
nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
return {statements=lua};
end, \(__src__ 1));
@ -71,7 +73,7 @@ immediately:
body_lua = body_lua.statements or ("return "..body_lua.expr..";");
local src = nomsu:dedent(nomsu:source_code(0));
local def_lua = ([[
nomsu:def(%s, function(%s)
nomsu:def(%s, \(__line_no__), function(%s)
%s
end, %s);]]):format(signature, args, body_lua, nomsu:repr(src));
return def_lua;
@ -79,7 +81,7 @@ immediately:
# Rule to make nomsu macros:
immediately:
lua> ".."
nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, \%shorthand, \%longhand)
nomsu:defmacro("parse %shorthand as %longhand", \(__line_no__), (function(nomsu, \%shorthand, \%longhand)
nomsu:assert(\%shorthand.type == "List",
"Invalid type for parse definition signature. Expected List, but got: "..tostring(\%shorthand.type));
nomsu:assert(\%longhand.type == "Block",
@ -95,11 +97,12 @@ immediately:
for i, a in ipairs(arg_names) do replacements[i] = "["..nomsu:repr(a).."]=_"..nomsu:var_to_lua_identifier(a); end
replacements = "{"..table.concat(replacements, ", ").."}";
local lua_code = ([[
nomsu:defmacro(%s, (function(%s)
nomsu:defmacro(%s, %s, (function(%s)
local template = nomsu:parse(%s, %s);
local replacement = nomsu:replaced_vars(template, %s);
return nomsu:tree_to_lua(replacement);
end), %s)]]):format(signature, args, template, nomsu:repr(\%shorthand:get_line_no()), replacements, nomsu:repr(nomsu:source_code(0)));
end), %s)]]):format(signature, nomsu:repr(\%shorthand:get_line_no()), args, template,
nomsu:repr(\%shorthand:get_line_no()), replacements, nomsu:repr(nomsu:source_code(0)));
return {statements=lua_code};
end), \(__src__ 1));

22
lib/operators.nom
View File

@ -19,14 +19,24 @@ compile [..]
%when_true_expr if %condition otherwise %when_false_expr
%when_false_expr unless %condition else %when_true_expr
%when_false_expr unless %condition then %when_true_expr
..to: ".."
(function(nomsu, condition)
if condition then
return \(%when_true_expr as lua);
..to:
lua> ".."
local condition = nomsu:tree_to_lua(\%condition).expr;
local when_true = nomsu:tree_to_lua(\%when_true_expr).expr;
local when_false = nomsu:tree_to_lua(\%when_false_expr).expr;
local safe = {String=true, List=true, Dict=true, Number=true};
if safe[\%when_true_expr.type] then
return "("..condition.." and "..when_true.." or "..when_false..")";
else
return \(%when_false_expr as lua);
return ([[
(function(nomsu)
if %s then
return %s;
else
return %s;
end
end)(nomsu)]]):format(condition, when_true, when_false);
end
end)(nomsu, \(%condition as lua))
parse [..]
%true if %x == %y else %false, %true if %x == %y otherwise %false
%false unless %x == %y else %true, %false unless %x == %y otherwise %true

2
lib/utils.nom
View File

@ -113,7 +113,7 @@ lua> ".."
};
for name,code in pairs(colors) do
local escape = "\\"\\\\27["..tostring(code).."m\\""
nomsu:defmacro(name, function() return escape end, "");
nomsu:defmacro(name, \(__line_no__), function() return escape end, "");
end
end

378
nomsu.lua
View File

@ -204,7 +204,7 @@ do
self:write_err(...)
return self:write_err("\n")
end,
def = function(self, signature, fn, src, is_macro)
def = function(self, signature, line_no, fn, src, is_macro)
if is_macro == nil then
is_macro = false
end
@ -221,6 +221,7 @@ do
local def = {
fn = fn,
src = src,
line_no = line_no,
is_macro = is_macro,
aliases = { },
def_number = self.__class.def_number,
@ -275,28 +276,8 @@ do
rawset(where_defs_go, stub, stub_def)
end
end,
defmacro = function(self, signature, fn, src)
return self:def(signature, fn, src, true)
end,
scoped = function(self, thunk)
local old_defs = self.defs
local new_defs = {
["#vars"] = setmetatable({ }, {
__index = self.defs["#vars"]
}),
["#loaded_files"] = setmetatable({ }, {
__index = self.defs["#loaded_files"]
})
}
self.defs = setmetatable(new_defs, {
__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
defmacro = function(self, signature, line_no, fn, src)
return self:def(signature, line_no, fn, src, true)
end,
serialize_defs = function(self, scope, after)
if scope == nil then
@ -367,50 +348,6 @@ do
end
return concat(buff, "\n")
end,
call = function(self, stub, line_no, ...)
local def = self.defs[stub]
if def and def.is_macro and self.callstack[#self.callstack] ~= "#macro" then
self:error("Attempt to call macro at runtime: " .. tostring(stub) .. "\nThis can be caused by using a macro in a function that is defined before the macro.")
end
insert(self.callstack, {
stub,
line_no
})
if not (def) then
self:error("Attempt to call undefined function: " .. tostring(stub))
end
if not (def.is_macro) then
self:assert_permission(stub)
end
local fn, arg_positions
fn, arg_positions = def.fn, def.arg_positions
local args
do
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #arg_positions do
local p = arg_positions[_index_0]
_accum_0[_len_0] = select(p, ...)
_len_0 = _len_0 + 1
end
args = _accum_0
end
if self.debug then
self:write(tostring(colored.bright("CALLING")) .. " " .. tostring(colored.magenta(colored.underscore(stub))) .. " ")
self:writeln(tostring(colored.bright("WITH ARGS:")))
for i, value in ipairs(args) do
self:writeln(" " .. tostring(colored.bright("* " .. tostring(def.args[i]))) .. " = " .. tostring(colored.dim(repr(value))))
end
end
local old_defs
old_defs, self.defs = self.defs, def.defs
local rets = {
fn(self, unpack(args))
}
self.defs = old_defs
remove(self.callstack)
return unpack(rets)
end,
run_macro = function(self, tree)
local args
do
@ -430,10 +367,7 @@ do
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))))
end
insert(self.callstack, "#macro")
local ret = self:call(tree.stub, tree:get_line_no(), unpack(args))
remove(self.callstack)
return ret
return self.defs[tree.stub].fn(self, unpack(args))
end,
dedent = function(self, code)
if not (code:find("\n")) then
@ -614,11 +548,7 @@ end]]):format(lua_code))
self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(err))
end
local run_lua_fn = load_lua_fn()
local ok, ret = pcall(run_lua_fn, self)
if not ok then
self:errorln(debug.traceback())
self:error(ret)
end
run_lua_fn(self)
return ret
end,
tree_to_value = function(self, tree, filename)
@ -639,7 +569,6 @@ end]]):format(lua_code))
end
self:assert(tree, "No tree provided.")
if not tree.type then
self:errorln(debug.traceback())
self:error("Invalid tree: " .. tostring(repr(tree)))
end
local _exp_0 = tree.type
@ -829,7 +758,6 @@ end]]):format(lua_code))
tree_to_lua = function(self, tree, filename)
self:assert(tree, "No tree provided.")
if not tree.type then
self:errorln(debug.traceback())
self:error("Invalid tree: " .. tostring(repr(tree)))
end
local _exp_0 = tree.type
@ -905,57 +833,45 @@ end]]):format(lua_code))
expr = "(" .. tostring(concat(bits, " ")) .. ")"
}
end
local args = {
repr(tree.stub),
repr(tree:get_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 arg_positions = def and def.arg_positions or { }
local args = { }
local _list_0 = tree.value
for _index_0 = 1, #_list_0 do
local _continue_0 = false
repeat
local arg = _list_0[_index_0]
if arg.type == 'Word' then
local tok = _list_0[_index_0]
if tok.type == "Word" then
_continue_0 = true
break
end
if escaped_args[arg_names[arg_num]] then
insert(args, "nomsu:parse(" .. tostring(repr(arg.src)) .. ", " .. tostring(repr(tree:get_line_no())) .. ").value[1]")
else
local lua = self:tree_to_lua(arg, filename)
if lua.statements then
self:error("Cannot use [[" .. tostring(arg.src) .. "]] as a function argument to " .. tostring(tree.stub) .. ", since it's not an expression.")
end
insert(args, lua.expr)
end
arg_num = arg_num + 1
local lua = self:tree_to_lua(tok, filename)
self:assert(lua.expr, "Cannot use " .. tostring(tok.src) .. " as an argument, since it's not an expression.")
insert(args, lua.expr)
_continue_0 = true
until true
if not _continue_0 then
break
end
end
if def then
local new_args
do
local _accum_0 = { }
local _len_0 = 1
local _list_1 = def.arg_positions
for _index_0 = 1, #_list_1 do
local p = _list_1[_index_0]
_accum_0[_len_0] = args[p]
_len_0 = _len_0 + 1
end
new_args = _accum_0
end
args = new_args
end
insert(args, 1, "nomsu")
remove(self.compilestack)
return {
expr = self.__class:comma_separated_items("nomsu:call(", args, ")")
expr = self.__class:comma_separated_items("nomsu.defs[" .. tostring(repr(tree.stub)) .. "].fn(", args, ")")
}
elseif "String" == _exp_0 then
local concat_parts = { }
@ -1266,52 +1182,12 @@ end]]):format(lua_code))
msg = ''
end
if not condition then
return self:error("Assertion failed: " .. msg)
self:error("Assertion failed: " .. msg)
end
return condition
end,
error = function(self, msg)
local error_msg = colored.red("ERROR!")
if msg and #msg > 0 then
error_msg = error_msg .. ("\n" .. (colored.bright(colored.yellow(colored.onred(msg)))))
else
error_msg = error_msg .. "\n<no message>"
end
error_msg = error_msg .. "\nCallstack:"
local maxlen = max((function()
local _accum_0 = { }
local _len_0 = 1
local _list_0 = self.callstack
for _index_0 = 1, #_list_0 do
local c = _list_0[_index_0]
if c ~= "#macro" then
_accum_0[_len_0] = #c[2]
_len_0 = _len_0 + 1
end
end
return _accum_0
end)())
for i = #self.callstack, 1, -1 do
if self.callstack[i] ~= "#macro" then
local line_no = self.callstack[i][2]
if line_no then
local nums
do
local _accum_0 = { }
local _len_0 = 1
for n in line_no:gmatch(":([0-9]+)") do
_accum_0[_len_0] = tonumber(n)
_len_0 = _len_0 + 1
end
nums = _accum_0
end
line_no = line_no:gsub(":.*$", ":" .. tostring(sum(nums) - #nums + 1))
end
error_msg = error_msg .. "\n " .. tostring(("%-" .. tostring(maxlen) .. "s"):format(line_no)) .. "| " .. tostring(self.callstack[i][1])
end
end
error_msg = error_msg .. "\n <top level>"
self.callstack = { }
return error(error_msg, 3)
return error(msg, 0)
end,
source_code = function(self, level)
if level == nil then
@ -1338,7 +1214,7 @@ end]]):format(lua_code))
end
return concat(concat_parts)
end
self:defmacro("do %block", function(self, _block)
self:defmacro("do %block", "nomsu.moon", function(self, _block)
local make_line
make_line = function(lua)
return lua.expr and (lua.expr .. ";") or lua.statements
@ -1351,7 +1227,7 @@ end]]):format(lua_code))
}
end
end)
self:defmacro("immediately %block", function(self, _block)
self:defmacro("immediately %block", "nomsu.moon", function(self, _block)
local lua = self:tree_to_lua(_block)
local lua_code = lua.statements or (lua.expr .. ";")
lua_code = "-- Immediately:\n" .. lua_code
@ -1360,27 +1236,32 @@ end]]):format(lua_code))
statements = lua_code
}
end)
self:defmacro("lua> %code", function(self, _code)
self:defmacro("lua> %code", "nomsu.moon", function(self, _code)
local lua = nomsu_string_as_lua(self, _code)
return {
statements = lua
}
end)
self:defmacro("=lua %code", function(self, _code)
self:defmacro("=lua %code", "nomsu.moon", function(self, _code)
local lua = nomsu_string_as_lua(self, _code)
return {
expr = lua
}
end)
self:defmacro("__src__ %level", function(self, _level)
self:defmacro("__line_no__", "nomsu.moon", function(self)
return {
expr = repr(self.compilestack[#self.compilestack]:get_line_no())
}
end)
self:defmacro("__src__ %level", "nomsu.moon", function(self, _level)
return {
expr = repr(self:source_code(self:tree_to_value(_level)))
}
end)
self:def("run file %filename", function(self, _filename)
self:def("run file %filename", "nomsu.moon", function(self, _filename)
return self:run_file(_filename)
end)
return self:defmacro("require %filename", function(self, _filename)
return self:defmacro("require %filename", "nomsu.moon", function(self, _filename)
local filename = self:tree_to_value(_filename)
self:require_file(filename)
return {
@ -1485,63 +1366,138 @@ if arg then
print("Usage: lua nomsu.lua [-c] [-i] [-p] [-O] [--help] [input [-o output]]")
os.exit()
end
local c = NomsuCompiler()
if args.flags["-v"] then
c.debug = true
end
c.skip_precompiled = not args.flags["-O"]
if args.input then
if args.flags["-c"] and not args.output then
args.output = args.input:gsub("%.nom", ".lua")
local nomsu = NomsuCompiler()
local run
run = function()
if args.flags["-v"] then
nomsu.debug = true
end
local compiled_output = nil
if args.flags["-p"] then
local _write = c.write
c.write = function() end
compiled_output = io.output()
elseif args.output then
compiled_output = io.open(args.output, 'w')
end
if args.input:match(".*%.lua") then
local retval = dofile(args.input)(c, { })
else
local input
if args.input == '-' then
input = io.read('*a')
nomsu.skip_precompiled = not args.flags["-O"]
if args.input then
if args.flags["-c"] and not args.output then
args.output = args.input:gsub("%.nom", ".lua")
end
local compiled_output = nil
if args.flags["-p"] then
local _write = nomsu.write
nomsu.write = function() end
compiled_output = io.output()
elseif args.output then
compiled_output = io.open(args.output, 'w')
end
if args.input:match(".*%.lua") then
local retval = dofile(args.input)(nomsu, { })
else
input = io.open(args.input):read("*a")
local input
if args.input == '-' then
input = io.read('*a')
else
input = io.open(args.input):read("*a")
end
local retval, code = nomsu:run(input, args.input)
if args.output then
compiled_output:write(code)
end
end
local retval, code = c:run(input, args.input)
if args.output then
compiled_output:write(code)
if args.flags["-p"] then
nomsu.write = _write
end
end
if args.flags["-p"] then
c.write = _write
end
end
if args.flags["-i"] then
c:run('require "lib/core.nom"', "stdin")
while true do
local buff = ""
if args.flags["-i"] then
nomsu:run('require "lib/core.nom"', "stdin")
while true do
io.write(">> ")
local line = io.read("*L")
if line == "\n" or not line then
local buff = ""
while true do
io.write(">> ")
local line = io.read("*L")
if line == "\n" or not line then
break
end
buff = buff .. line
end
if #buff == 0 then
break
end
buff = buff .. line
end
if #buff == 0 then
break
end
local ok, ret = pcall(function()
return c:run(buff, "stdin")
end)
if ok and ret ~= nil then
print("= " .. repr(ret))
local ok, ret = pcall(function()
return nomsu:run(buff, "stdin")
end)
if ok and ret ~= nil then
print("= " .. repr(ret))
end
end
end
end
local err_hand
err_hand = function(error_message)
print(tostring(colored.red("ERROR:")) .. " " .. tostring(colored.bright(colored.yellow(colored.onred((error_message or ""))))))
print("stack traceback:")
local to_lua
to_lua = require("moonscript.base").to_lua
local nomsu_file = io.open("nomsu.moon")
local nomsu_source = nomsu_file:read("*a")
local _, line_table = to_lua(nomsu_source)
nomsu_file:close()
local function_defs
do
local _tbl_0 = { }
for _, def in pairs(nomsu.defs) do
if def.fn then
_tbl_0[def.fn] = def
end
end
function_defs = _tbl_0
end
local level = 2
while true do
local _continue_0 = false
repeat
local calling_fn = debug.getinfo(level)
if not calling_fn then
break
end
if calling_fn.func == run then
break
end
level = level + 1
local name = calling_fn.name
if name == "run_lua_fn" then
_continue_0 = true
break
end
local line = nil
do
local def = function_defs[calling_fn.func]
if def then
line = colored.yellow(def.line_no)
name = colored.bright(colored.yellow(def.aliases[1]))
else
if calling_fn.istailcall and not name then
name = "<tail call>"
end
if calling_fn.short_src == "./nomsu.moon" then
local char = line_table[calling_fn.linedefined - 2]
local line_num = 3
for _ in nomsu_source:sub(1, char):gmatch("\n") do
line_num = line_num + 1
end
line = colored.cyan(tostring(calling_fn.short_src) .. ":" .. tostring(line_num))
name = colored.bright(colored.cyan(name or "???"))
else
line = colored.blue(tostring(calling_fn.short_src) .. ":" .. tostring(calling_fn.linedefined))
name = colored.bright(colored.blue(name or "???"))
end
end
end
local _from = colored.dim(colored.white("|"))
print(("%32s %s %s"):format(name, _from, line))
_continue_0 = true
until true
if not _continue_0 then
break
end
end
return os.exit(false, true)
end
xpcall(run, err_hand)
end
return NomsuCompiler

251
nomsu.moon
View File

@ -171,7 +171,7 @@ class NomsuCompiler
@write_err(...)
@write_err("\n")
def: (signature, fn, src, is_macro=false)=>
def: (signature, line_no, fn, src, is_macro=false)=>
if type(signature) == 'string'
signature = @get_stubs {signature}
elseif type(signature) == 'table' and type(signature[1]) == 'string'
@ -179,7 +179,7 @@ class NomsuCompiler
@assert type(fn) == 'function', "Bad fn: #{repr fn}"
aliases = {}
@@def_number += 1
def = {:fn, :src, :is_macro, aliases:{}, def_number:@@def_number, defs:@defs}
def = {:fn, :src, :line_no, :is_macro, aliases:{}, def_number:@@def_number, defs:@defs}
where_defs_go = (getmetatable(@defs) or {}).__newindex or @defs
for sig_i=1,#signature
stub, arg_names, escaped_args = unpack(signature[sig_i])
@ -204,19 +204,8 @@ class NomsuCompiler
stub_def = setmetatable({:stub, :arg_names, :arg_positions}, {__index:def})
rawset(where_defs_go, stub, stub_def)
defmacro: (signature, fn, src)=>
@def(signature, fn, src, true)
scoped: (thunk)=>
old_defs = @defs
new_defs =
["#vars"]: setmetatable({}, {__index:@defs["#vars"]})
["#loaded_files"]: setmetatable({}, {__index:@defs["#loaded_files"]})
@defs = setmetatable(new_defs, {__index:old_defs})
ok, ret1, ret2 = pcall thunk, @
@defs = old_defs
if not ok then @error(ret1)
return ret1, ret2
defmacro: (signature, line_no, fn, src)=>
@def(signature, line_no, fn, src, true)
serialize_defs: (scope=nil, after=nil)=>
after or= @core_defs or 0
@ -253,39 +242,12 @@ class NomsuCompiler
return concat buff, "\n"
call: (stub,line_no,...)=>
def = @defs[stub]
-- This is a little bit hacky, but having this check is handy for catching mistakes
-- I use a hash sign in "#macro" so it's guaranteed to not be a valid function name
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."
insert @callstack, {stub, line_no}
unless def
@error "Attempt to call undefined function: #{stub}"
unless def.is_macro
@assert_permission(stub)
{:fn, :arg_positions} = def
args = [select(p, ...) for p in *arg_positions]
if @debug
@write "#{colored.bright "CALLING"} #{colored.magenta(colored.underscore stub)} "
@writeln "#{colored.bright "WITH ARGS:"}"
for i, value in ipairs(args)
@writeln " #{colored.bright "* #{def.args[i]}"} = #{colored.dim repr(value)}"
old_defs, @defs = @defs, def.defs
rets = {fn(self,unpack(args))}
@defs = old_defs
remove @callstack
return unpack(rets)
run_macro: (tree)=>
args = [arg for arg in *tree.value when arg.type != "Word"]
if @debug
@write "#{colored.bright "RUNNING MACRO"} #{colored.underscore colored.magenta(tree.stub)} "
@writeln "#{colored.bright "WITH ARGS:"} #{colored.dim repr args}"
insert @callstack, "#macro"
ret = @call(tree.stub, tree\get_line_no!, unpack(args))
remove @callstack
return ret
return @defs[tree.stub].fn(self, unpack(args))
dedent: (code)=>
unless code\find("\n")
@ -405,11 +367,7 @@ end]]\format(lua_code))
code = "1 |"..lua_code\gsub("\n", fn)
@error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{err}")
run_lua_fn = load_lua_fn!
ok,ret = pcall(run_lua_fn, self)
if not ok
--@errorln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow tree.src}"
@errorln debug.traceback!
@error(ret)
run_lua_fn(self)
return ret
tree_to_value: (tree, filename)=>
@ -426,7 +384,7 @@ end]]\format(lua_code))
-- Return <nomsu code>, <is safe for inline use>
@assert tree, "No tree provided."
if not tree.type
@errorln debug.traceback()
--@errorln debug.traceback()
@error "Invalid tree: #{repr(tree)}"
switch tree.type
when "File"
@ -558,7 +516,7 @@ end]]\format(lua_code))
-- Return <lua code for value>, <additional lua code>
@assert tree, "No tree provided."
if not tree.type
@errorln debug.traceback()
--@errorln debug.traceback()
@error "Invalid tree: #{repr(tree)}"
switch tree.type
when "File"
@ -609,26 +567,21 @@ end]]\format(lua_code))
remove @compilestack
return expr:"(#{concat bits, " "})"
args = {repr(tree.stub), repr(tree\get_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
if arg.type == 'Word' then continue
if escaped_args[arg_names[arg_num]]
insert args, "nomsu:parse(#{repr arg.src}, #{repr tree\get_line_no!}).value[1]"
else
lua = @tree_to_lua arg, filename
if lua.statements
@error "Cannot use [[#{arg.src}]] as a function argument to #{tree.stub}, since it's not an expression."
insert args, lua.expr
arg_num += 1
arg_positions = def and def.arg_positions or {}
args = {}
for tok in *tree.value
if tok.type == "Word" then continue
lua = @tree_to_lua(tok, filename)
@assert(lua.expr, "Cannot use #{tok.src} as an argument, since it's not an expression.")
insert args, lua.expr
if def
new_args = [args[p] for p in *def.arg_positions]
args = new_args
insert args, 1, "nomsu"
remove @compilestack
return expr:@@comma_separated_items("nomsu:call(", args, ")")
return expr:@@comma_separated_items("nomsu.defs[#{repr tree.stub}].fn(", args, ")")
when "String"
concat_parts = {}
@ -818,25 +771,10 @@ end]]\format(lua_code))
assert: (condition, msg='')=>
if not condition
@error("Assertion failed: "..msg)
return condition
error: (msg)=>
error_msg = colored.red "ERROR!"
if msg and #msg > 0
error_msg ..= "\n" .. (colored.bright colored.yellow colored.onred msg)
else
error_msg ..= "\n<no message>"
error_msg ..= "\nCallstack:"
maxlen = max([#c[2] for c in *@callstack when c != "#macro"])
for i=#@callstack,1,-1
if @callstack[i] != "#macro"
line_no = @callstack[i][2]
if line_no
nums = [tonumber(n) for n in line_no\gmatch(":([0-9]+)")]
line_no = line_no\gsub(":.*$", ":#{sum(nums) - #nums + 1}")
error_msg ..= "\n #{"%-#{maxlen}s"\format line_no}| #{@callstack[i][1]}"
error_msg ..= "\n <top level>"
@callstack = {}
error error_msg, 3
error msg, 0
source_code: (level=0)=>
@dedent @compilestack[#@compilestack-level].src
@ -855,35 +793,38 @@ end]]\format(lua_code))
insert concat_parts, lua.expr
return concat(concat_parts)
@defmacro "do %block", (_block)=>
@defmacro "do %block", "nomsu.moon", (_block)=>
make_line = (lua)-> lua.expr and (lua.expr..";") or lua.statements
if _block.type == "Block"
return @tree_to_lua(_block)
else
return expr:"#{@tree_to_lua _block}(nomsu)"
@defmacro "immediately %block", (_block)=>
@defmacro "immediately %block", "nomsu.moon", (_block)=>
lua = @tree_to_lua(_block)
lua_code = lua.statements or (lua.expr..";")
lua_code = "-- Immediately:\n"..lua_code
@run_lua(lua_code)
return statements:lua_code
@defmacro "lua> %code", (_code)=>
@defmacro "lua> %code", "nomsu.moon", (_code)=>
lua = nomsu_string_as_lua(@, _code)
return statements:lua
@defmacro "=lua %code", (_code)=>
@defmacro "=lua %code", "nomsu.moon", (_code)=>
lua = nomsu_string_as_lua(@, _code)
return expr:lua
@defmacro "__src__ %level", (_level)=>
@defmacro "__line_no__", "nomsu.moon", ()=>
expr: repr(@compilestack[#@compilestack]\get_line_no!)
@defmacro "__src__ %level", "nomsu.moon", (_level)=>
expr: repr(@source_code(@tree_to_value(_level)))
@def "run file %filename", (_filename)=>
@def "run file %filename", "nomsu.moon", (_filename)=>
@run_file(_filename)
@defmacro "require %filename", (_filename)=>
@defmacro "require %filename", "nomsu.moon", (_filename)=>
filename = @tree_to_value(_filename)
@require_file(filename)
return statements:"nomsu:require_file(#{repr filename});"
@ -904,52 +845,96 @@ if arg
print "Usage: lua nomsu.lua [-c] [-i] [-p] [-O] [--help] [input [-o output]]"
os.exit!
c = NomsuCompiler()
nomsu = NomsuCompiler()
run = ->
if args.flags["-v"]
nomsu.debug = true
if args.flags["-v"]
c.debug = true
nomsu.skip_precompiled = not args.flags["-O"]
if args.input
-- Read a file or stdin and output either the printouts or the compiled lua
if args.flags["-c"] and not args.output
args.output = args.input\gsub("%.nom", ".lua")
compiled_output = nil
if args.flags["-p"]
_write = nomsu.write
nomsu.write = ->
compiled_output = io.output()
elseif args.output
compiled_output = io.open(args.output, 'w')
c.skip_precompiled = not args.flags["-O"]
if args.input
-- Read a file or stdin and output either the printouts or the compiled lua
if args.flags["-c"] and not args.output
args.output = args.input\gsub("%.nom", ".lua")
compiled_output = nil
if args.flags["-p"]
_write = c.write
c.write = ->
compiled_output = io.output()
elseif args.output
compiled_output = io.open(args.output, 'w')
if args.input\match(".*%.lua")
retval = dofile(args.input)(nomsu, {})
else
input = if args.input == '-'
io.read('*a')
else io.open(args.input)\read("*a")
retval, code = nomsu\run(input, args.input)
if args.output
compiled_output\write(code)
if args.input\match(".*%.lua")
retval = dofile(args.input)(c, {})
else
input = if args.input == '-'
io.read('*a')
else io.open(args.input)\read("*a")
retval, code = c\run(input, args.input)
if args.output
compiled_output\write(code)
if args.flags["-p"]
nomsu.write = _write
if args.flags["-p"]
c.write = _write
if args.flags["-i"]
-- REPL
c\run('require "lib/core.nom"', "stdin")
while true
buff = ""
if args.flags["-i"]
-- REPL
nomsu\run('require "lib/core.nom"', "stdin")
while true
io.write(">> ")
line = io.read("*L")
if line == "\n" or not line
buff = ""
while true
io.write(">> ")
line = io.read("*L")
if line == "\n" or not line
break
buff ..= line
if #buff == 0
break
buff ..= line
if #buff == 0
break
ok, ret = pcall(-> c\run(buff, "stdin"))
if ok and ret != nil
print "= "..repr(ret)
ok, ret = pcall(-> nomsu\run(buff, "stdin"))
if ok and ret != nil
print "= "..repr(ret)
err_hand = (error_message)->
print("#{colored.red "ERROR:"} #{colored.bright colored.yellow colored.onred (error_message or "")}")
print("stack traceback:")
import to_lua from require "moonscript.base"
nomsu_file = io.open("nomsu.moon")
nomsu_source = nomsu_file\read("*a")
_, line_table = to_lua(nomsu_source)
nomsu_file\close!
function_defs = {def.fn, def for _,def in pairs(nomsu.defs) when def.fn}
level = 2
while true
calling_fn = debug.getinfo(level)
if not calling_fn then break
if calling_fn.func == run then break
level += 1
name = calling_fn.name
if name == "run_lua_fn" then continue
line = nil
if def = function_defs[calling_fn.func]
line = colored.yellow(def.line_no)
name = colored.bright(colored.yellow(def.aliases[1]))
else
if calling_fn.istailcall and not name
name = "<tail call>"
if calling_fn.short_src == "./nomsu.moon"
-- Ugh, magic numbers, but this works
char = line_table[calling_fn.linedefined-2]
line_num = 3
for _ in nomsu_source\sub(1,char)\gmatch("\n") do line_num += 1
line = colored.cyan("#{calling_fn.short_src}:#{line_num}")
name = colored.bright(colored.cyan(name or "???"))
else
line = colored.blue("#{calling_fn.short_src}:#{calling_fn.linedefined}")
name = colored.bright(colored.blue(name or "???"))
_from = colored.dim colored.white "|"
print(("%32s %s %s")\format(name, _from, line))
os.exit(false, true)
xpcall(run, err_hand)
return NomsuCompiler