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

Modernized the codebase a bit to include "immediately:" for immediately

Browse Source 
running code before further parsing takes place. That means that in the
default case, whole files can be run at once, which makes all but the
weirdest edge cases make a lot more sense and operate smoothly.
This commit is contained in:
Bruce Hill 2018-01-08 18:53:57 -08:00
parent 568a44ef19
commit f97ab858ed
6 changed files with 473 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/control_flow.nom
View File

@ -43,7 +43,7 @@ rule [tree %tree has function call %call] =:
return true; return true;
end end
end end
do return false; end return false;
# While loops # While loops
compile [do next repeat-loop] to code: "goto continue_repeat;" compile [do next repeat-loop] to code: "goto continue_repeat;"
@ -100,12 +100,14 @@ compile [..]
%stop_labels join= "\n::stop_for::;" %stop_labels join= "\n::stop_for::;"
if (tree %body has function call (tree \(stop %) with {""=%var})): if (tree %body has function call (tree \(stop %) with {""=%var})):
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
if (%stop_labels != ""): ".." return (..)
".."
do --for-loop label scope do --for-loop label scope
\%code\ \%code\
..\%stop_labels ..\%stop_labels
end --for-loop label scope end --for-loop label scope
..else: %code ..if %stop_labels != "" else %code
parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
parse [..] parse [..]
for all %start to %stop by %step %body for all %start to %stop by %step %body
@ -131,11 +133,12 @@ compile [for %var in %iterable %body] to code:
%stop_labels join= "\n::stop_for::;" %stop_labels join= "\n::stop_for::;"
if (tree %body has function call (tree \(stop %) with {""=%var})): if (tree %body has function call (tree \(stop %) with {""=%var})):
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
if (%stop_labels != ""): ".." return (..)
".."
do --for-loop label scope do --for-loop label scope
\%code\%stop_labels \%code\%stop_labels
end --for-loop label scope end --for-loop label scope
..else: %code ..if %stop_labels != "" else %code
parse [for all %iterable %body] as: for % in %iterable %body parse [for all %iterable %body] as: for % in %iterable %body
# Dict iteration (lua's "pairs()") # Dict iteration (lua's "pairs()")
@ -161,12 +164,13 @@ compile [for %key = %value in %iterable %body] to code:
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;" %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;"
if (tree %body has function call (tree \(stop %) with {""=%value})): if (tree %body has function call (tree \(stop %) with {""=%value})):
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;" %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;"
if (%stop_labels != ""): ".." return (..)
".."
do --for-loop label scope do --for-loop label scope
\%code\ \%code\
..\%stop_labels ..\%stop_labels
end --for-loop label scope end --for-loop label scope
..else: %code ..if %stop_labels != "" else %code
# Switch statement/multi-branch if # Switch statement/multi-branch if
compile [when %body] to code: compile [when %body] to code:

82
lib/metaprogramming.nom
View File

@ -3,57 +3,76 @@
that easier. that easier.
# Rule to make rules: # Rule to make rules:
immediately:
lua> ".." lua> ".."
nomsu:defmacro("rule %signature = %body", (function(nomsu, vars) nomsu:defmacro("rule %signature = %body", (function(nomsu, vars)
nomsu:assert(\%signature.type == "List", nomsu:assert(\%signature.type == "List",
"Invalid type for rule definition signature. Expected List, but got: "..tostring(\%signature.type)); "Invalid type for rule definition signature. Expected List, but got: "..tostring(\%signature.type));
nomsu:assert(\%body.type == "Thunk", nomsu:assert(\%body.type == "Block",
"Invalid type for rule definition body. Expected Thunk, but got: "..tostring(\%body.type)); "Invalid type for rule definition body. Expected Block, but got: "..tostring(\%body.type));
local signature = {}; local signature = {};
for i, alias in ipairs(\%signature.value) do for i, alias in ipairs(\%signature.value) do
signature[i] = alias.src; signature[i] = alias.src;
end end
local src = nomsu:source_code(0); local src = nomsu:source_code(0);
return nil, ([[ local body_lua = nomsu:tree_to_lua(\%body);
local fn_src = ([[
function(nomsu, vars)
%s
end]]):format(body_lua.statements or ("return "..body_lua.expr..";"));
return {statements=([[
nomsu:def(%s, %s, %s) nomsu:def(%s, %s, %s)
]]):format(nomsu:repr(signature), nomsu:tree_to_lua(\%body), nomsu:repr(nomsu:dedent(src))); ]]):format(nomsu:repr(signature), fn_src, nomsu:repr(nomsu:dedent(src)))};
end), \(__src__ 1)); end), \(__src__ 1));
# Rule to make lua macros: # Rules to make lua macros:
immediately:
rule [compile \%macro_def to \%body] =: rule [compile \%macro_def to \%body] =:
lua> ".." lua> ".."
nomsu:assert(\%macro_def.type == "List", nomsu:assert(\%macro_def.type == "List",
"Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type)); "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type));
nomsu:assert(\%body.type == "Thunk", nomsu:assert(\%body.type == "Block",
"Invalid type for compile definition body. Expected Thunk, but got: "..tostring(\%body.type)); "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
local signature = {}; local signature = {};
for i, alias in ipairs(\%macro_def.value) do for i, alias in ipairs(\%macro_def.value) do
signature[i] = alias.src; signature[i] = alias.src;
end end
local thunk = nomsu:tree_to_value(\%body); local body_lua = nomsu:tree_to_lua(\%body);
nomsu:defmacro(signature, thunk, ("compile %s\\n..to %s"):format(\%macro_def.src, \%body.src)); local fn_src = ([[
function(nomsu, vars)
%s
end]]):format(body_lua.statements or ("return "..body_lua.expr..";"));
local fn = nomsu:run_lua("return "..fn_src..";");
local fn_wrapper = function(...) return {expr=fn(...)}; end;
nomsu:defmacro(signature, fn_wrapper, ("compile %s\\n..to %s"):format(\%macro_def.src, \%body.src));
rule [compile \%macro_def to code \%body] =: rule [compile \%macro_def to code \%body] =:
lua> ".." lua> ".."
nomsu:assert(\%macro_def.type == "List", nomsu:assert(\%macro_def.type == "List",
"Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type)); "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type));
nomsu:assert(\%body.type == "Thunk", nomsu:assert(\%body.type == "Block",
"Invalid type for compile definition body. Expected Thunk, but got: "..tostring(\%body.type)); "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
local signature = {}; local signature = {};
for i, alias in ipairs(\%macro_def.value) do for i, alias in ipairs(\%macro_def.value) do
signature[i] = alias.src; signature[i] = alias.src;
end end
local thunk = nomsu:tree_to_value(\%body); local body_lua = nomsu:tree_to_lua(\%body);
local thunk_wrapper = function(...) return nil, thunk(...); end local fn_src = ([[
nomsu:defmacro(signature, thunk_wrapper, ("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)); function(nomsu, vars)
%s
end]]):format(body_lua.statements or ("return "..body_lua.expr..";"));
local fn = nomsu:run_lua("return "..fn_src..";");
local fn_wrapper = function(...) return {statements=fn(...)}; end;
nomsu:defmacro(signature, fn_wrapper, ("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src));
# Rule to make nomsu macros: # Rule to make nomsu macros:
immediately:
lua> ".." lua> ".."
nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, vars) nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, vars)
nomsu:assert(\%shorthand.type == "List", nomsu:assert(\%shorthand.type == "List",
"Invalid type for parse definition signature. Expected List, but got: "..tostring(\%shorthand.type)); "Invalid type for parse definition signature. Expected List, but got: "..tostring(\%shorthand.type));
nomsu:assert(\%longhand.type == "Thunk", nomsu:assert(\%longhand.type == "Block",
"Invalid type for parse definition body. Expected Thunk, but got: "..tostring(\%longhand.type)); "Invalid type for parse definition body. Expected Block, but got: "..tostring(\%longhand.type));
local signature = {}; local signature = {};
for i, alias in ipairs(\%shorthand.value) do for i, alias in ipairs(\%shorthand.value) do
signature[i] = alias.src; signature[i] = alias.src;
@ -63,13 +82,13 @@ lua> ".."
template[i] = nomsu:dedent(line.src); template[i] = nomsu:dedent(line.src);
end end
signature, template = nomsu:repr(signature), nomsu:repr(table.concat(template, "\\n")); signature, template = nomsu:repr(signature), nomsu:repr(table.concat(template, "\\n"));
return nil, ([[ return {expr=([[
nomsu:defmacro(%s, (function(nomsu, vars) nomsu:defmacro(%s, (function(nomsu, vars)
local template = nomsu:parse(%s, %s); local template = nomsu:parse(%s, %s);
if #template.value == 1 then template = template.value[1]; end if #template.value == 1 then template = template.value[1]; end
local replacement = nomsu:replaced_vars(template, vars); local replacement = nomsu:replaced_vars(template, vars);
return nomsu:tree_to_lua(replacement); return nomsu:tree_to_lua(replacement);
end), %s)]]):format(signature, template, nomsu:repr(\%shorthand.line_no), nomsu:repr(nomsu:source_code(0))); end), %s)]]):format(signature, template, nomsu:repr(\%shorthand.line_no), nomsu:repr(nomsu:source_code(0)))};
end), \(__src__ 1)); end), \(__src__ 1));
rule [remove rule %stub] =: rule [remove rule %stub] =:
@ -79,8 +98,13 @@ rule [remove rule %stub] =:
nomsu.defs[alias] = false; nomsu.defs[alias] = false;
end end
immediately:
rule [%tree as lua] =: rule [%tree as lua] =:
=lua "nomsu:tree_to_lua(\%tree)" =lua "nomsu:tree_to_lua(\%tree).expr"
rule [%tree as lua statements] =:
lua> ".."
local lua = nomsu:tree_to_lua(\%tree);
return lua.statements or (lua.expr..";");
rule [%tree as value] =: rule [%tree as value] =:
=lua "nomsu:tree_to_value(\%tree, vars)" =lua "nomsu:tree_to_value(\%tree, vars)"
compile [repr %obj] to: compile [repr %obj] to:
@ -97,22 +121,6 @@ parse [lua do> %block] as:
lua> %block lua> %block
lua> "end" lua> "end"
rule [%tree as lua statement] =:
lua do> ".."
local _,statement = nomsu:tree_to_lua(\%tree);
return statement;
rule [%tree as lua statements] =:
lua do> ".."
local lua_bits = {};
nomsu:assert(type(\%tree) == 'table' and \%tree.type == "Thunk",
"Invalid type. Expected Thunk.");
for _,bit in ipairs(\%tree.value) do
local expr, statement = nomsu:tree_to_lua(bit);
if statement then table.insert(lua_bits, statement); end
if expr then table.insert(lua_bits, "ret = "..expr..";"); end
end
return table.concat(lua_bits, "\\n");
compile [nomsu] to: "nomsu" compile [nomsu] to: "nomsu"
compile [nomsu's %key] to: "nomsu[\(%key as lua)]" compile [nomsu's %key] to: "nomsu[\(%key as lua)]"
compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))" compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))"
@ -124,7 +132,7 @@ parse [rule %signature] as:
# Get the source code for a function # Get the source code for a function
rule [help %rule] =: rule [help %rule] =:
lua do> ".." lua> ".."
local fn_def = nomsu.defs[nomsu:get_stub(\%rule)] local fn_def = nomsu.defs[nomsu:get_stub(\%rule)]
if not fn_def then if not fn_def then
nomsu:writeln("Rule not found: "..nomsu:repr(\%rule)); nomsu:writeln("Rule not found: "..nomsu:repr(\%rule));
@ -135,7 +143,7 @@ rule [help %rule] =:
# Compiler tools # Compiler tools
parse [eval %code, run %code] as: nomsu "run" [%code] parse [eval %code, run %code] as: nomsu "run" [%code]
rule [source code from tree %tree] =: rule [source code from tree %tree] =:
lua do> ".." lua> ".."
local _,_,leading_space = \%tree.src:find("\\n(%s*)%S"); local _,_,leading_space = \%tree.src:find("\\n(%s*)%S");
if leading_space then if leading_space then
local chunk1, chunk2 = \%tree.src:match(":%s*([^\\n]*)(\\n.*)"); local chunk1, chunk2 = \%tree.src:match(":%s*([^\\n]*)(\\n.*)");

