From 421abe1a6f6c04ba55106b9154160ccd45d83610 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Tue, 9 Jan 2018 14:59:06 -0800 Subject: [PATCH] Cleaned up metaprogramming to go "compile to" -> "rule =" -> "parse as". This speeds things up a bit, and is more intuitive. --- lib/control_flow.nom | 569 +++++++++++++++++++++------------------- lib/metaprogramming.nom | 108 ++++---- nomsu.lua | 15 +- nomsu.moon | 13 +- 4 files changed, 367 insertions(+), 338 deletions(-) diff --git a/lib/control_flow.nom b/lib/control_flow.nom index 5169ac2..922338f 100644 --- a/lib/control_flow.nom +++ b/lib/control_flow.nom @@ -3,312 +3,327 @@ require "lib/operators.nom" require "lib/utils.nom" # Conditionals -compile [if %condition %if_body] to code: ".." - if \(%condition as lua) then - \(%if_body as lua statements) - end --end if -parse [unless %condition %unless_body] as: if (not %condition) %unless_body -parse [if %x == %y %if_body] as: if (%x == %y) %if_body -parse [if %x != %y %if_body] as: if (%x != %y) %if_body -parse [unless %x == %y %if_body] as: if (%x != %y) %if_body -parse [unless %x != %y %if_body] as: if (%x == %y) %if_body +immediately: + compile [if %condition %if_body] to code: ".." + if \(%condition as lua) then + \(%if_body as lua statements) + end --end if + parse [unless %condition %unless_body] as: if (not %condition) %unless_body + parse [if %x == %y %if_body] as: if (%x == %y) %if_body + parse [if %x != %y %if_body] as: if (%x != %y) %if_body + parse [unless %x == %y %if_body] as: if (%x != %y) %if_body + parse [unless %x != %y %if_body] as: if (%x == %y) %if_body -compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to code: ".." - if \(%condition as lua) then - \(%if_body as lua statements) - else - \(%else_body as lua statements) - end --end if -parse [if %x == %y %if_body else %else_body] as: if (%x == %y) %if_body else %else_body -parse [if %x != %y %if_body else %else_body] as: if (%x != %y) %if_body else %else_body -parse [unless %x == %y %if_body else %else_body] as: if (%x != %y) %if_body else %else_body -parse [unless %x != %y %if_body else %else_body] as: if (%x == %y) %if_body else %else_body + compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to code: ".." + if \(%condition as lua) then + \(%if_body as lua statements) + else + \(%else_body as lua statements) + end --end if + parse [if %x == %y %if_body else %else_body] as: if (%x == %y) %if_body else %else_body + parse [if %x != %y %if_body else %else_body] as: if (%x != %y) %if_body else %else_body + parse [unless %x == %y %if_body else %else_body] as: if (%x != %y) %if_body else %else_body + parse [unless %x != %y %if_body else %else_body] as: if (%x == %y) %if_body else %else_body # Return -compile [return] to code: "do return; end" -compile [return %return_value] to code: "do return \(%return_value as lua); end" +immediately: + compile [return] to code: "do return; end" + compile [return %return_value] to code: "do return \(%return_value as lua); end" # GOTOs -compile [-> %label] to code: ".." - ::label_\(nomsu "var_to_lua_identifier" [%label])::; -compile [go to %label] to code: ".." - goto label_\(nomsu "var_to_lua_identifier" [%label]); +immediately: + compile [-> %label] to code: ".." + ::label_\(nomsu "var_to_lua_identifier" [%label])::; + compile [go to %label] to code: ".." + goto label_\(nomsu "var_to_lua_identifier" [%label]); -rule [tree %tree has function call %call] =: - lua> ".." - local target = (\%call).stub; - for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\%tree); end) do - if type(subtree) == 'table' and subtree.type == "FunctionCall" - and subtree.stub == target then - return true; +# Helper function +immediately: + rule [tree %tree has function call %call] =: + lua> ".." + local target = (\%call).stub; + for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\%tree); end) do + if type(subtree) == 'table' and subtree.type == "FunctionCall" + and subtree.stub == target then + return true; + end end - end - return false; + return false; # While loops -compile [do next repeat-loop] to code: "goto continue_repeat;" -compile [stop repeat-loop] to code: "goto stop_repeat;" -compile [repeat while %condition %body] to code: - %continue_labels = (..) - "\n::continue_repeat::;" if (tree %body has function call \(do next repeat-loop)) else "" - %code = ".." - while \(%condition as lua) do - \(%body as lua statements)\ - ..\%continue_labels - end --while-loop - if (tree %body has function call \(stop repeat-loop)): - return ".." - do --while-loop label scope - \%code - ::stop_repeat::; - end --while-loop label scope - return %code -parse [repeat %body] as: repeat while (true) %body -parse [repeat until %condition %body] as: repeat while (not %condition) %body -parse [repeat while %x == %y %body] as: repeat while (%x == %y) %body -parse [repeat while %x != %y %body] as: repeat while (%x != %y) %body -parse [repeat until %x == %y %body] as: repeat while (%x != %y) %body -parse [repeat until %x != %y %body] as: repeat while (%x == %y) %body +immediately: + compile [do next repeat-loop] to code: "goto continue_repeat;" + compile [stop repeat-loop] to code: "goto stop_repeat;" + compile [repeat while %condition %body] to code: + %continue_labels = (..) + "\n::continue_repeat::;" if (tree %body has function call \(do next repeat-loop)) else "" + %code = ".." + while \(%condition as lua) do + \(%body as lua statements)\ + ..\%continue_labels + end --while-loop + if (tree %body has function call \(stop repeat-loop)): + return ".." + do --while-loop label scope + \%code + ::stop_repeat::; + end --while-loop label scope + return %code + parse [repeat %body] as: repeat while (true) %body + parse [repeat until %condition %body] as: repeat while (not %condition) %body + parse [repeat while %x == %y %body] as: repeat while (%x == %y) %body + parse [repeat while %x != %y %body] as: repeat while (%x != %y) %body + parse [repeat until %x == %y %body] as: repeat while (%x != %y) %body + parse [repeat until %x != %y %body] as: repeat while (%x == %y) %body # For loop control flow: -compile [stop for-loop] to code: "goto stop_for;" -compile [stop %var] to code: ".." - goto stop_\(nomsu "var_to_lua_identifier" [%var]); -compile [do next for-loop] to code: "goto continue_for;" -compile [do next %var] to code: ".." - goto continue_\(nomsu "var_to_lua_identifier" [%var]); +immediately: + compile [stop for-loop] to code: "goto stop_for;" + compile [stop %var] to code: ".." + goto stop_\(nomsu "var_to_lua_identifier" [%var]); + compile [do next for-loop] to code: "goto continue_for;" + compile [do next %var] to code: ".." + goto continue_\(nomsu "var_to_lua_identifier" [%var]); # Numeric range for loops -compile [..] - for %var from %start to %stop by %step %body - for %var from %start to %stop via %step %body -..to code: - %continue_labels = "" - if (tree %body has function call \(do next for-loop)): - %continue_labels join= "\n::continue_for::;" - if (tree %body has function call (tree \(do next %) with {""=%var})): - %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;" - # This trashes the loop variables, just like in Python. - %code = ".." - for i=\(%start as lua),\(%stop as lua),\(%step as lua) do - \(%var as lua) = i; - \(%body as lua statements)\ - ..\%continue_labels - end --numeric for-loop - %stop_labels = "" - if (tree %body has function call \(stop for-loop)): - %stop_labels join= "\n::stop_for::;" - if (tree %body has function call (tree \(stop %) with {""=%var})): - %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" - return (..) - ".." - do --for-loop label scope - \%code\ - ..\%stop_labels - end --for-loop label scope - ..if %stop_labels != "" else %code +immediately: + compile [..] + for %var from %start to %stop by %step %body + for %var from %start to %stop via %step %body + ..to code: + %continue_labels = "" + if (tree %body has function call \(do next for-loop)): + %continue_labels join= "\n::continue_for::;" + if (tree %body has function call (tree \(do next %) with {""=%var})): + %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;" + # This trashes the loop variables, just like in Python. + %code = ".." + for i=\(%start as lua),\(%stop as lua),\(%step as lua) do + \(%var as lua) = i; + \(%body as lua statements)\ + ..\%continue_labels + end --numeric for-loop + %stop_labels = "" + if (tree %body has function call \(stop for-loop)): + %stop_labels join= "\n::stop_for::;" + if (tree %body has function call (tree \(stop %) with {""=%var})): + %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" + return (..) + ".." + do --for-loop label scope + \%code\ + ..\%stop_labels + end --for-loop label scope + ..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 all %start to %stop by %step %body - for all %start to %stop via %step %body -..as: for % from %start to %stop via %step %body -parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body +immediately: + parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body + parse [..] + for all %start to %stop by %step %body + for all %start to %stop via %step %body + ..as: for % from %start to %stop via %step %body + parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body -compile [for %var in %iterable %body] to code: - %continue_labels = "" - if (tree %body has function call \(do next for-loop)): - %continue_labels join= "\n::continue_for::;" - if (tree %body has function call (tree \(do next %) with {""=%var})): - %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;" - # This trashes the loop variables, just like in Python. - %code = ".." - for i,value in ipairs(\(%iterable as lua)) do - \(%var as lua) = value; - \(%body as lua statements)\ - ..\%continue_labels - end --foreach-loop - %stop_labels = "" - if (tree %body has function call \(stop for-loop)): - %stop_labels join= "\n::stop_for::;" - if (tree %body has function call (tree \(stop %) with {""=%var})): - %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" - return (..) - ".." - do --for-loop label scope - \%code\%stop_labels - end --for-loop label scope - ..if %stop_labels != "" else %code -parse [for all %iterable %body] as: for % in %iterable %body +immediately: + compile [for %var in %iterable %body] to code: + %continue_labels = "" + if (tree %body has function call \(do next for-loop)): + %continue_labels join= "\n::continue_for::;" + if (tree %body has function call (tree \(do next %) with {""=%var})): + %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;" + # This trashes the loop variables, just like in Python. + %code = ".." + for i,value in ipairs(\(%iterable as lua)) do + \(%var as lua) = value; + \(%body as lua statements)\ + ..\%continue_labels + end --foreach-loop + %stop_labels = "" + if (tree %body has function call \(stop for-loop)): + %stop_labels join= "\n::stop_for::;" + if (tree %body has function call (tree \(stop %) with {""=%var})): + %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" + return (..) + ".." + do --for-loop label scope + \%code\%stop_labels + end --for-loop label scope + ..if %stop_labels != "" else %code + parse [for all %iterable %body] as: for % in %iterable %body # Dict iteration (lua's "pairs()") -compile [for %key = %value in %iterable %body] to code: - %continue_labels = "" - if (tree %body has function call \(do next for-loop)): - %continue_labels join= "\n::continue_for::;" - if (tree %body has function call (tree \(do next %x) with {x=%key})): - %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%key])::;" - if (tree %body has function call (tree \(do next %) with {""=%value})): - %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%value])::;" - # This trashes the loop variables, just like in Python. - %code = ".." - for key,value in ipairs(\(%iterable as lua)) do - \(%key as lua), \(%value as lua) = key, value; - \(%body as lua statements)\ - ..\%continue_labels - end --foreach-loop - %stop_labels = "" - if (tree %body has function call \(stop for-loop)): - %stop_labels join= "\n::stop_for::;" - if (tree %body has function call (tree \(stop %) with {""=%key})): - %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;" - if (tree %body has function call (tree \(stop %) with {""=%value})): - %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;" - return (..) - ".." - do --for-loop label scope - \%code\ - ..\%stop_labels - end --for-loop label scope - ..if %stop_labels != "" else %code +immediately: + compile [for %key = %value in %iterable %body] to code: + %continue_labels = "" + if (tree %body has function call \(do next for-loop)): + %continue_labels join= "\n::continue_for::;" + if (tree %body has function call (tree \(do next %x) with {x=%key})): + %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%key])::;" + if (tree %body has function call (tree \(do next %) with {""=%value})): + %continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%value])::;" + # This trashes the loop variables, just like in Python. + %code = ".." + for key,value in ipairs(\(%iterable as lua)) do + \(%key as lua), \(%value as lua) = key, value; + \(%body as lua statements)\ + ..\%continue_labels + end --foreach-loop + %stop_labels = "" + if (tree %body has function call \(stop for-loop)): + %stop_labels join= "\n::stop_for::;" + if (tree %body has function call (tree \(stop %) with {""=%key})): + %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;" + if (tree %body has function call (tree \(stop %) with {""=%value})): + %stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;" + return (..) + ".." + do --for-loop label scope + \%code\ + ..\%stop_labels + end --for-loop label scope + ..if %stop_labels != "" else %code # Switch statement/multi-branch if -compile [when %body] to code: - %result = "" - %fallthroughs = [] - %first = (yes) - for %func_call in (%body's "value"): - assert ((%func_call's "type") == "FunctionCall") ".." - Invalid format for 'when' statement. Only '*' blocks are allowed. - %tokens = (%func_call's "value") - %star = (%tokens -> 1) - assert (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") ".." - Invalid format for 'when' statement. Lines must begin with '*' - - %condition = (%tokens -> 2) - assert %condition ".." - Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" - - %action = (%tokens -> 3) - if (%action == (nil)): - lua do> "table.insert(\%fallthroughs, \%condition)" - do next %func_call - - if (=lua "\%condition.type == 'Word' and \%condition.value == 'else'"): - %result join= ".." - - else - \(%action as lua statements) - stop for-loop - ..else: - %condition = (%condition as lua) - for all %fallthroughs: - %condition join= " or \(% as lua)" - %result join= ".." - - \("if" if %first else "elseif") \%condition then - \(%action as lua statements) - +immediately: + compile [when %body] to code: + %result = "" %fallthroughs = [] - %first = (no) + %first = (yes) + for %func_call in (%body's "value"): + assert ((%func_call's "type") == "FunctionCall") ".." + Invalid format for 'when' statement. Only '*' blocks are allowed. + %tokens = (%func_call's "value") + %star = (%tokens -> 1) + assert (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") ".." + Invalid format for 'when' statement. Lines must begin with '*' - if (%result != ""): - %result join= "\nend" - return %result + %condition = (%tokens -> 2) + assert %condition ".." + Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" + + %action = (%tokens -> 3) + if (%action == (nil)): + lua do> "table.insert(\%fallthroughs, \%condition)" + do next %func_call + + if (=lua "\%condition.type == 'Word' and \%condition.value == 'else'"): + %result join= ".." + + else + \(%action as lua statements) + stop for-loop + ..else: + %condition = (%condition as lua) + for all %fallthroughs: + %condition join= " or \(% as lua)" + %result join= ".." + + \("if" if %first else "elseif") \%condition then + \(%action as lua statements) + + %fallthroughs = [] + %first = (no) + + if (%result != ""): + %result join= "\nend" + return %result # Switch statement -compile [when %branch_value == ? %body] to code: - %result = "" - %fallthroughs = [] - %first = (yes) - for %func_call in (%body's "value"): - assert ((%func_call's "type") == "FunctionCall") ".." - Invalid format for 'when' statement. Only '*' blocks are allowed. - %tokens = (%func_call's "value") - %star = (%tokens -> 1) - assert (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") ".." - Invalid format for 'when' statement. Lines must begin with '*' - - %condition = (%tokens -> 2) - assert %condition ".." - Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" - - %action = (%tokens -> 3) - if (%action == (nil)): - lua> "table.insert(\%fallthroughs, \%condition)" - do next %func_call - - if (=lua "\%condition.type == 'Word' and \%condition.value == 'else'"): - %result join= ".." - - else - \(%action as lua statements) - stop for-loop - ..else: - %condition = "branch_value == (\(%condition as lua))" - for all %fallthroughs: - %condition join= " or (branch_value == \(% as lua))" - %result join= ".." - - \("if" if %first else "elseif") \%condition then - \(%action as lua statements) - +immediately: + compile [when %branch_value == ? %body] to code: + %result = "" %fallthroughs = [] - %first = (no) + %first = (yes) + for %func_call in (%body's "value"): + assert ((%func_call's "type") == "FunctionCall") ".." + Invalid format for 'when' statement. Only '*' blocks are allowed. + %tokens = (%func_call's "value") + %star = (%tokens -> 1) + assert (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") ".." + Invalid format for 'when' statement. Lines must begin with '*' - if (%result != ""): - %result = ".." - do --when == ? - local branch_value = \(%branch_value as lua);\ - ..\%result - end - end --when == ? - return %result + %condition = (%tokens -> 2) + assert %condition ".." + Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" + + %action = (%tokens -> 3) + if (%action == (nil)): + lua> "table.insert(\%fallthroughs, \%condition)" + do next %func_call + + if (=lua "\%condition.type == 'Word' and \%condition.value == 'else'"): + %result join= ".." + + else + \(%action as lua statements) + stop for-loop + ..else: + %condition = "branch_value == (\(%condition as lua))" + for all %fallthroughs: + %condition join= " or (branch_value == \(% as lua))" + %result join= ".." + + \("if" if %first else "elseif") \%condition then + \(%action as lua statements) + + %fallthroughs = [] + %first = (no) + + if (%result != ""): + %result = ".." + do --when == ? + local branch_value = \(%branch_value as lua);\ + ..\%result + end + end --when == ? + return %result # Try/except -compile [..] - try %action and if it succeeds %success or if it fails %fallback - try %action and if it fails %fallback or if it succeeds %success -..to code: ".." - do - local fell_through = false; - local ok, ret1, ret2 = pcall(function(nomsu, vars) - \(%action as lua statements) - fell_through = true; - end, nomsu, vars); - if ok then - \(%success as lua statements) +immediately: + compile [..] + try %action and if it succeeds %success or if it fails %fallback + try %action and if it fails %fallback or if it succeeds %success + ..to code: ".." + do + local fell_through = false; + local ok, ret1, ret2 = pcall(function(nomsu, vars) + \(%action as lua statements) + fell_through = true; + end, nomsu, vars); + if ok then + \(%success as lua statements) + end + if not ok then + \(%fallback as lua statements) + elseif not fell_through then + return ret1, ret2; + end end - if not ok then - \(%fallback as lua statements) - elseif not fell_through then - return ret1, ret2; - end - end -parse [try %action] as: - try %action and if it succeeds: pass - ..or if it fails: pass -parse [try %action and if it fails %fallback] as: - try %action and if it succeeds: pass - ..or if it fails %fallback -parse [try %action and if it succeeds %success] as: - try %action and if it succeeds %success or if it fails: pass + parse [try %action] as: + try %action and if it succeeds: pass + ..or if it fails: pass + parse [try %action and if it fails %fallback] as: + try %action and if it succeeds: pass + ..or if it fails %fallback + parse [try %action and if it succeeds %success] as: + try %action and if it succeeds %success or if it fails: pass # Do/finally: -compile [do %action then always %final_action] to code: ".." - do - local fell_through = false; - local ok, ret1, ret2 = pcall(function(nomsu, vars) - \(%action as lua statements) - fell_through = true; - end, nomsu, vars); - local ok2, _ = pcall(function(nomsu, vars) - \(%final_action as lua statements) - end, nomsu, vars); - if not ok then nomsu:error(ret1); end - if not ok2 then nomsu:error(ret2); end - if not fell_through then - return ret1, ret2; +immediately: + compile [do %action then always %final_action] to code: ".." + do + local fell_through = false; + local ok, ret1, ret2 = pcall(function(nomsu, vars) + \(%action as lua statements) + fell_through = true; + end, nomsu, vars); + local ok2, _ = pcall(function(nomsu, vars) + \(%final_action as lua statements) + end, nomsu, vars); + if not ok then nomsu:error(ret1); end + if not ok2 then nomsu:error(ret2); end + if not fell_through then + return ret1, ret2; + end end - end diff --git a/lib/metaprogramming.nom b/lib/metaprogramming.nom index f59ce04..1477175 100644 --- a/lib/metaprogramming.nom +++ b/lib/metaprogramming.nom @@ -2,10 +2,60 @@ This File contains rules for making rules and macros and some helper functions to make that easier. -# Rule to make rules: +# Rule to make macros: immediately: lua> ".." - nomsu:defmacro("rule %signature = %body", (function(nomsu, vars) + nomsu:defmacro("compile %macro_def to %body", function(nomsu, vars) + nomsu:assert(\%macro_def.type == "List", + "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type)); + nomsu:assert(\%body.type == "Block", + "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type)); + local signature = {}; + for i, alias in ipairs(\%macro_def.value) do + signature[i] = alias.src; + end + local body_lua = nomsu:tree_to_lua(\%body); + body_lua = body_lua.statements or ("return "..body_lua.expr..";"); + local lua = ([[ + do + local function macro(nomsu, vars) + %s + end + local function macro_wrapper(...) return {expr=macro(...)}; end + 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))); + return {statements=lua}; + end, \(__src__ 1)); + + lua> ".." + nomsu:defmacro("compile %macro_def to code %body", function(nomsu, vars) + nomsu:assert(\%macro_def.type == "List", + "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type)); + nomsu:assert(\%body.type == "Block", + "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type)); + local signature = {}; + for i, alias in ipairs(\%macro_def.value) do + signature[i] = alias.src; + end + local body_lua = nomsu:tree_to_lua(\%body); + body_lua = body_lua.statements or ("return "..body_lua.expr..";"); + local lua = ([[ + do + local function macro(nomsu, vars) + %s + end + local function macro_wrapper(...) return {statements=macro(...)}; end + 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))); + return {statements=lua}; + end, \(__src__ 1)); + +compile [rand] to: "math.random()" + +# Rule to make rules: +immediately: + compile [rule %signature = %body] to code: + lua> ".." nomsu:assert(\%signature.type == "List", "Invalid type for rule definition signature. Expected List, but got: "..tostring(\%signature.type)); nomsu:assert(\%body.type == "Block", @@ -14,56 +64,14 @@ immediately: for i, alias in ipairs(\%signature.value) do signature[i] = alias.src; end - local src = nomsu:source_code(0); 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) - ]]):format(nomsu:repr(signature), fn_src, nomsu:repr(nomsu:dedent(src)))}; - end), \(__src__ 1)); - -# Rules to make lua macros: -immediately: - rule [compile \%macro_def to \%body] =: - lua> ".." - nomsu:assert(\%macro_def.type == "List", - "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type)); - nomsu:assert(\%body.type == "Block", - "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type)); - local signature = {}; - for i, alias in ipairs(\%macro_def.value) do - signature[i] = alias.src; - end - local body_lua = nomsu:tree_to_lua(\%body); - local fn_src = ([[ - function(nomsu, vars) + body_lua = body_lua.statements or ("return "..body_lua.expr..";"); + local src = nomsu:dedent(nomsu:source_code(0)); + local def_lua = ([[ + nomsu:def(%s, function(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] =: - lua> ".." - nomsu:assert(\%macro_def.type == "List", - "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type)); - nomsu:assert(\%body.type == "Block", - "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type)); - local signature = {}; - for i, alias in ipairs(\%macro_def.value) do - signature[i] = alias.src; - end - 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..";")); - 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)); + end, %s);]]):format(nomsu:repr(signature), body_lua, nomsu:repr(src)); + return def_lua; # Rule to make nomsu macros: immediately: diff --git a/nomsu.lua b/nomsu.lua index 39e83fc..1ae7349 100644 --- a/nomsu.lua +++ b/nomsu.lua @@ -142,8 +142,8 @@ do } setmetatable(defs, { __index = function(self, key) - local fn - fn = function(start, value, stop) + local make_node + make_node = function(start, value, stop) return { start = start, stop = stop, @@ -152,8 +152,8 @@ do type = key } end - self[key] = fn - return fn + self[key] = make_node + return make_node end }) local peg_tidier = re.compile([[ file <- {~ %nl* (def/comment) (%nl+ (def/comment))* %nl* ~} @@ -535,6 +535,7 @@ do self:assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type)) local lua = self:tree_to_lua(tree) local lua_code = lua.statements or (lua.expr .. ";") + lua_code = "-- File: " .. tostring(filename) .. "\n" .. lua_code local ret = self:run_lua(lua_code, vars) if max_operations then debug.sethook() @@ -571,6 +572,7 @@ end]]):format(lua_code)) end, tree_to_value = function(self, tree, vars, filename) local code = "return (function(nomsu, vars)\nreturn " .. tostring(self:tree_to_lua(tree, filename).expr) .. ";\nend);" + code = "-- Tree to value: " .. tostring(filename) .. "\n" .. code if self.debug then self:writeln(tostring(colored.bright("RUNNING LUA TO GET VALUE:")) .. "\n" .. tostring(colored.blue(colored.bright(code)))) end @@ -889,7 +891,7 @@ end]]):format(lua_code)) else local lua = self:tree_to_lua(arg, filename) 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 to " .. tostring(tree.stub) .. ", since it's not an expression.") end insert(args, lua.expr) end @@ -1319,9 +1321,10 @@ end]]):format(lua_code)) self:defmacro("immediately %block", function(self, vars) local lua = self:tree_to_lua(vars.block) local lua_code = lua.statements or (lua.expr .. ";") + lua_code = "-- Immediately:\n" .. lua_code self:run_lua(lua_code, vars) return { - statements = lua_code + statements = "" } end) self:defmacro("lua> %code", function(self, vars) diff --git a/nomsu.moon b/nomsu.moon index 03005bb..26bea8e 100755 --- a/nomsu.moon +++ b/nomsu.moon @@ -106,10 +106,10 @@ do return {type: "FunctionCall", :src, line_no: "#{ctx.filename}:#{line_no}", :value, :stub} setmetatable(defs, {__index:(key)=> - fn = (start, value, stop)-> + make_node = (start, value, stop)-> {:start, :stop, :value, src:ctx.source_code\sub(start,stop-1), type: key} - self[key] = fn - return fn + self[key] = make_node + return make_node }) -- Just for cleanliness, I put the language spec in its own file using a slightly modified @@ -346,6 +346,7 @@ class NomsuCompiler lua = @tree_to_lua(tree) lua_code = lua.statements or (lua.expr..";") + lua_code = "-- File: #{filename}\n"..lua_code ret = @run_lua(lua_code, vars) if max_operations debug.sethook! @@ -375,6 +376,7 @@ end]]\format(lua_code)) tree_to_value: (tree, vars, filename)=> code = "return (function(nomsu, vars)\nreturn #{@tree_to_lua(tree, filename).expr};\nend);" + code = "-- Tree to value: #{filename}\n"..code if @debug @writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}" lua_thunk, err = load(code) @@ -583,7 +585,7 @@ end]]\format(lua_code)) else lua = @tree_to_lua arg, filename 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 to #{tree.stub}, since it's not an expression." insert args, lua.expr arg_num += 1 @@ -835,8 +837,9 @@ end]]\format(lua_code)) @defmacro "immediately %block", (vars)=> lua = @tree_to_lua(vars.block) lua_code = lua.statements or (lua.expr..";") + lua_code = "-- Immediately:\n"..lua_code @run_lua(lua_code, vars) - return statements:lua_code + return statements:"" @defmacro "lua> %code", (vars)=> lua = nomsu_string_as_lua(@, vars.code)