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

Pretty much mostly working.

Browse Source
This commit is contained in:
Bruce Hill 2018-01-10 20:45:03 -08:00
parent 09b64e0341
commit 53a9d4eae8
9 changed files with 263 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/collections.nom
View File

@ -105,14 +105,13 @@ compile [%expression for %item in %iterable] to:
assert ((%item's "type") == "Var") ".." assert ((%item's "type") == "Var") ".."
List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type") List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
return ".." return ".."
(function(nomsu, vars); (function(nomsu);
local comprehension = {}; local comprehension = {};
for i,item in ipairs(\(%iterable as lua)) do; for i,\(%item as lua) in ipairs(\(%iterable as lua)) do;
\(%item as lua) = item;
comprehension[i] = \(%expression as lua); comprehension[i] = \(%expression as lua);
end; end;
return comprehension; return comprehension;
end)(nomsu, setmetatable({}, {__index=vars})) end)(nomsu)
parse [%expression for all %iterable] as: %expression for % in %iterable parse [%expression for all %iterable] as: %expression for % in %iterable
compile [%expression for %key = %value in %iterable] to: compile [%expression for %key = %value in %iterable] to:
@ -121,14 +120,13 @@ compile [%expression for %key = %value in %iterable] to:
assert ((%value's "type") == "Var") ".." assert ((%value's "type") == "Var") ".."
List comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%value's "type") List comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%value's "type")
return ".." return ".."
(function(nomsu, vars); (function(nomsu);
local comprehension = {}; local comprehension = {};
for key,value in pairs(\(%iterable as lua)) do; for \(%key as lua), \(%value as lua) in pairs(\(%iterable as lua)) do;
\(%key as lua), \(%value as lua) = key, value;
comprehension[i] = \(%expression as lua); comprehension[i] = \(%expression as lua);
end; end;
return comprehension; return comprehension;
end)(nomsu, setmetatable({}, {__index=vars})) end)(nomsu)
rule [%items sorted] =: rule [%items sorted] =:
%copy = (% for all %items) %copy = (% for all %items)
@ -166,14 +164,13 @@ compile [%key = %value for %item in %iterable] to:
assert ((%item's "type") == "Var") ".." assert ((%item's "type") == "Var") ".."
Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type") Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
return ".." return ".."
(function(nomsu, vars); (function(nomsu);
local comprehension = {}; local comprehension = {};
for i,value in ipairs(\(%iterable as lua)) do; for i,\(%item as lua) in ipairs(\(%iterable as lua)) do;
\(%item as lua) = value;
comprehension[\(%key as lua)] = \(%value as lua); comprehension[\(%key as lua)] = \(%value as lua);
end; end;
return comprehension; return comprehension;
end)(nomsu, setmetatable({}, {__index=vars})) end)(nomsu)
parse [%key = %value for all %iterable] as: %key = %value for % in %iterable parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
compile [%key = %value for %src_key = %src_value in %iterable] to: compile [%key = %value for %src_key = %src_value in %iterable] to:
@ -182,12 +179,11 @@ compile [%key = %value for %src_key = %src_value in %iterable] to:
assert ((%src_value's "type") == "Var") ".." assert ((%src_value's "type") == "Var") ".."
Dict comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%src_value's "type") Dict comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%src_value's "type")
return ".." return ".."
(function(nomsu, vars); (function(nomsu);
local comprehension = {}; local comprehension = {};
for key,value in pairs(\(%iterable as lua)) do; for \(%src_key as lua), \(%src_value as lua) in pairs(\(%iterable as lua)) do;
\(%src_key as lua), \(%src_value as lua) = key, value;
comprehension[\(%key as lua)] = \(%value as lua); comprehension[\(%key as lua)] = \(%value as lua);
end; end;
return comprehension; return comprehension;
end)(nomsu, setmetatable({}, {__index=vars})) end)(nomsu)

22
lib/control_flow.nom
View File

@ -91,6 +91,7 @@ immediately:
for %var from %start to %stop by %step %body for %var from %start to %stop by %step %body
for %var from %start to %stop via %step %body for %var from %start to %stop via %step %body
..to code: ..to code:
lua> "local \%continue_labels, \%code, \%stop_labels"
%continue_labels = "" %continue_labels = ""
if (tree %body has function call \(do next for-loop)): if (tree %body has function call \(do next for-loop)):
%continue_labels join= "\n::continue_for::;" %continue_labels join= "\n::continue_for::;"
@ -126,6 +127,7 @@ immediately:
immediately: immediately:
compile [for %var in %iterable %body] to code: compile [for %var in %iterable %body] to code:
lua> "local \%continue_labels, \%stop_labels, \%code, \%stop_labels"
%continue_labels = "" %continue_labels = ""
if (tree %body has function call \(do next for-loop)): if (tree %body has function call \(do next for-loop)):
%continue_labels join= "\n::continue_for::;" %continue_labels join= "\n::continue_for::;"
@ -143,12 +145,12 @@ immediately:
%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])::;"
return (..) if %stop_labels != "":
".." %code = ".."
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
..if %stop_labels != "" else %code return %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()")
@ -186,10 +188,12 @@ immediately:
# Switch statement/multi-branch if # Switch statement/multi-branch if
immediately: immediately:
compile [when %body] to code: compile [when %body] to code:
lua> "local \%result, \%fallthroughs, \%first"
%result = "" %result = ""
%fallthroughs = [] %fallthroughs = []
%first = (yes) %first = (yes)
for %func_call in (%body's "value"): for %func_call in (%body's "value"):
lua> "local \%tokens, \%star, \%condition, \%action"
assert ((%func_call's "type") == "FunctionCall") ".." assert ((%func_call's "type") == "FunctionCall") ".."
Invalid format for 'when' statement. Only '*' blocks are allowed. Invalid format for 'when' statement. Only '*' blocks are allowed.
%tokens = (%func_call's "value") %tokens = (%func_call's "value")
@ -286,10 +290,10 @@ immediately:
..to code: ".." ..to code: ".."
do do
local fell_through = false; local fell_through = false;
local ok, ret1, ret2 = pcall(function(nomsu, vars) local ok, ret1, ret2 = pcall(function(nomsu)
\(%action as lua statements) \(%action as lua statements)
fell_through = true; fell_through = true;
end, nomsu, vars); end, nomsu);
if ok then if ok then
\(%success as lua statements) \(%success as lua statements)
end end
@ -313,13 +317,13 @@ immediately:
compile [do %action then always %final_action] to code: ".." compile [do %action then always %final_action] to code: ".."
do do
local fell_through = false; local fell_through = false;
local ok, ret1, ret2 = pcall(function(nomsu, vars) local ok, ret1, ret2 = pcall(function(nomsu)
\(%action as lua statements) \(%action as lua statements)
fell_through = true; fell_through = true;
end, nomsu, vars); end, nomsu);
local ok2, _ = pcall(function(nomsu, vars) local ok2, _ = pcall(function(nomsu)
\(%final_action as lua statements) \(%final_action as lua statements)
end, nomsu, vars); end, nomsu);
if not ok then nomsu:error(ret1); end if not ok then nomsu:error(ret1); end
if not ok2 then nomsu:error(ret2); end if not ok2 then nomsu:error(ret2); end
if not fell_through then if not fell_through then