4
lib/operators.nom
View File

@ -51,9 +51,9 @@ compile [%var = %val] to code:
lua> ".." lua> ".."
if \%var.type == 'List' and \%val.type == 'List' then if \%var.type == 'List' and \%val.type == 'List' then
local lhs = {}; local lhs = {};
for i,x in ipairs(\%var.value) do lhs[i] = nomsu:tree_to_lua(x); end for i,x in ipairs(\%var.value) do lhs[i] = nomsu:tree_to_lua(x).expr; end
local rhs = {}; local rhs = {};
for i,x in ipairs(\%val.value) do rhs[i] = nomsu:tree_to_lua(x); end for i,x in ipairs(\%val.value) do rhs[i] = nomsu:tree_to_lua(x).expr; end
return table.concat(lhs, ", ").." = "..table.concat(rhs, ", ")..";"; return table.concat(lhs, ", ").." = "..table.concat(rhs, ", ")..";";
else else
return \(%var as lua).." = "..\(%val as lua)..";"; return \(%var as lua).." = "..\(%val as lua)..";";

349
nomsu.lua
View File

@ -194,7 +194,7 @@ do
self:write_err(...) self:write_err(...)
return self:write_err("\n") return self:write_err("\n")
end, end,
def = function(self, signature, thunk, src, is_macro) def = function(self, signature, fn, src, is_macro)
if is_macro == nil then if is_macro == nil then
is_macro = false is_macro = false
end end
@ -205,13 +205,13 @@ do
elseif type(signature) == 'table' and type(signature[1]) == 'string' then elseif type(signature) == 'table' and type(signature[1]) == 'string' then
signature = self:get_stubs(signature) signature = self:get_stubs(signature)
end end
self:assert(type(thunk) == 'function', "Bad thunk: " .. tostring(repr(thunk))) self:assert(type(fn) == 'function', "Bad fn: " .. tostring(repr(fn)))
local canonical_args = nil local canonical_args = nil
local canonical_escaped_args = nil local canonical_escaped_args = nil
local aliases = { } local aliases = { }
self.__class.def_number = self.__class.def_number + 1 self.__class.def_number = self.__class.def_number + 1
local def = { local def = {
thunk = thunk, fn = fn,
src = src, src = src,
is_macro = is_macro, is_macro = is_macro,
aliases = { }, aliases = { },
@ -256,8 +256,8 @@ do
rawset(where_defs_go, stub, stub_def) rawset(where_defs_go, stub, stub_def)
end end
end, end,
defmacro = function(self, signature, thunk, src) defmacro = function(self, signature, fn, src)
return self:def(signature, thunk, src, true) return self:def(signature, fn, src, true)
end, end,
scoped = function(self, thunk) scoped = function(self, thunk)
local old_defs = self.defs local old_defs = self.defs
@ -363,8 +363,8 @@ do
if not (def.is_macro) then if not (def.is_macro) then
self:assert_permission(stub) self:assert_permission(stub)
end end
local thunk, arg_names local fn, arg_names
thunk, arg_names = def.thunk, def.arg_names fn, arg_names = def.fn, def.arg_names
local args local args
do do
local _tbl_0 = { } local _tbl_0 = { }
@ -375,12 +375,15 @@ do
end end
if self.debug then if self.debug then
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:")))
for name, value in pairs(args) do
self:writeln(" " .. tostring(colored.bright("* " .. tostring(name))) .. " = " .. tostring(colored.dim(repr(value))))
end
end end
local old_defs local old_defs
old_defs, self.defs = self.defs, def.defs old_defs, self.defs = self.defs, def.defs
local rets = { local rets = {
thunk(self, args) fn(self, args)
} }
self.defs = old_defs self.defs = old_defs
remove(self.callstack) remove(self.callstack)
@ -406,9 +409,9 @@ do
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(tree.stub, tree.line_no, unpack(args)) local ret = self:call(tree.stub, tree.line_no, unpack(args))
remove(self.callstack) remove(self.callstack)
return expr, statement return ret
end, end,
dedent = function(self, code) dedent = function(self, code)
if not (code:find("\n")) then if not (code:find("\n")) then
@ -448,8 +451,11 @@ do
return (code:gsub("\n" .. (" "):rep(indent_spaces), "\n ")) return (code:gsub("\n" .. (" "):rep(indent_spaces), "\n "))
end end
end, end,
indent = function(self, code) indent = function(self, code, levels)
return (code:gsub("\n", "\n ")) if levels == nil then
levels = 1
end
return code:gsub("\n", "\n" .. (" "):rep(levels))
end, end,
assert_permission = function(self, stub) assert_permission = function(self, stub)
local fn_def = self.defs[stub] local fn_def = self.defs[stub]
@ -525,72 +531,46 @@ do
debug.sethook(timeout, "", max_operations) debug.sethook(timeout, "", max_operations)
end end
local tree = self:parse(src, filename) local tree = self:parse(src, filename)
self:assert(tree, "Tree failed to compile: " .. tostring(src)) self:assert(tree, "Failed to parse: " .. tostring(src))
self:assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type)) self:assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type))
local buffer = { } local lua = self:tree_to_lua(tree)
local _list_0 = tree.value local lua_code = lua.statements or (lua.expr .. ";")
for _index_0 = 1, #_list_0 do local ret = self:run_lua(lua_code, vars)
local statement = _list_0[_index_0] if max_operations then
if self.debug then debug.sethook()
self:writeln(tostring(colored.bright("RUNNING NOMSU:")) .. "\n" .. tostring(colored.bright(colored.yellow(statement.src))))
self:writeln(colored.bright("PARSED TO TREE:"))
self:print_tree(statement)
end end
local ok, expr, statements = pcall(self.tree_to_lua, self, statement, filename)
if not ok then
self:errorln(tostring(colored.red("Error occurred in statement:")) .. "\n" .. tostring(colored.bright(colored.yellow(statement.src))))
error(expr)
end
local code_for_statement = ([[return (function(nomsu, vars)
%s
end);]]):format(statements or ("return " .. expr .. ";"))
if output_file then if output_file then
if statements and #statements > 0 then output_file:write(lua_code)
output_file:write("lua> \"..\"\n " .. tostring(self:indent(statements:gsub("\\", "\\\\"))) .. "\n")
end end
if expr and #expr > 0 then return ret, lua_code, vars
output_file:write("=lua \"..\"\n " .. tostring(self:indent(expr:gsub("\\", "\\\\"))) .. "\n") end,
run_lua = function(self, lua_code, vars)
if vars == nil then
vars = { }
end end
end local load_lua_fn, err = load(([[return function(nomsu, vars)
if self.debug then %s
self:writeln(tostring(colored.bright("RUNNING LUA:")) .. "\n" .. tostring(colored.blue(colored.bright(code_for_statement)))) end]]):format(lua_code))
end if not load_lua_fn then
local lua_thunk, err = load(code_for_statement)
if not lua_thunk then
local n = 1 local n = 1
local fn local fn
fn = function() fn = function()
n = n + 1 n = n + 1
return ("\n%-3d|"):format(n) return ("\n%-3d|"):format(n)
end end
local code = "1 |" .. code_for_statement:gsub("\n", fn) local code = "1 |" .. lua_code:gsub("\n", fn)
error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(err) .. "\n\nProduced by statement:\n" .. tostring(colored.bright(colored.yellow(statement.src)))) self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(err))
end end
local run_statement = lua_thunk() local run_lua_fn = load_lua_fn()
local ret local ok, ret = pcall(run_lua_fn, self, vars)
ok, ret = pcall(run_statement, self, vars)
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(debug.traceback()) self:errorln(debug.traceback())
error(ret) self:error(ret)
end end
if statements then return ret
insert(buffer, statements)
end
if expr then
insert(buffer, tostring(expr) .. ";")
end
end
if max_operations then
debug.sethook()
end
local lua_code = ([[return (function(nomsu, vars)
%s
end);]]):format(concat(buffer, "\n"))
return nil, lua_code, vars
end, end,
tree_to_value = function(self, tree, vars, filename) tree_to_value = function(self, tree, vars, filename)
local code = "return (function(nomsu, vars)\nreturn " .. tostring(self:tree_to_lua(tree, filename)) .. ";\nend);" local code = "return (function(nomsu, vars)\nreturn " .. tostring(self:tree_to_lua(tree, filename).expr) .. ";\nend);"
if self.debug then if self.debug then
self:writeln(tostring(colored.bright("RUNNING LUA TO GET VALUE:")) .. "\n" .. tostring(colored.blue(colored.bright(code)))) self:writeln(tostring(colored.bright("RUNNING LUA TO GET VALUE:")) .. "\n" .. tostring(colored.blue(colored.bright(code))))
end end
@ -625,9 +605,9 @@ end);]]):format(concat(buffer, "\n"))
elseif "Nomsu" == _exp_0 then elseif "Nomsu" == _exp_0 then
local inside, inline = self:tree_to_nomsu(tree.value, force_inline) local inside, inline = self:tree_to_nomsu(tree.value, force_inline)
return "\\" .. tostring(inside), inline return "\\" .. tostring(inside), inline
elseif "Thunk" == _exp_0 then elseif "Block" == _exp_0 then
if force_inline then if force_inline then
return "{" .. tostring(concat((function() return "(:" .. tostring(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
@ -637,7 +617,7 @@ end);]]):format(concat(buffer, "\n"))
_len_0 = _len_0 + 1 _len_0 = _len_0 + 1
end end
return _accum_0 return _accum_0
end)(), "; ")), true end)(), "; ")) .. ")", true
else else
return ":" .. self:indent("\n" .. concat((function() return ":" .. self:indent("\n" .. concat((function()
local _accum_0 = { } local _accum_0 = { }
@ -739,7 +719,7 @@ end);]]):format(concat(buffer, "\n"))
return longbuff, false return longbuff, false
end end
elseif "Dict" == _exp_0 then elseif "Dict" == _exp_0 then
return error("Sorry, not yet implemented.") return self:error("Sorry, not yet implemented.")
elseif "Number" == _exp_0 then elseif "Number" == _exp_0 then
return repr(tree.value), true return repr(tree.value), true
elseif "Var" == _exp_0 then elseif "Var" == _exp_0 then
@ -771,7 +751,7 @@ end);]]):format(concat(buffer, "\n"))
return _accum_0 return _accum_0
end)(), ", ")) .. "]" end)(), ", ")) .. "]"
else else
return "(d{" .. tostring(concat((function() return "{" .. tostring(concat((function()
local _accum_0 = { } local _accum_0 = { }
local _len_0 = 1 local _len_0 = 1
for k, v in pairs(value) do for k, v in pairs(value) do
@ -779,7 +759,7 @@ end);]]):format(concat(buffer, "\n"))
_len_0 = _len_0 + 1 _len_0 = _len_0 + 1
end end
return _accum_0 return _accum_0
end)(), "; ")) .. "})" end)(), ", ")) .. "}"
end end
elseif "string" == _exp_0 then elseif "string" == _exp_0 then
if value == "\n" then if value == "\n" then
@ -801,49 +781,59 @@ end);]]):format(concat(buffer, "\n"))
end end
local _exp_0 = tree.type local _exp_0 = tree.type
if "File" == _exp_0 then if "File" == _exp_0 then
if #tree.value == 1 then
return self:tree_to_lua(tree.value[1], filename)
end
local lua_bits = { } local lua_bits = { }
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 line = _list_0[_index_0] local line = _list_0[_index_0]
local expr, statement = self:tree_to_lua(line, filename) local lua = self:tree_to_lua(line, filename)
if statement then if not lua then
insert(lua_bits, statement) self:error("No lua produced by " .. tostring(repr(line)))
end end
if expr then if lua.statements then
insert(lua_bits, tostring(expr) .. ";") insert(lua_bits, lua.statements)
end
if lua.expr then
insert(lua_bits, tostring(lua.expr) .. ";")
end end
end end
return nil, concat(lua_bits, "\n") return {
statements = concat(lua_bits, "\n")
}
elseif "Nomsu" == _exp_0 then elseif "Nomsu" == _exp_0 then
return "nomsu:parse(" .. tostring(repr(tree.value.src)) .. ", " .. tostring(repr(tree.line_no)) .. ").value[1]", nil return {
elseif "Thunk" == _exp_0 then expr = "nomsu:parse(" .. tostring(repr(tree.value.src)) .. ", " .. tostring(repr(tree.line_no)) .. ").value[1]"
}
elseif "Block" == _exp_0 then
local lua_bits = { } local lua_bits = { }
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 expr, statement = self:tree_to_lua(arg, filename) local lua = self:tree_to_lua(arg, filename)
if #tree.value == 1 and expr and not statement then if #tree.value == 1 and lua.expr and not lua.statements then
return ([[(function(nomsu, vars) return {
return %s; expr = lua.expr
end)]]):format(expr) }
end end
if statement then if lua.statements then
insert(lua_bits, statement) insert(lua_bits, lua.statements)
end end
if expr then if lua.expr then
insert(lua_bits, tostring(expr) .. ";") insert(lua_bits, tostring(lua.expr) .. ";")
end end
end end
return ([[(function(nomsu, vars) return {
%s statements = concat(lua_bits, "\n")
end)]]):format(concat(lua_bits, "\n")) }
elseif "FunctionCall" == _exp_0 then elseif "FunctionCall" == _exp_0 then
insert(self.compilestack, tree) insert(self.compilestack, tree)
local def = self.defs[tree.stub] local def = self.defs[tree.stub]
if def and def.is_macro then if def and def.is_macro then
local expr, statement = self:run_macro(tree) local lua = self:run_macro(tree)
remove(self.compilestack) remove(self.compilestack)
return expr, statement return lua
elseif not def and self.__class.math_patt:match(tree.stub) then elseif not def and self.__class.math_patt:match(tree.stub) then
local bits = { } local bits = { }
local _list_0 = tree.value local _list_0 = tree.value
@ -852,12 +842,15 @@ end)]]):format(concat(lua_bits, "\n"))
if tok.type == "Word" then if tok.type == "Word" then
insert(bits, tok.value) insert(bits, tok.value)
else else
local expr, statement = self:tree_to_lua(tok, filename) local lua = self:tree_to_lua(tok, filename)
self:assert(statement == nil, "non-expression value inside math expression") self:assert(lua.statements == nil, "non-expression value inside math expression")
insert(bits, expr) insert(bits, lua.expr)
end end
end end
return "(" .. tostring(concat(bits, " ")) .. ")" remove(self.compilestack)
return {
expr = "(" .. tostring(concat(bits, " ")) .. ")"
}
end end
local args = { local args = {
repr(tree.stub), repr(tree.stub),
@ -894,11 +887,11 @@ end)]]):format(concat(lua_bits, "\n"))
if escaped_args[arg_names[arg_num]] then if escaped_args[arg_names[arg_num]] then
insert(args, "nomsu:parse(" .. tostring(repr(arg.src)) .. ", " .. tostring(repr(tree.line_no)) .. ").value[1]") insert(args, "nomsu:parse(" .. tostring(repr(arg.src)) .. ", " .. tostring(repr(tree.line_no)) .. ").value[1]")
else else
local expr, statement = self:tree_to_lua(arg, filename) local lua = self:tree_to_lua(arg, filename)
if statement then if lua.statements 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, lua.expr)
end end
arg_num = arg_num + 1 arg_num = arg_num + 1
_continue_0 = true _continue_0 = true
@ -908,7 +901,9 @@ end)]]):format(concat(lua_bits, "\n"))
end end
end end
remove(self.compilestack) remove(self.compilestack)
return self.__class:comma_separated_items("nomsu:call(", args, ")"), nil return {
expr = self.__class:comma_separated_items("nomsu:call(", args, ")")
}
elseif "String" == _exp_0 then elseif "String" == _exp_0 then
local concat_parts = { } local concat_parts = { }
local string_buffer = "" local string_buffer = ""
@ -926,16 +921,16 @@ end)]]):format(concat(lua_bits, "\n"))
insert(concat_parts, repr(string_buffer)) insert(concat_parts, repr(string_buffer))
string_buffer = "" string_buffer = ""
end end
local expr, statement = self:tree_to_lua(bit, filename) local lua = self:tree_to_lua(bit, filename)
if self.debug then if self.debug then
self:writeln((colored.bright("INTERP:"))) self:writeln((colored.bright("INTERP:")))
self:print_tree(bit) self:print_tree(bit)
self:writeln(tostring(colored.bright("EXPR:")) .. " " .. tostring(expr) .. ", " .. tostring(colored.bright("STATEMENT:")) .. " " .. tostring(statement)) self:writeln(tostring(colored.bright("EXPR:")) .. " " .. tostring(lua.expr) .. ", " .. tostring(colored.bright("STATEMENT:")) .. " " .. tostring(lua.statements))
end end
if statement then if lua.statements then
self:error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.") self:error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
end end
insert(concat_parts, "nomsu:stringify(" .. tostring(expr) .. ")") insert(concat_parts, "nomsu:stringify(" .. tostring(lua.expr) .. ")")
_continue_0 = true _continue_0 = true
until true until true
if not _continue_0 then if not _continue_0 then
@ -946,57 +941,75 @@ end)]]):format(concat(lua_bits, "\n"))
insert(concat_parts, repr(string_buffer)) insert(concat_parts, repr(string_buffer))
end end
if #concat_parts == 0 then if #concat_parts == 0 then
return "''", nil return {
expr = "''"
}
elseif #concat_parts == 1 then elseif #concat_parts == 1 then
return concat_parts[1], nil return {
expr = concat_parts[1]
}
else else
return "(" .. tostring(concat(concat_parts, "..")) .. ")", nil return {
expr = "(" .. tostring(concat(concat_parts, "..")) .. ")"
}
end end
elseif "List" == _exp_0 then elseif "List" == _exp_0 then
local items = { } local items = { }
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 item = _list_0[_index_0] local item = _list_0[_index_0]
local expr, statement = self:tree_to_lua(item, filename) local lua = self:tree_to_lua(item, filename)
if statement then if lua.statements then
self:error("Cannot use [[" .. tostring(item.src) .. "]] as a list item, since it's not an expression.") self:error("Cannot use [[" .. tostring(item.src) .. "]] as a list item, since it's not an expression.")
end end
insert(items, expr) insert(items, lua.expr)
end end
return self.__class:comma_separated_items("{", items, "}"), nil return {
expr = self.__class:comma_separated_items("{", items, "}")
}
elseif "Dict" == _exp_0 then elseif "Dict" == _exp_0 then
local items = { } local items = { }
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 entry = _list_0[_index_0] local entry = _list_0[_index_0]
local key_expr, key_statement local key_lua
if entry.dict_key.type == "Word" then if entry.dict_key.type == "Word" then
key_expr, key_statement = repr(entry.dict_key.value), nil key_lua = {
expr = repr(entry.dict_key.value)
}
else else
key_expr, key_statement = self:tree_to_lua(entry.dict_key, filename) key_lua = self:tree_to_lua(entry.dict_key, filename)
end end
if key_statement then if key_lua.statements then
self:error("Cannot use [[" .. tostring(entry.dict_key.src) .. "]] as a dict key, since it's not an expression.") self:error("Cannot use [[" .. tostring(entry.dict_key.src) .. "]] as a dict key, since it's not an expression.")
end end
local value_expr, value_statement = self:tree_to_lua(entry.dict_value, filename) local value_lua = self:tree_to_lua(entry.dict_value, filename)
if value_statement then if value_lua.statements then
self:error("Cannot use [[" .. tostring(entry.dict_value.src) .. "]] as a dict value, since it's not an expression.") self:error("Cannot use [[" .. tostring(entry.dict_value.src) .. "]] as a dict value, since it's not an expression.")
end end
local key_str = key_expr:match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=]) local key_str = key_lua.expr:match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
if key_str then if key_str then
insert(items, tostring(key_str) .. "=" .. tostring(value_expr)) insert(items, tostring(key_str) .. "=" .. tostring(value_lua.expr))
else else
insert(items, "[" .. tostring(key_expr) .. "]=" .. tostring(value_expr)) insert(items, "[" .. tostring(key_lua.expr) .. "]=" .. tostring(value_lua.expr))
end end
end end
return self.__class:comma_separated_items("{", items, "}"), nil return {
expr = self.__class:comma_separated_items("{", items, "}")
}
elseif "Number" == _exp_0 then elseif "Number" == _exp_0 then
return repr(tree.value), nil return {
expr = repr(tree.value)
}
elseif "Var" == _exp_0 then elseif "Var" == _exp_0 then
if tree.value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then if tree.value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
return "vars." .. tostring(tree.value), nil return {
expr = "vars." .. tostring(tree.value)
}
else else
return "vars[" .. tostring(repr(tree.value)) .. "]", nil return {
expr = "vars[" .. tostring(repr(tree.value)) .. "]"
}
end end
else else
return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type)) return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type))
@ -1011,7 +1024,7 @@ end)]]):format(concat(lua_bits, "\n"))
return return
end end
local _exp_0 = tree.type local _exp_0 = tree.type
if "List" == _exp_0 or "File" == _exp_0 or "Thunk" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then if "List" == _exp_0 or "File" == _exp_0 or "Block" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then
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 v = _list_0[_index_0] local v = _list_0[_index_0]
@ -1064,7 +1077,7 @@ end)]]):format(concat(lua_bits, "\n"))
if vars[tree.value] ~= nil then if vars[tree.value] ~= nil then
tree = vars[tree.value] tree = vars[tree.value]
end end
elseif "File" == _exp_0 or "Nomsu" == _exp_0 or "Thunk" == _exp_0 or "List" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then elseif "File" == _exp_0 or "Nomsu" == _exp_0 or "Block" == _exp_0 or "List" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then
local new_value = self:replaced_vars(tree.value, vars) local new_value = self:replaced_vars(tree.value, vars)
if new_value ~= tree.value then if new_value ~= tree.value then
do do
@ -1281,43 +1294,52 @@ end)]]):format(concat(lua_bits, "\n"))
if type(bit) == "string" then if type(bit) == "string" then
insert(concat_parts, bit) insert(concat_parts, bit)
else else
local expr, statement = self:tree_to_lua(bit, filename) local lua = self:tree_to_lua(bit, filename)
if statement then if lua.statements then
self:error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.") self:error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
end end
insert(concat_parts, expr) insert(concat_parts, lua.expr)
end end
end end
return concat(concat_parts) return concat(concat_parts)
end end
local lua_code self:defmacro("do %block", function(self, vars)
lua_code = function(self, vars) local make_line
local lua = nomsu_string_as_lua(self, vars.code) make_line = function(lua)
return nil, lua return lua.expr and (lua.expr .. ";") or lua.statements
end end
self:defmacro("lua> %code", lua_code) if vars.block.type == "Block" then
local lua_value return self:tree_to_lua(vars.block)
lua_value = function(self, vars) else
local lua = nomsu_string_as_lua(self, vars.code) return {
return lua, nil expr = tostring(self:tree_to_lua(vars.block)) .. "(nomsu, vars)"
}
end end
self:defmacro("=lua %code", lua_value)
self:defmacro("__src__ %level", function(self, vars)
return self:repr(self:source_code(self:tree_to_value(vars.level)))
end) end)
self:def("derp \\%foo derp \\%bar", function(self, vars) self:defmacro("immediately %block", function(self, vars)
local lua = "local x = " .. repr((function() local lua = self:tree_to_lua(vars.block)
local _accum_0 = { } local lua_code = lua.statements or (lua.expr .. ";")
local _len_0 = 1 self:run_lua(lua_code, vars)
local _list_0 = vars.foo.value return {
for _index_0 = 1, #_list_0 do statements = lua_code
local t = _list_0[_index_0] }
_accum_0[_len_0] = t.stub end)
_len_0 = _len_0 + 1 self:defmacro("lua> %code", function(self, vars)
end local lua = nomsu_string_as_lua(self, vars.code)
return _accum_0 return {
end)()) .. ";\nlocal y = " .. self:tree_to_lua(vars.bar) statements = lua
return print(colored.green(lua)) }
end)
self:defmacro("=lua %code", function(self, vars)
local lua = nomsu_string_as_lua(self, vars.code)
return {
expr = lua
}
end)
self:defmacro("__src__ %level", function(self, vars)
return {
expr = repr(self:source_code(self:tree_to_value(vars.level)))
}
end) end)
local run_file local run_file
run_file = function(self, vars) run_file = function(self, vars)
@ -1340,17 +1362,19 @@ end)]]):format(concat(lua_bits, "\n"))
end end
end end
self:def("run file %filename", run_file) self:def("run file %filename", run_file)
local _require return self:defmacro("require %filename", function(self, vars)
_require = function(self, vars) local filename = self:tree_to_value(vars.filename)
local loaded = self.defs["#loaded_files"] local loaded = self.defs["#loaded_files"]
if not loaded[vars.filename] then if not loaded[filename] then
loaded[vars.filename] = run_file(self, { loaded[filename] = run_file(self, {
filename = vars.filename filename = filename
}) or true }) or true
end end
return loaded[vars.filename] local _ = loaded[filename]
end return {
return self:def("require %filename", _require) statements = ""
}
end)
end end
} }
_base_0.__index = _base_0 _base_0.__index = _base_0
@ -1476,7 +1500,10 @@ if arg then
input = io.open(args.input):read("*a") input = io.open(args.input):read("*a")
end end
local vars = { } local vars = { }
local retval, code = c:run(input, args.input, vars, nil, compiled_output) local retval, code = c:run(input, args.input, vars)
if args.output then
compiled_output:write("lua> \"..\"\n " .. c:indent(code:gsub("\\", "\\\\"), 1))
end
end end
if args.flags["-p"] then if args.flags["-p"] then
c.write = _write c.write = _write