74
lib/metaprogramming.nom
View File

@ -5,53 +5,59 @@
# Rule to make macros: # Rule to make macros:
immediately: immediately:
lua> ".." lua> ".."
nomsu:defmacro("compile %macro_def to %body", function(nomsu, vars) nomsu.parse_spec = function(nomsu, spec)
local signature = {};
for i, alias in ipairs(spec.value) do
signature[i] = alias.src;
end
local _, arg_names, _ = nomsu:get_stub(spec.value[1]);
local args = {"nomsu"};
for i, a in ipairs(arg_names) do args[i+1] = "_"..nomsu:var_to_lua_identifier(a); end
signature, args = nomsu:repr(signature), table.concat(args, ", ");
return signature, args;
end
immediately:
lua> ".."
nomsu:defmacro("compile %macro_def to %body", function(nomsu, \%macro_def, \%body)
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 == "Block", nomsu:assert(\%body.type == "Block",
"Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type)); "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
local signature = {}; local signature, args = nomsu:parse_spec(\%macro_def);
for i, alias in ipairs(\%macro_def.value) do
signature[i] = alias.src;
end
local body_lua = nomsu:tree_to_lua(\%body); local body_lua = nomsu:tree_to_lua(\%body);
body_lua = body_lua.statements or ("return "..body_lua.expr..";"); body_lua = body_lua.statements or ("return "..body_lua.expr..";");
local lua = ([[ local lua = ([[
do do
local function macro(nomsu, vars) local function macro(%s)
%s %s
end end
local function macro_wrapper(...) return {expr=macro(...)}; end local function macro_wrapper(...) return {expr=macro(...)}; end
nomsu:defmacro(%s, macro_wrapper, %s); nomsu:defmacro(%s, macro_wrapper, %s);
end]]):format(body_lua, nomsu:repr(signature), nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src))); end]]):format(args, body_lua, signature, nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
return {statements=lua}; return {statements=lua};
end, \(__src__ 1)); end, \(__src__ 1));
lua> ".." lua> ".."
nomsu:defmacro("compile %macro_def to code %body", function(nomsu, vars) nomsu:defmacro("compile %macro_def to code %body", function(nomsu, \%macro_def, \%body)
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 == "Block", nomsu:assert(\%body.type == "Block",
"Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type)); "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
local signature = {}; local signature, args = nomsu:parse_spec(\%macro_def);
for i, alias in ipairs(\%macro_def.value) do
signature[i] = alias.src;
end
local body_lua = nomsu:tree_to_lua(\%body); local body_lua = nomsu:tree_to_lua(\%body);
body_lua = body_lua.statements or ("return "..body_lua.expr..";"); body_lua = body_lua.statements or ("return "..body_lua.expr..";");
local lua = ([[ local lua = ([[
do do
local function macro(nomsu, vars) local function macro(%s)
%s %s
end end
local function macro_wrapper(...) return {statements=macro(...)}; end local function macro_wrapper(...) return {statements=macro(...)}; end
nomsu:defmacro(%s, macro_wrapper, %s); nomsu:defmacro(%s, macro_wrapper, %s);
end]]):format(body_lua, nomsu:repr(signature), nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src))); end]]):format(args, body_lua, signature, nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
return {statements=lua}; return {statements=lua};
end, \(__src__ 1)); end, \(__src__ 1));
compile [rand] to: "math.random()"
# Rule to make rules: # Rule to make rules:
immediately: immediately:
compile [rule %signature = %body] to code: compile [rule %signature = %body] to code:
@ -60,43 +66,41 @@ immediately:
"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 == "Block", nomsu:assert(\%body.type == "Block",
"Invalid type for rule definition body. Expected Block, but got: "..tostring(\%body.type)); "Invalid type for rule definition body. Expected Block, but got: "..tostring(\%body.type));
local signature = {}; local signature, args = nomsu:parse_spec(\%signature);
for i, alias in ipairs(\%signature.value) do
signature[i] = alias.src;
end
local body_lua = nomsu:tree_to_lua(\%body); local body_lua = nomsu:tree_to_lua(\%body);
body_lua = body_lua.statements or ("return "..body_lua.expr..";"); body_lua = body_lua.statements or ("return "..body_lua.expr..";");
local src = nomsu:dedent(nomsu:source_code(0)); local src = nomsu:dedent(nomsu:source_code(0));
local def_lua = ([[ local def_lua = ([[
nomsu:def(%s, function(nomsu, vars) nomsu:def(%s, function(%s)
%s %s
end, %s);]]):format(nomsu:repr(signature), body_lua, nomsu:repr(src)); end, %s);]]):format(signature, args, body_lua, nomsu:repr(src));
return def_lua; return def_lua;
# Rule to make nomsu macros: # Rule to make nomsu macros:
immediately: immediately:
lua> ".." lua> ".."
nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, vars) nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, \%shorthand, \%longhand)
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 == "Block", nomsu:assert(\%longhand.type == "Block",
"Invalid type for parse definition body. Expected Block, but got: "..tostring(\%longhand.type)); "Invalid type for parse definition body. Expected Block, but got: "..tostring(\%longhand.type));
local signature = {}; local signature, args = nomsu:parse_spec(\%shorthand);
for i, alias in ipairs(\%shorthand.value) do
signature[i] = alias.src;
end
local template = {}; local template = {};
for i, line in ipairs(\%longhand.value) do for i, line in ipairs(\%longhand.value) do
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")); template = nomsu:repr(table.concat(template, "\\n"));
return {expr=([[ local _, arg_names, _ = nomsu:get_stub(\%shorthand.value[1]);
nomsu:defmacro(%s, (function(nomsu, vars) local replacements = {};
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)
local template = nomsu:parse(%s, %s); local template = nomsu:parse(%s, %s);
if #template.value == 1 then template = template.value[1]; end local replacement = nomsu:replaced_vars(template, %s);
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, args, template, nomsu:repr(\%shorthand:get_line_no()), replacements, nomsu:repr(nomsu:source_code(0)));
return {statements=lua_code};
end), \(__src__ 1)); end), \(__src__ 1));
rule [remove rule %stub] =: rule [remove rule %stub] =:
@ -114,7 +118,7 @@ immediately:
local lua = nomsu:tree_to_lua(\%tree); local lua = nomsu:tree_to_lua(\%tree);
return lua.statements or (lua.expr..";"); 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)"
compile [repr %obj] to: compile [repr %obj] to:
"nomsu:repr(\(%obj as lua))" "nomsu:repr(\(%obj as lua))"
compile [indented %obj] to: compile [indented %obj] to:
@ -124,12 +128,14 @@ immediately:
compile [type %obj, type of %obj] to: compile [type %obj, type of %obj] to:
"type(\(%obj as lua))" "type(\(%obj as lua))"
immediately:
parse [lua do> %block] as: parse [lua do> %block] as:
lua> "do" lua> "do"
lua> %block lua> %block
lua> "end" lua> "end"
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)))"
compile [tree %tree with %replacements] to: ".." compile [tree %tree with %replacements] to: ".."

6
lib/operators.nom
View File

@ -20,13 +20,13 @@ compile [..]
%when_false_expr unless %condition else %when_true_expr %when_false_expr unless %condition else %when_true_expr
%when_false_expr unless %condition then %when_true_expr %when_false_expr unless %condition then %when_true_expr
..to: ".." ..to: ".."
(function(nomsu, vars) (function(nomsu, condition)
if \(%condition as lua) then if condition then
return \(%when_true_expr as lua); return \(%when_true_expr as lua);
else else
return \(%when_false_expr as lua); return \(%when_false_expr as lua);
end end
end)(nomsu, vars) end)(nomsu, \(%condition as lua))
parse [..] parse [..]
%true if %x == %y else %false, %true if %x == %y otherwise %false %true if %x == %y else %false, %true if %x == %y otherwise %false
%false unless %x == %y else %true, %false unless %x == %y otherwise %true %false unless %x == %y else %true, %false unless %x == %y otherwise %true

2
lib/scopes.nom
View File

@ -13,6 +13,8 @@ compile [str %] to: "tostring(\(% as lua))"
compile [scope] to: "nomsu.defs" compile [scope] to: "nomsu.defs"
compile [parent scope] to: "getmetatable(nomsu.defs).__index" compile [parent scope] to: "getmetatable(nomsu.defs).__index"
# TODO: fix this file
return
compile [using %scoped do %actions] to code: ".." compile [using %scoped do %actions] to code: ".."
do do
local old_scope, old_vars = nomsu.defs, vars; local old_scope, old_vars = nomsu.defs, vars;

14
lib/utils.nom
View File

@ -7,7 +7,7 @@ rule [error %msg] =:
nomsu "error"[%msg] nomsu "error"[%msg]
compile [assert %condition %msg] to code: ".." compile [assert %condition %msg] to code: ".."
if not (\(%condition as lua)) then if not (\(%condition as lua)) then
nomsu:error(\(%msg as lua)) nomsu:error(\(%msg as lua));
end end
parse [assert %condition] as: assert %condition (nil) parse [assert %condition] as: assert %condition (nil)
@ -80,19 +80,17 @@ compile [min of %items, smallest of %items, lowest of %items] to:
compile [max of %items, biggest of %items, largest of %items, highest of %items] to: compile [max of %items, biggest of %items, largest of %items, highest of %items] to:
"nomsu.utils.max(\(%items as lua))" "nomsu.utils.max(\(%items as lua))"
compile [min of %items by %value_expr] to: ".." compile [min of %items by %value_expr] to: ".."
nomsu.utils.min(\(%items as lua), function(item) nomsu.utils.min(\(%items as lua), function(\(\% as lua))
local vars = setmetatable({['']=item}, {__index=vars})
return \(%value_expr as lua) return \(%value_expr as lua)
end) end)
compile [max of %items by %value_expr] to: ".." compile [max of %items by %value_expr] to: ".."
nomsu.utils.max(\(%items as lua), function(item) nomsu.utils.max(\(%items as lua), function(\(\% as lua))
local vars = setmetatable({['']=item}, {__index=vars})
return \(%value_expr as lua) return \(%value_expr as lua)
end) end)
compile [sort %items] to: "table.sort(\(%items as lua))" compile [sort %items] to: "table.sort(\(%items as lua))"
rule [sort %items by %key] =: =lua ".." compile [sort %items by %key_expr] to: ".."
nomsu.utils.sort(\%items, function(x) nomsu.utils.sort(\(%items as lua), function(\(\% as lua))
return (\%key)(nomsu, {['']=x}); return \(%key_expr as lua);
end) end)
# String utilities # String utilities

6
lib/utils2.nom
View File

@ -11,7 +11,7 @@ compile [say %str] to:
compile [do %action] to code: compile [do %action] to code:
(%action as lua statements) if ((%action's "type") == "Thunk") (%action as lua statements) if ((%action's "type") == "Thunk")
..else "(\(%action as lua))(nomsu, vars);" ..else "(\(%action as lua))(nomsu);"
# With statement # With statement
compile [with %assignments %action] to code: compile [with %assignments %action] to code:
@ -33,10 +33,10 @@ compile [with %assignments %action] to code:
do do
\%setup \%setup
local fell_through = false; local fell_through = false;
local ok, ret1, ret2 = pcall(function(nomsu, vars) local ok, ret1, ret2 = pcall(function(nomsu)
\(%action as lua statements); \(%action as lua statements);
fell_through = true; fell_through = true;
end, nomsu, vars); end, nomsu);
\(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ") \(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ")
if not ok then nomsu:error(ret1); end if not ok then nomsu:error(ret1); end
if not fell_through then if not fell_through then

204
nomsu.lua
View File