268
nomsu.moon
View File

@ -36,6 +36,7 @@ if _VERSION == "Lua 5.1"
-- 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.)
-- Do a pass on all rules to enforce parameters-are-nouns heuristic
lpeg.setmaxstack 10000 -- whoa lpeg.setmaxstack 10000 -- whoa
{:P,:R,:V,:S,:Cg,:C,:Cp,:B,:Cmt} = lpeg {:P,:R,:V,:S,:Cg,:C,:Cp,:B,:Cmt} = lpeg
@ -164,17 +165,17 @@ class NomsuCompiler
@write_err(...) @write_err(...)
@write_err("\n") @write_err("\n")
def: (signature, thunk, src, is_macro=false)=> def: (signature, fn, src, is_macro=false)=>
if type(signature) == 'string' if type(signature) == 'string'
signature = @get_stubs {signature} signature = @get_stubs {signature}
elseif type(signature) == 'table' and type(signature[1]) == 'string' elseif type(signature) == 'table' and type(signature[1]) == 'string'
signature = @get_stubs signature signature = @get_stubs signature
@assert type(thunk) == 'function', "Bad thunk: #{repr thunk}" @assert type(fn) == 'function', "Bad fn: #{repr fn}"
canonical_args = nil canonical_args = nil
canonical_escaped_args = nil canonical_escaped_args = nil
aliases = {} aliases = {}
@@def_number += 1 @@def_number += 1
def = {:thunk, :src, :is_macro, aliases:{}, def_number:@@def_number, defs:@defs} def = {:fn, :src, :is_macro, aliases:{}, def_number:@@def_number, defs:@defs}
where_defs_go = (getmetatable(@defs) or {}).__newindex or @defs where_defs_go = (getmetatable(@defs) or {}).__newindex or @defs
for {stub, arg_names, escaped_args} in *signature for {stub, arg_names, escaped_args} in *signature
@assert stub, "NO STUB FOUND: #{repr signature}" @assert stub, "NO STUB FOUND: #{repr signature}"
@ -193,8 +194,8 @@ class NomsuCompiler
stub_def = setmetatable({:stub, :arg_names, :escaped_args}, {__index:def}) stub_def = setmetatable({:stub, :arg_names, :escaped_args}, {__index:def})
rawset(where_defs_go, stub, stub_def) rawset(where_defs_go, stub, stub_def)
defmacro: (signature, thunk, src)=> defmacro: (signature, fn, src)=>
@def(signature, thunk, src, true) @def(signature, fn, src, true)
scoped: (thunk)=> scoped: (thunk)=>
old_defs = @defs old_defs = @defs
@ -253,13 +254,15 @@ class NomsuCompiler
@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)
{:thunk, :arg_names} = def {:fn, :arg_names} = def
args = {name, select(i,...) for i,name in ipairs(arg_names)} args = {name, select(i,...) for i,name in ipairs(arg_names)}
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:"}"
for name, value in pairs(args)
@writeln " #{colored.bright "* #{name}"} = #{colored.dim repr(value)}"
old_defs, @defs = @defs, def.defs old_defs, @defs = @defs, def.defs
rets = {thunk(self,args)} rets = {fn(self,args)}
@defs = old_defs @defs = old_defs
remove @callstack remove @callstack
return unpack(rets) return unpack(rets)
@ -270,9 +273,9 @@ class NomsuCompiler
@write "#{colored.bright "RUNNING MACRO"} #{colored.underscore colored.magenta(tree.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(tree.stub, tree.line_no, unpack(args)) ret = @call(tree.stub, tree.line_no, unpack(args))
remove @callstack remove @callstack
return expr, statement return ret
dedent: (code)=> dedent: (code)=>
unless code\find("\n") unless code\find("\n")
@ -290,8 +293,8 @@ class NomsuCompiler
else else
return (code\gsub("\n"..(" ")\rep(indent_spaces), "\n ")) return (code\gsub("\n"..(" ")\rep(indent_spaces), "\n "))
indent: (code)=> indent: (code, levels=1)=>
(code\gsub("\n","\n ")) return code\gsub("\n","\n"..(" ")\rep(levels))
assert_permission: (stub)=> assert_permission: (stub)=>
fn_def = @defs[stub] fn_def = @defs[stub]
@ -338,60 +341,40 @@ class NomsuCompiler
@error "Execution quota exceeded. Your code took too long." @error "Execution quota exceeded. Your code took too long."
debug.sethook timeout, "", max_operations debug.sethook timeout, "", max_operations
tree = @parse(src, filename) tree = @parse(src, filename)
@assert tree, "Tree failed to compile: #{src}" @assert tree, "Failed to parse: #{src}"
@assert tree.type == "File", "Attempt to run non-file: #{tree.type}" @assert tree.type == "File", "Attempt to run non-file: #{tree.type}"
buffer = {} lua = @tree_to_lua(tree)
-- TODO: handle return statements in a file lua_code = lua.statements or (lua.expr..";")
for statement in *tree.value ret = @run_lua(lua_code, vars)
if @debug if max_operations
@writeln "#{colored.bright "RUNNING NOMSU:"}\n#{colored.bright colored.yellow statement.src}" debug.sethook!
@writeln colored.bright("PARSED TO TREE:")
@print_tree statement
ok,expr,statements = pcall(@tree_to_lua, self, statement, filename)
if not ok
@errorln "#{colored.red "Error occurred in statement:"}\n#{colored.bright colored.yellow statement.src}"
error(expr)
code_for_statement = ([[
return (function(nomsu, vars)
%s
end);]])\format(statements or ("return "..expr..";"))
if output_file if output_file
if statements and #statements > 0 output_file\write(lua_code)
output_file\write "lua> \"..\"\n #{@indent statements\gsub("\\","\\\\")}\n" return ret, lua_code, vars
if expr and #expr > 0
output_file\write "=lua \"..\"\n #{@indent expr\gsub("\\","\\\\")}\n" run_lua: (lua_code, vars={})=>
if @debug load_lua_fn, err = load([[
@writeln "#{colored.bright "RUNNING LUA:"}\n#{colored.blue colored.bright(code_for_statement)}" return function(nomsu, vars)
lua_thunk, err = load(code_for_statement) %s
if not lua_thunk end]]\format(lua_code))
if not load_lua_fn
n = 1 n = 1
fn = -> fn = ->
n = n + 1 n = n + 1
("\n%-3d|")\format(n) ("\n%-3d|")\format(n)
code = "1 |"..code_for_statement\gsub("\n", fn) code = "1 |"..lua_code\gsub("\n", fn)
error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{err}\n\nProduced by statement:\n#{colored.bright colored.yellow statement.src}") @error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{err}")
run_statement = lua_thunk! run_lua_fn = load_lua_fn!
ok,ret = pcall(run_statement, self, vars) ok,ret = pcall(run_lua_fn, self, vars)
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 tree.src}"
@errorln debug.traceback! @errorln debug.traceback!
error(ret) @error(ret)
if statements return ret
insert buffer, statements
if expr
insert buffer, "#{expr};"
if max_operations
debug.sethook!
lua_code = ([[
return (function(nomsu, vars)
%s
end);]])\format(concat(buffer, "\n"))
return nil, lua_code, vars
tree_to_value: (tree, vars, filename)=> tree_to_value: (tree, vars, filename)=>
code = "return (function(nomsu, vars)\nreturn #{@tree_to_lua(tree, filename)};\nend);" code = "return (function(nomsu, vars)\nreturn #{@tree_to_lua(tree, filename).expr};\nend);"
if @debug if @debug
@writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}" @writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}"
lua_thunk, err = load(code) lua_thunk, err = load(code)
@ -413,9 +396,9 @@ end);]])\format(concat(buffer, "\n"))
inside, inline = @tree_to_nomsu(tree.value, force_inline) inside, inline = @tree_to_nomsu(tree.value, force_inline)
return "\\#{inside}", inline return "\\#{inside}", inline
when "Thunk" when "Block"
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
@ -491,7 +474,8 @@ end);]])\format(concat(buffer, "\n"))
return longbuff, false return longbuff, false
when "Dict" when "Dict"
error("Sorry, not yet implemented.") -- TODO: Implement
@error("Sorry, not yet implemented.")
when "Number" when "Number"
return repr(tree.value), true return repr(tree.value), true
@ -517,7 +501,7 @@ end);]])\format(concat(buffer, "\n"))
if is_list(value) if is_list(value)
return "[#{concat [@value_to_nomsu(v) for v in *value], ", "}]" return "[#{concat [@value_to_nomsu(v) for v in *value], ", "}]"
else else
return "(d{#{concat ["#{@value_to_nomsu(k)}=#{@value_to_nomsu(v)}" for k,v in pairs(value)], "; "}})" return "{#{concat ["#{@value_to_nomsu(k)}=#{@value_to_nomsu(v)}" for k,v in pairs(value)], ", "}}"
when "string" when "string"
if value == "\n" if value == "\n"
return "'\\n'" return "'\\n'"
@ -538,50 +522,52 @@ end);]])\format(concat(buffer, "\n"))
@error "Invalid tree: #{repr(tree)}" @error "Invalid tree: #{repr(tree)}"
switch tree.type switch tree.type
when "File" when "File"
if #tree.value == 1
return @tree_to_lua(tree.value[1], filename)
lua_bits = {} lua_bits = {}
for line in *tree.value for line in *tree.value
expr,statement = @tree_to_lua line, filename lua = @tree_to_lua line, filename
if statement then insert lua_bits, statement if not lua
if expr then insert lua_bits, "#{expr};" @error "No lua produced by #{repr line}"
return nil, concat(lua_bits, "\n") if lua.statements then insert lua_bits, lua.statements
if lua.expr then insert lua_bits, "#{lua.expr};"
return statements:concat(lua_bits, "\n")
when "Nomsu" when "Nomsu"
return "nomsu:parse(#{repr tree.value.src}, #{repr tree.line_no}).value[1]", nil return expr:"nomsu:parse(#{repr tree.value.src}, #{repr tree.line_no}).value[1]"
when "Thunk" when "Block"
lua_bits = {} lua_bits = {}
for arg in *tree.value for arg in *tree.value
expr,statement = @tree_to_lua arg, filename lua = @tree_to_lua arg, filename
if #tree.value == 1 and expr and not statement if #tree.value == 1 and lua.expr and not lua.statements
return ([[ return expr:lua.expr
(function(nomsu, vars) if lua.statements then insert lua_bits, lua.statements
return %s; if lua.expr then insert lua_bits, "#{lua.expr};"
end)]])\format(expr) return statements:concat(lua_bits, "\n")
if statement then insert lua_bits, statement
if expr then insert lua_bits, "#{expr};"
return ([[
(function(nomsu, vars)
%s
end)]])\format(concat(lua_bits, "\n"))
when "FunctionCall" when "FunctionCall"
insert @compilestack, tree insert @compilestack, tree
def = @defs[tree.stub] def = @defs[tree.stub]
if def and def.is_macro if def and def.is_macro
expr, statement = @run_macro(tree) lua = @run_macro(tree)
remove @compilestack remove @compilestack
return expr, statement return lua
elseif not def and @@math_patt\match(tree.stub) elseif not def and @@math_patt\match(tree.stub)
-- This is a bit of a hack, but this code handles arbitrarily complex
-- math expressions like 2*x + 3^2 without having to define a single
-- rule for every possibility.
bits = {} bits = {}
for tok in *tree.value for tok in *tree.value
if tok.type == "Word" if tok.type == "Word"
insert bits, tok.value insert bits, tok.value
else else
expr, statement = @tree_to_lua(tok, filename) lua = @tree_to_lua(tok, filename)
@assert(statement == nil, "non-expression value inside math expression") @assert(lua.statements == nil, "non-expression value inside math expression")
insert bits, expr insert bits, lua.expr
return "(#{concat bits, " "})" remove @compilestack
return expr:"(#{concat bits, " "})"
args = {repr(tree.stub), repr(tree.line_no)} args = {repr(tree.stub), repr(tree.line_no)}
local arg_names, escaped_args local arg_names, escaped_args
@ -595,14 +581,14 @@ end)]])\format(concat(lua_bits, "\n"))
if escaped_args[arg_names[arg_num]] if escaped_args[arg_names[arg_num]]
insert args, "nomsu:parse(#{repr arg.src}, #{repr tree.line_no}).value[1]" insert args, "nomsu:parse(#{repr arg.src}, #{repr tree.line_no}).value[1]"
else else
expr,statement = @tree_to_lua arg, filename lua = @tree_to_lua arg, filename
if statement if lua.statements
@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, lua.expr
arg_num += 1 arg_num += 1
remove @compilestack remove @compilestack
return @@comma_separated_items("nomsu:call(", args, ")"), nil return expr:@@comma_separated_items("nomsu:call(", args, ")")
when "String" when "String"
concat_parts = {} concat_parts = {}
@ -614,61 +600,60 @@ end)]])\format(concat(lua_bits, "\n"))
if string_buffer ~= "" if string_buffer ~= ""
insert concat_parts, repr(string_buffer) insert concat_parts, repr(string_buffer)
string_buffer = "" string_buffer = ""
expr, statement = @tree_to_lua bit, filename lua = @tree_to_lua bit, filename
if @debug if @debug
@writeln (colored.bright "INTERP:") @writeln (colored.bright "INTERP:")
@print_tree bit @print_tree bit
@writeln "#{colored.bright "EXPR:"} #{expr}, #{colored.bright "STATEMENT:"} #{statement}" @writeln "#{colored.bright "EXPR:"} #{lua.expr}, #{colored.bright "STATEMENT:"} #{lua.statements}"
if statement if lua.statements
@error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression." @error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
insert concat_parts, "nomsu:stringify(#{expr})" insert concat_parts, "nomsu:stringify(#{lua.expr})"
if string_buffer ~= "" if string_buffer ~= ""
insert concat_parts, repr(string_buffer) insert concat_parts, repr(string_buffer)
if #concat_parts == 0 if #concat_parts == 0
return "''", nil return expr:"''"
elseif #concat_parts == 1 elseif #concat_parts == 1
return concat_parts[1], nil return expr:concat_parts[1]
else return "(#{concat(concat_parts, "..")})", nil else return expr:"(#{concat(concat_parts, "..")})"
when "List" when "List"
items = {} items = {}
for item in *tree.value for item in *tree.value
expr,statement = @tree_to_lua item, filename lua = @tree_to_lua item, filename
if statement if lua.statements
@error "Cannot use [[#{item.src}]] as a list item, since it's not an expression." @error "Cannot use [[#{item.src}]] as a list item, since it's not an expression."
insert items, expr insert items, lua.expr
return @@comma_separated_items("{", items, "}"), nil return expr:@@comma_separated_items("{", items, "}")
when "Dict" when "Dict"
items = {} items = {}
for entry in *tree.value for entry in *tree.value
local key_expr,key_statement key_lua = if entry.dict_key.type == "Word"
if entry.dict_key.type == "Word" {expr:repr(entry.dict_key.value)}
key_expr,key_statement = repr(entry.dict_key.value),nil
else else
key_expr,key_statement = @tree_to_lua entry.dict_key, filename @tree_to_lua entry.dict_key, filename
if key_statement if key_lua.statements
@error "Cannot use [[#{entry.dict_key.src}]] as a dict key, since it's not an expression." @error "Cannot use [[#{entry.dict_key.src}]] as a dict key, since it's not an expression."
value_expr,value_statement = @tree_to_lua entry.dict_value, filename value_lua = @tree_to_lua entry.dict_value, filename
if value_statement if value_lua.statements
@error "Cannot use [[#{entry.dict_value.src}]] as a dict value, since it's not an expression." @error "Cannot use [[#{entry.dict_value.src}]] as a dict value, since it's not an expression."
key_str = key_expr\match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=]) key_str = key_lua.expr\match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
if key_str if key_str
insert items, "#{key_str}=#{value_expr}" insert items, "#{key_str}=#{value_lua.expr}"
else else
insert items, "[#{key_expr}]=#{value_expr}" insert items, "[#{key_lua.expr}]=#{value_lua.expr}"
return @@comma_separated_items("{", items, "}"), nil return expr:@@comma_separated_items("{", items, "}")
when "Number" when "Number"
return repr(tree.value), nil return expr:repr(tree.value)
when "Var" when "Var"
if tree.value\match("^[a-zA-Z_][a-zA-Z0-9_]*$") if tree.value\match("^[a-zA-Z_][a-zA-Z0-9_]*$")
return "vars.#{tree.value}", nil return expr:"vars.#{tree.value}"
else else
return "vars[#{repr tree.value}]", nil return expr:"vars[#{repr tree.value}]"
else else
@error("Unknown/unimplemented thingy: #{tree.type}") @error("Unknown/unimplemented thingy: #{tree.type}")
@ -678,7 +663,7 @@ end)]])\format(concat(lua_bits, "\n"))
if type(tree) != 'table' or not tree.type if type(tree) != 'table' or not tree.type
return return
switch tree.type switch tree.type
when "List", "File", "Thunk", "FunctionCall", "String" when "List", "File", "Block", "FunctionCall", "String"
for v in *tree.value for v in *tree.value
@walk_tree(v, depth+1) @walk_tree(v, depth+1)
when "Dict" when "Dict"
@ -728,7 +713,7 @@ end)]])\format(concat(lua_bits, "\n"))
when "Var" when "Var"
if vars[tree.value] ~= nil if vars[tree.value] ~= nil
tree = vars[tree.value] tree = vars[tree.value]
when "File", "Nomsu", "Thunk", "List", "FunctionCall", "String" when "File", "Nomsu", "Block", "List", "FunctionCall", "String"
new_value = @replaced_vars tree.value, vars new_value = @replaced_vars tree.value, vars
if new_value != tree.value if new_value != tree.value
tree = {k,v for k,v in pairs(tree)} tree = {k,v for k,v in pairs(tree)}
@ -834,29 +819,35 @@ end)]])\format(concat(lua_bits, "\n"))
if type(bit) == "string" if type(bit) == "string"
insert concat_parts, bit insert concat_parts, bit
else else
expr, statement = @tree_to_lua bit, filename lua = @tree_to_lua bit, filename
if statement if lua.statements
@error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression." @error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
insert concat_parts, expr insert concat_parts, lua.expr
return concat(concat_parts) return concat(concat_parts)
-- Uses named local functions to help out callstack readability @defmacro "do %block", (vars)=>
lua_code = (vars)=> make_line = (lua)-> lua.expr and (lua.expr..";") or lua.statements
lua = nomsu_string_as_lua(@, vars.code) if vars.block.type == "Block"
return nil, lua return @tree_to_lua(vars.block)
@defmacro "lua> %code", lua_code else
return expr:"#{@tree_to_lua vars.block}(nomsu, vars)"
lua_value = (vars)=> @defmacro "immediately %block", (vars)=>
lua = @tree_to_lua(vars.block)
lua_code = lua.statements or (lua.expr..";")
@run_lua(lua_code, vars)
return statements:lua_code
@defmacro "lua> %code", (vars)=>
lua = nomsu_string_as_lua(@, vars.code) lua = nomsu_string_as_lua(@, vars.code)
return lua, nil return statements:lua
@defmacro "=lua %code", lua_value
@defmacro "=lua %code", (vars)=>
lua = nomsu_string_as_lua(@, vars.code)
return expr:lua
@defmacro "__src__ %level", (vars)=> @defmacro "__src__ %level", (vars)=>
@repr @source_code @tree_to_value vars.level expr: repr(@source_code(@tree_to_value(vars.level)))
@def "derp \\%foo derp \\%bar", (vars)=>
lua = "local x = "..repr([t.stub for t in *vars.foo.value])..";\nlocal y = "..@tree_to_lua(vars.bar)
print(colored.green lua)
run_file = (vars)=> run_file = (vars)=>
if vars.filename\match(".*%.lua") if vars.filename\match(".*%.lua")
@ -873,13 +864,13 @@ end)]])\format(concat(lua_bits, "\n"))
else else
@error "Invalid filetype for #{vars.filename}" @error "Invalid filetype for #{vars.filename}"
@def "run file %filename", run_file @def "run file %filename", run_file
@defmacro "require %filename", (vars)=>
_require = (vars)=> filename = @tree_to_value(vars.filename)
loaded = @defs["#loaded_files"] loaded = @defs["#loaded_files"]
if not loaded[vars.filename] if not loaded[filename]
loaded[vars.filename] = run_file(self, {filename:vars.filename}) or true loaded[filename] = run_file(self, {:filename}) or true
return loaded[vars.filename] loaded[filename]
@def "require %filename", _require return statements:""
if arg if arg
@ -923,7 +914,10 @@ if arg
io.read('*a') io.read('*a')
else io.open(args.input)\read("*a") else io.open(args.input)\read("*a")
vars = {} vars = {}
retval, code = c\run(input, args.input, vars, nil, compiled_output) retval, code = c\run(input, args.input, vars)
if args.output
compiled_output\write("lua> \"..\"\n "..c\indent(code\gsub("\\","\\\\"), 1))
if args.flags["-p"] if args.flags["-p"]
c.write = _write c.write = _write