@ -126,15 +126,13 @@ do
end end
return _accum_0 return _accum_0
end)(), " ") end)(), " ")
local line_no = 1
while (ctx.line_starts[line_no + 1] or math.huge) < start do
line_no = line_no + 1
end
local src = ctx.source_code:sub(start, stop - 1) local src = ctx.source_code:sub(start, stop - 1)
return { return {
start = start,
stop = stop,
type = "FunctionCall", type = "FunctionCall",
src = src, src = src,
line_no = tostring(ctx.filename) .. ":" .. tostring(line_no), get_line_no = ctx.get_line_no,
value = value, value = value,
stub = stub stub = stub
} }
@ -149,6 +147,7 @@ do
stop = stop, stop = stop,
value = value, value = value,
src = ctx.source_code:sub(start, stop - 1), src = ctx.source_code:sub(start, stop - 1),
get_line_no = ctx.get_line_no,
type = key type = key
} }
end end
@ -168,15 +167,26 @@ do
local nomsu = peg_tidier:match(io.open("nomsu.peg"):read("*a")) local nomsu = peg_tidier:match(io.open("nomsu.peg"):read("*a"))
nomsu = re.compile(nomsu, defs) nomsu = re.compile(nomsu, defs)
parse = function(source_code, filename) parse = function(source_code, filename)
local old_ctx = ctx local _ctx = {
ctx = {
source_code = source_code, source_code = source_code,
filename = filename, filename = filename,
indent_stack = { indent_stack = {
0 0
} }
} }
ctx.line_starts = re.compile("lines <- {| line ('\n' line)* |} line <- {} [^\n]*"):match(source_code) _ctx.line_starts = re.compile("lines <- {| line ('\n' line)* |} line <- {} [^\n]*"):match(source_code)
_ctx.get_line_no = function(self)
if not (self._line_no) then
local line_no = 1
while (_ctx.line_starts[line_no + 1] or math.huge) < self.start do
line_no = line_no + 1
end
self._line_no = tostring(_ctx.filename) .. ":" .. tostring(line_no)
end
return self._line_no
end
local old_ctx = ctx
ctx = _ctx
local tree = nomsu:match(source_code) local tree = nomsu:match(source_code)
ctx = old_ctx ctx = old_ctx
return tree return tree
@ -206,8 +216,6 @@ do
signature = self:get_stubs(signature) signature = self:get_stubs(signature)
end end
self:assert(type(fn) == 'function', "Bad fn: " .. tostring(repr(fn))) self:assert(type(fn) == 'function', "Bad fn: " .. tostring(repr(fn)))
local canonical_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 = {
@ -221,6 +229,7 @@ do
local where_defs_go = (getmetatable(self.defs) or { }).__newindex or self.defs local where_defs_go = (getmetatable(self.defs) or { }).__newindex or self.defs
for sig_i = 1, #signature do for sig_i = 1, #signature do
local stub, arg_names, escaped_args = unpack(signature[sig_i]) local stub, arg_names, escaped_args = unpack(signature[sig_i])
local arg_positions = { }
self:assert(stub, "NO STUB FOUND: " .. tostring(repr(signature))) self:assert(stub, "NO STUB FOUND: " .. tostring(repr(signature)))
if self.debug then if self.debug then
self:writeln(tostring(colored.bright("DEFINING RULE:")) .. " " .. tostring(colored.underscore(colored.magenta(repr(stub)))) .. " " .. tostring(colored.bright("WITH ARGS")) .. " " .. tostring(colored.dim(repr(arg_names)))) self:writeln(tostring(colored.bright("DEFINING RULE:")) .. " " .. tostring(colored.underscore(colored.magenta(repr(stub)))) .. " " .. tostring(colored.bright("WITH ARGS")) .. " " .. tostring(colored.dim(repr(arg_names))))
@ -232,22 +241,34 @@ do
end end
end end
end end
if canonical_args then if sig_i == 1 then
self:assert(equivalent(set(arg_names), canonical_args), "Mismatched args") do
else local _accum_0 = { }
canonical_args = set(arg_names) local _len_0 = 1
for i = 1, #arg_names do
_accum_0[_len_0] = i
_len_0 = _len_0 + 1
end end
if canonical_escaped_args then arg_positions = _accum_0
self:assert(equivalent(escaped_args, canonical_escaped_args), "Mismatched escaped args") end
else def.args = arg_names
canonical_escaped_args = escaped_args
def.escaped_args = escaped_args def.escaped_args = escaped_args
else
self:assert(equivalent(set(def.args), set(arg_names)), "Mismatched args")
self:assert(equivalent(def.escaped_args, escaped_args), "Mismatched escaped args")
for j, a in ipairs(arg_names) do
for i, c_a in ipairs(def.args) do
if a == c_a then
arg_positions[j] = i
end
end
end
end end
insert(def.aliases, stub) insert(def.aliases, stub)
local stub_def = setmetatable({ local stub_def = setmetatable({
stub = stub, stub = stub,
arg_names = arg_names, arg_names = arg_names,
escaped_args = escaped_args arg_positions = arg_positions
}, { }, {
__index = def __index = def
}) })
@ -361,27 +382,30 @@ do
if not (def.is_macro) then if not (def.is_macro) then
self:assert_permission(stub) self:assert_permission(stub)
end end
local fn, arg_names local fn, arg_positions
fn, arg_names = def.fn, def.arg_names fn, arg_positions = def.fn, def.arg_positions
local args local args
do do
local _tbl_0 = { } local _accum_0 = { }
for i, name in ipairs(arg_names) do local _len_0 = 1
_tbl_0[name] = select(i, ...) 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 end
args = _tbl_0 args = _accum_0
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:"))) self:writeln(tostring(colored.bright("WITH ARGS:")))
for name, value in pairs(args) do for i, value in ipairs(args) do
self:writeln(" " .. tostring(colored.bright("* " .. tostring(name))) .. " = " .. tostring(colored.dim(repr(value)))) self:writeln(" " .. tostring(colored.bright("* " .. tostring(def.args[i]))) .. " = " .. tostring(colored.dim(repr(value))))
end 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 = {
fn(self, args) fn(self, unpack(args))
} }
self.defs = old_defs self.defs = old_defs
remove(self.callstack) remove(self.callstack)
@ -407,7 +431,7 @@ 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 ret = self:call(tree.stub, tree.line_no, unpack(args)) local ret = self:call(tree.stub, tree:get_line_no(), unpack(args))
remove(self.callstack) remove(self.callstack)
return ret return ret
end, end,
@ -495,6 +519,7 @@ do
return false return false
end, end,
parse = function(self, str, filename) parse = function(self, str, filename)
self:assert(type(filename) == "string", "Bad filename type: " .. tostring(type(filename)))
if self.debug then if self.debug then
self:writeln(tostring(colored.bright("PARSING:")) .. "\n" .. tostring(colored.yellow(str))) self:writeln(tostring(colored.bright("PARSING:")) .. "\n" .. tostring(colored.yellow(str)))
end end
@ -507,10 +532,7 @@ do
end end
return tree return tree
end, end,
run = function(self, src, filename, vars, max_operations, output_file) run = function(self, src, filename, max_operations, output_file)
if vars == nil then
vars = { }
end
if max_operations == nil then if max_operations == nil then
max_operations = nil max_operations = nil
end end
@ -518,7 +540,7 @@ do
output_file = nil output_file = nil
end end
if src == "" then if src == "" then
return nil, "", vars return nil, ""
end end
if max_operations then if max_operations then
local timeout local timeout
@ -534,21 +556,18 @@ do
local lua = self:tree_to_lua(tree, filename) local lua = self:tree_to_lua(tree, filename)
local lua_code = lua.statements or (lua.expr .. ";") local lua_code = lua.statements or (lua.expr .. ";")
lua_code = "-- File: " .. tostring(filename) .. "\n" .. lua_code lua_code = "-- File: " .. tostring(filename) .. "\n" .. lua_code
local ret = self:run_lua(lua_code, vars) local ret = self:run_lua(lua_code)
if max_operations then if max_operations then
debug.sethook() debug.sethook()
end end
if output_file then if output_file then
output_file:write(lua_code) output_file:write(lua_code)
end end
return ret, lua_code, vars return ret, lua_code
end, end,
run_file = function(self, filename, vars) run_file = function(self, filename)
if vars == nil then
vars = { }
end
if filename:match(".*%.lua") then if filename:match(".*%.lua") then
return dofile(filename)(self, vars) return dofile(filename)(self)
end end
if filename:match(".*%.nom") then if filename:match(".*%.nom") then
if not self.skip_precompiled then if not self.skip_precompiled then
@ -556,7 +575,7 @@ do
if file then if file then
local lua_code = file:read("*a") local lua_code = file:read("*a")
file:close() file:close()
return self:run_lua(lua_code, vars) return self:run_lua(lua_code)
end end
end end
local file = file or io.open(filename) local file = file or io.open(filename)
@ -570,23 +589,20 @@ do
return self:error("Invalid filetype for " .. tostring(filename)) return self:error("Invalid filetype for " .. tostring(filename))
end end
end, end,
require_file = function(self, filename, vars) require_file = function(self, filename)
if vars == nil then
vars = { }
end
local loaded = self.defs["#loaded_files"] local loaded = self.defs["#loaded_files"]
if not loaded[filename] then if not loaded[filename] then
loaded[filename] = self:run_file(filename, vars) or true loaded[filename] = self:run_file(filename) or true
end end
return loaded[filename] return loaded[filename]
end, end,
run_lua = function(self, lua_code, vars) run_lua = function(self, lua_code)
if vars == nil then local load_lua_fn, err = load(([[return function(nomsu)
vars = { }
end
local load_lua_fn, err = load(([[return function(nomsu, vars)
%s %s
end]]):format(lua_code)) end]]):format(lua_code))
if self.debug then
self:writeln(tostring(colored.bright("RUNNING LUA:")) .. "\n" .. tostring(colored.blue(colored.bright(lua_code))))
end
if not load_lua_fn then if not load_lua_fn then
local n = 1 local n = 1
local fn local fn
@ -598,15 +614,15 @@ end]]):format(lua_code))
self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(err)) self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(err))
end end
local run_lua_fn = load_lua_fn() local run_lua_fn = load_lua_fn()
local ok, ret = pcall(run_lua_fn, self, vars) local ok, ret = pcall(run_lua_fn, self)
if not ok then if not ok then
self:errorln(debug.traceback()) self:errorln(debug.traceback())
self:error(ret) self:error(ret)
end end
return ret return ret
end, end,
tree_to_value = function(self, tree, vars, filename) tree_to_value = function(self, tree, filename)
local code = "return (function(nomsu, vars)\nreturn " .. tostring(self:tree_to_lua(tree, filename).expr) .. ";\nend);" local code = "return (function(nomsu)\nreturn " .. tostring(self:tree_to_lua(tree, filename).expr) .. ";\nend);"
code = "-- Tree to value: " .. tostring(filename) .. "\n" .. code code = "-- Tree to value: " .. tostring(filename) .. "\n" .. code
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))))
@ -615,7 +631,7 @@ end]]):format(lua_code))
if not lua_thunk then if not lua_thunk then
self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(colored.red(err))) self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(colored.red(err)))
end end
return (lua_thunk())(self, vars or { }) return (lua_thunk())(self)
end, end,
tree_to_nomsu = function(self, tree, force_inline) tree_to_nomsu = function(self, tree, force_inline)
if force_inline == nil then if force_inline == nil then
@ -841,7 +857,7 @@ end]]):format(lua_code))
} }
elseif "Nomsu" == _exp_0 then elseif "Nomsu" == _exp_0 then
return { return {
expr = "nomsu:parse(" .. tostring(repr(tree.value.src)) .. ", " .. tostring(repr(tree.line_no)) .. ").value[1]" expr = "nomsu:parse(" .. tostring(repr(tree.value.src)) .. ", " .. tostring(repr(tree:get_line_no())) .. ").value[1]"
} }
elseif "Block" == _exp_0 then elseif "Block" == _exp_0 then
local lua_bits = { } local lua_bits = { }
@ -891,7 +907,7 @@ end]]):format(lua_code))
end end
local args = { local args = {
repr(tree.stub), repr(tree.stub),
repr(tree.line_no) repr(tree:get_line_no())
} }
local arg_names, escaped_args local arg_names, escaped_args
if def then if def then
@ -922,7 +938,7 @@ end]]):format(lua_code))
break break
end end
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:get_line_no())) .. ").value[1]")
else else
local lua = self:tree_to_lua(arg, filename) local lua = self:tree_to_lua(arg, filename)
if lua.statements then if lua.statements then
@ -1039,15 +1055,9 @@ end]]):format(lua_code))
expr = repr(tree.value) 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
return { return {
expr = "vars." .. tostring(tree.value) expr = ("_" .. self:var_to_lua_identifier(tree.value))
} }
else
return {
expr = "vars[" .. tostring(repr(tree.value)) .. "]"
}
end
else else
return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type)) return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type))
end end
@ -1256,13 +1266,15 @@ end]]):format(lua_code))
msg = '' msg = ''
end end
if not condition then if not condition then
return self:error(msg) return self:error("Assertion failed: " .. msg)
end end
end, end,
error = function(self, msg) error = function(self, msg)
local error_msg = colored.red("ERROR!") local error_msg = colored.red("ERROR!")
if msg then if msg and #msg > 0 then
error_msg = error_msg .. ("\n" .. (colored.bright(colored.yellow(colored.onred(msg))))) error_msg = error_msg .. ("\n" .. (colored.bright(colored.yellow(colored.onred(msg)))))
else
error_msg = error_msg .. "\n<no message>"
end end
error_msg = error_msg .. "\nCallstack:" error_msg = error_msg .. "\nCallstack:"
local maxlen = max((function() local maxlen = max((function()
@ -1301,20 +1313,6 @@ end]]):format(lua_code))
self.callstack = { } self.callstack = { }
return error(error_msg, 3) return error(error_msg, 3)
end, end,
typecheck = function(self, vars, varname, desired_type)
local x = vars[varname]
local x_type = type(x)
if x_type == desired_type then
return x
end
if x_type == 'table' then
x_type = x.type or x_type
if x_type == desired_type then
return x
end
end
return self:error("Invalid type for %" .. tostring(varname) .. ". Expected " .. tostring(desired_type) .. ", but got " .. tostring(x_type) .. ":\n" .. tostring(repr(x)))
end,
source_code = function(self, level) source_code = function(self, level)
if level == nil then if level == nil then
level = 0 level = 0
@ -1340,51 +1338,51 @@ end]]):format(lua_code))
end end
return concat(concat_parts) return concat(concat_parts)
end end
self:defmacro("do %block", function(self, vars) self:defmacro("do %block", function(self, _block)
local make_line local make_line
make_line = function(lua) make_line = function(lua)
return lua.expr and (lua.expr .. ";") or lua.statements return lua.expr and (lua.expr .. ";") or lua.statements
end end
if vars.block.type == "Block" then if _block.type == "Block" then
return self:tree_to_lua(vars.block) return self:tree_to_lua(_block)
else else
return { return {
expr = tostring(self:tree_to_lua(vars.block)) .. "(nomsu, vars)" expr = tostring(self:tree_to_lua(_block)) .. "(nomsu)"
} }
end end
end) end)
self:defmacro("immediately %block", function(self, vars) self:defmacro("immediately %block", function(self, _block)
local lua = self:tree_to_lua(vars.block) local lua = self:tree_to_lua(_block)
local lua_code = lua.statements or (lua.expr .. ";") local lua_code = lua.statements or (lua.expr .. ";")
lua_code = "-- Immediately:\n" .. lua_code lua_code = "-- Immediately:\n" .. lua_code
self:run_lua(lua_code, vars) self:run_lua(lua_code)
return { return {
statements = lua_code statements = lua_code
} }
end) end)
self:defmacro("lua> %code", function(self, vars) self:defmacro("lua> %code", function(self, _code)
local lua = nomsu_string_as_lua(self, vars.code) local lua = nomsu_string_as_lua(self, _code)
return { return {
statements = lua statements = lua
} }
end) end)
self:defmacro("=lua %code", function(self, vars) self:defmacro("=lua %code", function(self, _code)
local lua = nomsu_string_as_lua(self, vars.code) local lua = nomsu_string_as_lua(self, _code)
return { return {
expr = lua expr = lua
} }
end) end)
self:defmacro("__src__ %level", function(self, vars) self:defmacro("__src__ %level", function(self, _level)
return { return {
expr = repr(self:source_code(self:tree_to_value(vars.level))) expr = repr(self:source_code(self:tree_to_value(_level)))
} }
end) end)
self:def("run file %filename", function(self, vars) self:def("run file %filename", function(self, _filename)
return self:run_file(vars.filename, vars) return self:run_file(_filename)
end) end)
return self:defmacro("require %filename", function(self, vars) return self:defmacro("require %filename", function(self, _filename)
local filename = self:tree_to_value(vars.filename) local filename = self:tree_to_value(_filename)
self:require_file(filename, vars) self:require_file(filename)
return { return {
statements = "nomsu:require_file(" .. tostring(repr(filename)) .. ");" statements = "nomsu:require_file(" .. tostring(repr(filename)) .. ");"
} }
@ -1513,8 +1511,7 @@ if arg then
else else
input = io.open(args.input):read("*a") input = io.open(args.input):read("*a")
end end
local vars = { } local retval, code = c:run(input, args.input)
local retval, code = c:run(input, args.input, vars)
if args.output then if args.output then
compiled_output:write(code) compiled_output:write(code)
end end
@ -1524,7 +1521,6 @@ if arg then
end end
end end
if args.flags["-i"] then if args.flags["-i"] then
local vars = { }
c:run('require "lib/core.nom"', "stdin") c:run('require "lib/core.nom"', "stdin")
while true do while true do
local buff = "" local buff = ""
@ -1540,7 +1536,7 @@ if arg then
break break
end end
local ok, ret = pcall(function() local ok, ret = pcall(function()
return c:run(buff, "stdin", vars) return c:run(buff, "stdin")
end) end)
if ok and ret ~= nil then if ok and ret ~= nil then
print("= " .. repr(ret)) print("= " .. repr(ret))

154
nomsu.moon
View File

@ -100,14 +100,12 @@ do
error(err_msg) error(err_msg)
FunctionCall: (start, value, stop)-> FunctionCall: (start, value, stop)->
stub = concat([(t.type == "Word" and t.value or "%") for t in *value], " ") stub = concat([(t.type == "Word" and t.value or "%") for t in *value], " ")
line_no = 1
while (ctx.line_starts[line_no+1] or math.huge) < start do line_no += 1
src = ctx.source_code\sub(start,stop-1) src = ctx.source_code\sub(start,stop-1)
return {type: "FunctionCall", :src, line_no: "#{ctx.filename}:#{line_no}", :value, :stub} return {:start, :stop, type: "FunctionCall", :src, get_line_no:ctx.get_line_no, :value, :stub}
setmetatable(defs, {__index:(key)=> setmetatable(defs, {__index:(key)=>
make_node = (start, value, stop)-> make_node = (start, value, stop)->
{:start, :stop, :value, src:ctx.source_code\sub(start,stop-1), type: key} {:start, :stop, :value, src:ctx.source_code\sub(start,stop-1), get_line_no:ctx.get_line_no, type: key}
self[key] = make_node self[key] = make_node
return make_node return make_node
}) })
@ -129,10 +127,18 @@ do
nomsu = re.compile(nomsu, defs) nomsu = re.compile(nomsu, defs)
parse = (source_code, filename)-> parse = (source_code, filename)->
_ctx = {:source_code, :filename, indent_stack: {0}}
_ctx.line_starts = re.compile("lines <- {| line ('\n' line)* |} line <- {} [^\n]*")\match(source_code)
_ctx.get_line_no = =>
unless @_line_no
line_no = 1
while (_ctx.line_starts[line_no+1] or math.huge) < @start do line_no += 1
@_line_no = "#{_ctx.filename}:#{line_no}"
return @_line_no
old_ctx = ctx old_ctx = ctx
export ctx export ctx
ctx = {:source_code, :filename, indent_stack: {0}} ctx = _ctx
ctx.line_starts = re.compile("lines <- {| line ('\n' line)* |} line <- {} [^\n]*")\match(source_code)
tree = nomsu\match(source_code) tree = nomsu\match(source_code)
ctx = old_ctx ctx = old_ctx
return tree return tree
@ -171,28 +177,31 @@ class NomsuCompiler
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(fn) == 'function', "Bad fn: #{repr fn}" @assert type(fn) == 'function', "Bad fn: #{repr fn}"
canonical_args = nil
canonical_escaped_args = nil
aliases = {} aliases = {}
@@def_number += 1 @@def_number += 1
def = {:fn, :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 sig_i=1,#signature for sig_i=1,#signature
stub, arg_names, escaped_args = unpack(signature[sig_i]) stub, arg_names, escaped_args = unpack(signature[sig_i])
arg_positions = {}
@assert stub, "NO STUB FOUND: #{repr signature}" @assert stub, "NO STUB FOUND: #{repr signature}"
if @debug then @writeln "#{colored.bright "DEFINING RULE:"} #{colored.underscore colored.magenta repr(stub)} #{colored.bright "WITH ARGS"} #{colored.dim repr(arg_names)}" if @debug then @writeln "#{colored.bright "DEFINING RULE:"} #{colored.underscore colored.magenta repr(stub)} #{colored.bright "WITH ARGS"} #{colored.dim repr(arg_names)}"
for i=1,#arg_names-1 do for j=i+1,#arg_names for i=1,#arg_names-1 do for j=i+1,#arg_names
if arg_names[i] == arg_names[j] then @error "Duplicate argument in function #{stub}: '#{arg_names[i]}'" if arg_names[i] == arg_names[j] then @error "Duplicate argument in function #{stub}: '#{arg_names[i]}'"
if canonical_args
@assert equivalent(set(arg_names), canonical_args), "Mismatched args" if sig_i == 1
else canonical_args = set(arg_names) arg_positions = [i for i=1,#arg_names]
if canonical_escaped_args def.args = arg_names
@assert equivalent(escaped_args, canonical_escaped_args), "Mismatched escaped args"
else
canonical_escaped_args = escaped_args
def.escaped_args = escaped_args def.escaped_args = escaped_args
else
@assert equivalent(set(def.args), set(arg_names)), "Mismatched args"
@assert equivalent(def.escaped_args, escaped_args), "Mismatched escaped args"
for j,a in ipairs(arg_names)
for i,c_a in ipairs(def.args)
if a == c_a
arg_positions[j] = i
insert def.aliases, stub insert def.aliases, stub
stub_def = setmetatable({:stub, :arg_names, :escaped_args}, {__index:def}) stub_def = setmetatable({:stub, :arg_names, :arg_positions}, {__index:def})
rawset(where_defs_go, stub, stub_def) rawset(where_defs_go, stub, stub_def)
defmacro: (signature, fn, src)=> defmacro: (signature, fn, src)=>
@ -255,15 +264,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)
{:fn, :arg_names} = def {:fn, :arg_positions} = def
args = {name, select(i,...) for i,name in ipairs(arg_names)} args = [select(p, ...) for p in *arg_positions]
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:"}" @writeln "#{colored.bright "WITH ARGS:"}"
for name, value in pairs(args) for i, value in ipairs(args)
@writeln " #{colored.bright "* #{name}"} = #{colored.dim repr(value)}" @writeln " #{colored.bright "* #{def.args[i]}"} = #{colored.dim repr(value)}"
old_defs, @defs = @defs, def.defs old_defs, @defs = @defs, def.defs
rets = {fn(self,args)} rets = {fn(self,unpack(args))}
@defs = old_defs @defs = old_defs
remove @callstack remove @callstack
return unpack(rets) return unpack(rets)
@ -274,7 +283,7 @@ 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"
ret = @call(tree.stub, tree.line_no, unpack(args)) ret = @call(tree.stub, tree\get_line_no!, unpack(args))
remove @callstack remove @callstack
return ret return ret
@ -324,6 +333,7 @@ class NomsuCompiler
return false return false
parse: (str, filename)=> parse: (str, filename)=>
@assert type(filename) == "string", "Bad filename type: #{type filename}"
if @debug if @debug
@writeln("#{colored.bright "PARSING:"}\n#{colored.yellow str}") @writeln("#{colored.bright "PARSING:"}\n#{colored.yellow str}")
str = str\gsub("\r","") str = str\gsub("\r","")
@ -334,8 +344,8 @@ class NomsuCompiler
@print_tree tree, " " @print_tree tree, " "
return tree return tree
run: (src, filename, vars={}, max_operations=nil, output_file=nil)=> run: (src, filename, max_operations=nil, output_file=nil)=>
if src == "" then return nil, "", vars if src == "" then return nil, ""
if max_operations if max_operations
timeout = -> timeout = ->
debug.sethook! debug.sethook!
@ -348,23 +358,23 @@ class NomsuCompiler
lua = @tree_to_lua(tree, filename) lua = @tree_to_lua(tree, filename)
lua_code = lua.statements or (lua.expr..";") lua_code = lua.statements or (lua.expr..";")
lua_code = "-- File: #{filename}\n"..lua_code lua_code = "-- File: #{filename}\n"..lua_code
ret = @run_lua(lua_code, vars) ret = @run_lua(lua_code)
if max_operations if max_operations
debug.sethook! debug.sethook!
if output_file if output_file
output_file\write(lua_code) output_file\write(lua_code)
return ret, lua_code, vars return ret, lua_code
run_file: (filename, vars={})=> run_file: (filename)=>
if filename\match(".*%.lua") if filename\match(".*%.lua")
return dofile(filename)(@, vars) return dofile(filename)(@)
if filename\match(".*%.nom") if filename\match(".*%.nom")
if not @skip_precompiled -- Look for precompiled version if not @skip_precompiled -- Look for precompiled version
file = io.open(filename\gsub("%.nom", ".lua"), "r") file = io.open(filename\gsub("%.nom", ".lua"), "r")
if file if file
lua_code = file\read("*a") lua_code = file\read("*a")
file\close! file\close!
return @run_lua(lua_code, vars) return @run_lua(lua_code)
file = file or io.open(filename) file = file or io.open(filename)
if not file if not file
@error "File does not exist: #{filename}" @error "File does not exist: #{filename}"
@ -374,17 +384,19 @@ class NomsuCompiler
else else
@error "Invalid filetype for #{filename}" @error "Invalid filetype for #{filename}"
require_file: (filename, vars={})=> require_file: (filename)=>
loaded = @defs["#loaded_files"] loaded = @defs["#loaded_files"]
if not loaded[filename] if not loaded[filename]
loaded[filename] = @run_file(filename, vars) or true loaded[filename] = @run_file(filename) or true
return loaded[filename] return loaded[filename]
run_lua: (lua_code, vars={})=> run_lua: (lua_code)=>
load_lua_fn, err = load([[ load_lua_fn, err = load([[
return function(nomsu, vars) return function(nomsu)
%s %s
end]]\format(lua_code)) end]]\format(lua_code))
if @debug
@writeln "#{colored.bright "RUNNING LUA:"}\n#{colored.blue colored.bright(lua_code)}"
if not load_lua_fn if not load_lua_fn
n = 1 n = 1
fn = -> fn = ->
@ -393,22 +405,22 @@ end]]\format(lua_code))
code = "1 |"..lua_code\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}") @error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{err}")
run_lua_fn = load_lua_fn! run_lua_fn = load_lua_fn!
ok,ret = pcall(run_lua_fn, self, vars) ok,ret = pcall(run_lua_fn, self)
if not ok if not ok
--@errorln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow tree.src}" --@errorln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow tree.src}"
@errorln debug.traceback! @errorln debug.traceback!
@error(ret) @error(ret)
return ret return ret
tree_to_value: (tree, vars, filename)=> tree_to_value: (tree, filename)=>
code = "return (function(nomsu, vars)\nreturn #{@tree_to_lua(tree, filename).expr};\nend);" code = "return (function(nomsu)\nreturn #{@tree_to_lua(tree, filename).expr};\nend);"
code = "-- Tree to value: #{filename}\n"..code code = "-- Tree to value: #{filename}\n"..code
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)
if not lua_thunk if not lua_thunk
@error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{colored.red err}") @error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{colored.red err}")
return (lua_thunk!)(self, vars or {}) return (lua_thunk!)(self)
tree_to_nomsu: (tree, force_inline=false)=> tree_to_nomsu: (tree, force_inline=false)=>
-- Return <nomsu code>, <is safe for inline use> -- Return <nomsu code>, <is safe for inline use>
@ -562,7 +574,7 @@ end]]\format(lua_code))
return statements:concat(lua_bits, "\n") return statements:concat(lua_bits, "\n")
when "Nomsu" when "Nomsu"
return expr:"nomsu:parse(#{repr tree.value.src}, #{repr tree.line_no}).value[1]" return expr:"nomsu:parse(#{repr tree.value.src}, #{repr tree\get_line_no!}).value[1]"
when "Block" when "Block"
lua_bits = {} lua_bits = {}
@ -597,7 +609,7 @@ end]]\format(lua_code))
remove @compilestack remove @compilestack
return expr:"(#{concat bits, " "})" return expr:"(#{concat bits, " "})"
args = {repr(tree.stub), repr(tree.line_no)} args = {repr(tree.stub), repr(tree\get_line_no!)}
local arg_names, escaped_args local arg_names, escaped_args
if def if def
arg_names, escaped_args = def.arg_names, def.escaped_args arg_names, escaped_args = def.arg_names, def.escaped_args
@ -607,7 +619,7 @@ end]]\format(lua_code))
for arg in *tree.value for arg in *tree.value
if arg.type == 'Word' then continue if arg.type == 'Word' then continue
if escaped_args[arg_names[arg_num]] 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\get_line_no!}).value[1]"
else else
lua = @tree_to_lua arg, filename lua = @tree_to_lua arg, filename
if lua.statements if lua.statements
@ -678,10 +690,7 @@ end]]\format(lua_code))
return expr:repr(tree.value) return expr:repr(tree.value)
when "Var" when "Var"
if tree.value\match("^[a-zA-Z_][a-zA-Z0-9_]*$") return expr:("_"..@var_to_lua_identifier(tree.value))
return expr:"vars.#{tree.value}"
else
return expr:"vars[#{repr tree.value}]"
else else
@error("Unknown/unimplemented thingy: #{tree.type}") @error("Unknown/unimplemented thingy: #{tree.type}")
@ -808,12 +817,14 @@ end]]\format(lua_code))
assert: (condition, msg='')=> assert: (condition, msg='')=>
if not condition if not condition
@error(msg) @error("Assertion failed: "..msg)
error: (msg)=> error: (msg)=>
error_msg = colored.red "ERROR!" error_msg = colored.red "ERROR!"
if msg if msg and #msg > 0
error_msg ..= "\n" .. (colored.bright colored.yellow colored.onred msg) error_msg ..= "\n" .. (colored.bright colored.yellow colored.onred msg)
else
error_msg ..= "\n<no message>"
error_msg ..= "\nCallstack:" error_msg ..= "\nCallstack:"
maxlen = max([#c[2] for c in *@callstack when c != "#macro"]) maxlen = max([#c[2] for c in *@callstack when c != "#macro"])
for i=#@callstack,1,-1 for i=#@callstack,1,-1
@ -827,15 +838,6 @@ end]]\format(lua_code))
@callstack = {} @callstack = {}
error error_msg, 3 error error_msg, 3
typecheck: (vars, varname, desired_type)=>
x = vars[varname]
x_type = type(x)
if x_type == desired_type then return x
if x_type == 'table'
x_type = x.type or x_type
if x_type == desired_type then return x
@error "Invalid type for %#{varname}. Expected #{desired_type}, but got #{x_type}:\n#{repr x}"
source_code: (level=0)=> source_code: (level=0)=>
@dedent @compilestack[#@compilestack-level].src @dedent @compilestack[#@compilestack-level].src
@ -853,37 +855,37 @@ end]]\format(lua_code))
insert concat_parts, lua.expr insert concat_parts, lua.expr
return concat(concat_parts) return concat(concat_parts)
@defmacro "do %block", (vars)=> @defmacro "do %block", (_block)=>
make_line = (lua)-> lua.expr and (lua.expr..";") or lua.statements make_line = (lua)-> lua.expr and (lua.expr..";") or lua.statements
if vars.block.type == "Block" if _block.type == "Block"
return @tree_to_lua(vars.block) return @tree_to_lua(_block)
else else
return expr:"#{@tree_to_lua vars.block}(nomsu, vars)" return expr:"#{@tree_to_lua _block}(nomsu)"
@defmacro "immediately %block", (vars)=> @defmacro "immediately %block", (_block)=>
lua = @tree_to_lua(vars.block) lua = @tree_to_lua(_block)
lua_code = lua.statements or (lua.expr..";") lua_code = lua.statements or (lua.expr..";")
lua_code = "-- Immediately:\n"..lua_code lua_code = "-- Immediately:\n"..lua_code
@run_lua(lua_code, vars) @run_lua(lua_code)
return statements:lua_code return statements:lua_code
@defmacro "lua> %code", (vars)=> @defmacro "lua> %code", (_code)=>
lua = nomsu_string_as_lua(@, vars.code) lua = nomsu_string_as_lua(@, _code)
return statements:lua return statements:lua
@defmacro "=lua %code", (vars)=> @defmacro "=lua %code", (_code)=>
lua = nomsu_string_as_lua(@, vars.code) lua = nomsu_string_as_lua(@, _code)
return expr:lua return expr:lua
@defmacro "__src__ %level", (vars)=> @defmacro "__src__ %level", (_level)=>
expr: repr(@source_code(@tree_to_value(vars.level))) expr: repr(@source_code(@tree_to_value(_level)))
@def "run file %filename", (vars)=> @def "run file %filename", (_filename)=>
@run_file(vars.filename, vars) @run_file(_filename)
@defmacro "require %filename", (vars)=> @defmacro "require %filename", (_filename)=>
filename = @tree_to_value(vars.filename) filename = @tree_to_value(_filename)
@require_file(filename, vars) @require_file(filename)
return statements:"nomsu:require_file(#{repr filename});" return statements:"nomsu:require_file(#{repr filename});"
if arg if arg
@ -926,8 +928,7 @@ if arg
input = if args.input == '-' input = if args.input == '-'
io.read('*a') io.read('*a')
else io.open(args.input)\read("*a") else io.open(args.input)\read("*a")
vars = {} retval, code = c\run(input, args.input)
retval, code = c\run(input, args.input, vars)
if args.output if args.output
compiled_output\write(code) compiled_output\write(code)
@ -936,7 +937,6 @@ if arg
if args.flags["-i"] if args.flags["-i"]
-- REPL -- REPL
vars = {}
c\run('require "lib/core.nom"', "stdin") c\run('require "lib/core.nom"', "stdin")
while true while true
buff = "" buff = ""
@ -948,7 +948,7 @@ if arg
buff ..= line buff ..= line
if #buff == 0 if #buff == 0
break break
ok, ret = pcall(-> c\run(buff, "stdin", vars)) ok, ret = pcall(-> c\run(buff, "stdin"))
if ok and ret != nil if ok and ret != nil
print "= "..repr(ret) print "= "..repr(ret)