18
nomsu.peg
View File

@ -11,12 +11,12 @@ statement: functioncall / expression
noeol_statement: noeol_functioncall / noeol_expression noeol_statement: noeol_functioncall / noeol_expression
inline_statement: inline_functioncall / inline_expression inline_statement: inline_functioncall / inline_expression
inline_thunk (Thunk): {| ":" %ws* inline_statement |} inline_block (Block): {| ":" %ws* inline_statement |}
eol_thunk (Thunk): {| ":" %ws* noeol_statement eol |} eol_block (Block): {| ":" %ws* noeol_statement eol |}
indented_thunk (Thunk): indented_block (Block):
{| ":" indent {| ":" indent
statement (nodent statement)* statement (nodent statement)*
(dedent / (("" -> "Error while parsing thunk") => error)) (dedent / (("" -> "Error while parsing block") => error))
|} |}
inline_nomsu (Nomsu): "\" inline_expression inline_nomsu (Nomsu): "\" inline_expression
@ -25,18 +25,18 @@ indented_nomsu (Nomsu): "\" expression
inline_expression: inline_expression:
number / variable / inline_string / inline_list / inline_dict / inline_nomsu number / variable / inline_string / inline_list / inline_dict / inline_nomsu
/ ("(" %ws* (inline_thunk / inline_statement) %ws* ")") / ("(" %ws* (inline_block / inline_statement) %ws* ")")
noeol_expression: noeol_expression:
indented_string / indented_nomsu / indented_list / indented_dict / indented_thunk indented_string / indented_nomsu / indented_list / indented_dict / indented_block
/ ("(..)" indent / ("(..)" indent
statement statement
(dedent / (("" -> "Error while parsing indented expression") => error)) (dedent / (("" -> "Error while parsing indented expression") => error))
) / inline_expression ) / inline_expression
expression: eol_thunk / eol_nomsu / noeol_expression expression: eol_block / eol_nomsu / noeol_expression
-- Function calls need at least one word in them -- Function calls need at least one word in them
inline_functioncall (FunctionCall): inline_functioncall (FunctionCall):
{| (inline_expression %ws*)* word (%ws* (inline_expression / word))* (%ws* inline_thunk)?|} {| (inline_expression %ws*)* word (%ws* (inline_expression / word))* (%ws* inline_block)?|}
noeol_functioncall (FunctionCall): noeol_functioncall (FunctionCall):
{| (noeol_expression %ws*)* word (%ws* (noeol_expression / word))* |} {| (noeol_expression %ws*)* word (%ws* (noeol_expression / word))* |}
functioncall (FunctionCall): functioncall (FunctionCall):
@ -57,7 +57,7 @@ indented_string (String):
~} / string_interpolation)* ~} / string_interpolation)*
|} ((!.) / (&(%nl+ !%gt_nodented)) / (("" -> "Error while parsing String") => error)) |} ((!.) / (&(%nl+ !%gt_nodented)) / (("" -> "Error while parsing String") => error))
string_interpolation: string_interpolation:
"\" (variable / inline_list / inline_dict / inline_string / ("(" %ws* (inline_thunk / inline_statement) %ws* ")")) "\" (variable / inline_list / inline_dict / inline_string / ("(" %ws* (inline_block / inline_statement) %ws* ")"))
number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber) number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber)