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

Added implicit local declarations and new syntax of %var <- %value.

Browse Source
This commit is contained in:
Bruce Hill 2018-01-23 19:22:20 -08:00
parent 15dc0309c3
commit 6d11354b3f
7 changed files with 442 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
lib/class.nom
View File

@ -12,7 +12,7 @@ compile [@%var] to
end end
return "_me["..key_lua.."]"; return "_me["..key_lua.."]";
compile [set @%var = %val] to code compile [@%var <- %val] to code
lua> ".." lua> ".."
local val_lua = \(%val as lua); local val_lua = \(%val as lua);
local key_lua = repr(\%var.value); local key_lua = repr(\%var.value);
@ -26,11 +26,10 @@ compile [set @%var = %val] to code
return "_me["..key_lua.."] = "..val_lua..";"; return "_me["..key_lua.."] = "..val_lua..";";
compile [object %classname %class_body] to compile [object %classname %class_body] to
local [%methods, %class_identifier] %class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
set %class_identifier = (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
if: %class_identifier is "" if: %class_identifier is ""
set %class_identifier = "class" %class_identifier <- "class"
set %methods = [] %methods <- []
for %line in (%class_body's "value") for %line in (%class_body's "value")
if: (%line's "type") is "Comment" if: (%line's "type") is "Comment"
do next %line do next %line

6
lib/collections.nom
View File

@ -11,7 +11,7 @@ use "lib/operators.nom"
# Indexing # Indexing
parse [..] parse [..]
%index st in %list, %index nd in %list, %index rd in %list %index st in %list, %index nd in %list, %index rd in %list
%index th in %list, %index in %list %index th in %list
..as: %list -> %index ..as: %list -> %index
compile [..] compile [..]
%index st to last in %list, %index nd to last in %list, %index rd to last in %list %index st to last in %list, %index nd to last in %list, %index rd to last in %list
@ -51,7 +51,7 @@ compile [length of %list, size of %list, size %list, number of %list, len %list]
compile [%list ->* %indices] to compile [%list ->* %indices] to
assume ((%indices's "type") is "List") or barf ".." assume ((%indices's "type") is "List") or barf ".."
Expected List for chained lookup, not \(%indices's "type") Expected List for chained lookup, not \(%indices's "type")
set %ret = "\(%list as lua)" %ret <- "\(%list as lua)"
for %index in (%indices's "value") for %index in (%indices's "value")
%ret join= "[\(%index as lua)]" %ret join= "[\(%index as lua)]"
return "\%ret" return "\%ret"
@ -75,7 +75,7 @@ compile [remove index %index from %list] to
action [flatten %lists] action [flatten %lists]
set %flat = [] %flat <- []
for %list in %lists for %list in %lists
for %item in %list for %item in %list
add %item to %flat add %item to %flat

392
lib/control_flow.nom
View File

@ -40,10 +40,9 @@ immediately
%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
local %safe
#.. If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic #.. If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic
equivalent of a conditional expression: (cond and if_true or if_false) equivalent of a conditional expression: (cond and if_true or if_false)
if: {Text:yes, List:yes, Dict:yes, Number:yes}->(%when_true_expr's "type") if: (%when_true_expr's "type") in {Text:yes, List:yes, Dict:yes, Number:yes}
return "(\(%condition as lua) and \(%when_true_expr as lua) or \(%when_false_expr as lua))" return "(\(%condition as lua) and \(%when_true_expr as lua) or \(%when_false_expr as lua))"
..else ..else
#.. Otherwise, need to do an anonymous inline function (yuck, too bad lua #.. Otherwise, need to do an anonymous inline function (yuck, too bad lua
@ -58,9 +57,10 @@ immediately
end end
end)() end)()
# GOTOs # GOTOs
immediately immediately
compile [-> %label] to code ".." compile [=== %label ===, --- %label ---] to code ".."
::label_\(nomsu "var_to_lua_identifier" [%label])::; ::label_\(nomsu "var_to_lua_identifier" [%label])::;
compile [go to %label] to code ".." compile [go to %label] to code ".."
goto label_\(nomsu "var_to_lua_identifier" [%label]); goto label_\(nomsu "var_to_lua_identifier" [%label]);
@ -72,46 +72,77 @@ immediately
# Helper function # Helper function
immediately immediately
action [tree %tree has function call %call] compile [for subtree %subtree where %condition in %tree %body] to code ".."
lua> ".." for \(%subtree as lua) in coroutine.wrap(function() nomsu:walk_tree(\(%tree as lua)) end) do
local target = (\%call).stub; if type(\(%subtree as lua)) == 'table' and \(%subtree as lua).type then
for subtree,depth in coroutine.wrap(function() nomsu:walk_tree(\%tree); end) do if \(%condition as lua) then
if type(subtree) == 'table' and subtree.type == "FunctionCall" \(%body as lua statements)
and subtree.stub == target then end
return true;
end end
end end
return false;
# While loops # While loops
immediately immediately
compile [do next repeat-loop] to code "goto continue_repeat;" compile [do next repetition] to code "goto continue_repeat;"
compile [stop repeat-loop] to code "goto stop_repeat;" compile [stop repeating] to code "goto stop_repeat;"
compile [repeat while %condition %body] to code compile [repeat while %condition %body] to code
set %continue_labels = %continue_labels <- ""
"\n::continue_repeat::;" for subtree % where
..if (tree %body has function call \(do next repeat-loop)) else "" ((%'s "type") = "FunctionCall") and ((%'s "stub") == "do next repetition")
set %code = ".." ..in %body
%continue_labels <- "\n::continue_repeat::;"
stop
%code <- ".."
while \(%condition as lua) do while \(%condition as lua) do
\(%body as lua statements)\ \(%body as lua statements)\
..\%continue_labels ..\%continue_labels
end --while-loop end --while-loop
if: tree %body has function call \(stop repeat-loop) for subtree % where
return ".." ((%'s "type") = "FunctionCall") and ((%'s "stub") == "stop repeating")
do --while-loop label scope ..in %body
%code <- ".."
do -- scope of "stop repeating" label
\%code \%code
::stop_repeat::; ::stop_repeat::;
end --while-loop label scope end -- end of "stop repeating" label scope
%continue_labels <- "\n::continue_repeat::;"
stop
return %code return %code
parse [repeat %body] as: repeat while (yes) %body parse [repeat %body] as: repeat while (yes) %body
parse [repeat until %condition %body] as: repeat while (not %condition) %body parse [repeat until %condition %body] as: repeat while (not %condition) %body
compile [..]
repeat %n times %body
..to code
%continue_labels <- ""
for subtree % where
((%'s "type") = "FunctionCall") and ((%'s "stub") == "do next repetition")
..in %body
%continue_labels <- "\n::continue_repeat::;"
stop
# This trashes the loop variables, just like in Python.
%code <- ".."
for i=1,\(%n as lua) do
\(%body as lua statements)\
..\%continue_labels
end --numeric for-loop
%stop_labels <- ""
for subtree % where
((%'s "type") = "FunctionCall") and ((%'s "stub") == "stop repeating")
..in %body
%code <- ".."
do -- scope of "stop repeating" label
\%code
::stop_repeat::;
end -- end of "stop repeating" label scope
%continue_labels <- "\n::continue_repeat::;"
stop
return %code
# For loop control flow: # For loop control flow:
immediately immediately
compile [stop for-loop] to code "goto stop_for;"
compile [stop %var] to code ".." compile [stop %var] to code ".."
goto stop_\(nomsu "var_to_lua_identifier" [%var]); goto stop_\(nomsu "var_to_lua_identifier" [%var]);
compile [do next for-loop] to code "goto continue_for;"
compile [do next %var] to code ".." compile [do next %var] to code ".."
goto continue_\(nomsu "var_to_lua_identifier" [%var]); goto continue_\(nomsu "var_to_lua_identifier" [%var]);
@ -121,37 +152,42 @@ 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
local [%continue_labels, %code, %stop_labels, %loop_var, %loop_var_shim] %continue_labels <- ""
set %continue_labels = "" for subtree % where
if: tree %body has function call \(do next for-loop) ((%'s "type") = "FunctionCall") and
%continue_labels join= "\n::continue_for::;" ((%'s "stub") == "do next %") and
if: tree %body has function call (tree \(do next %) with {"":%var}) ((3rd in (%'s "value"))'s "src") == (%var's "src")
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;" ..in %body
%continue_labels <- "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
stop
if: (%var's "type") is "Var" if: (%var's "type") is "Var"
set %loop_var = (%var as lua) %loop_var <- (%var as lua)
set %loop_var_shim = "" %loop_var_shim <- ""
..else ..else
set %loop_var = "i" %loop_var <- "i"
set %loop_var_shim = "\n\(%var as lua) = i;" %loop_var_shim <- "\n\(%var as lua) = i;"
# This trashes the loop variables, just like in Python. # This trashes the loop variables, just like in Python.
set %code = ".." %code <- ".."
for \(%loop_var)=\(%start as lua),\(%stop as lua),\(%step as lua) do\ for \(%loop_var)=\(%start as lua),\(%stop as lua),\(%step as lua) do\
..\%loop_var_shim ..\%loop_var_shim
\(%body as lua statements)\ \(%body as lua statements)\
..\%continue_labels ..\%continue_labels
end --numeric for-loop end --numeric for-loop
set %stop_labels = ""
if: tree %body has function call \(stop for-loop) for subtree % where
%stop_labels join= "\n::stop_for::;" ((%'s "type") = "FunctionCall") and
if: tree %body has function call (tree \(stop %) with {"":%var}) ((%'s "stub") == "stop %") and
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" ((2nd in (%'s "value"))'s "src") == (%var's "src")
return ..in %body
".." %code <- ".."
do --for-loop label scope do -- scope for stopping for-loop
\%code\ \%code
..\%stop_labels ::stop_\(nomsu "var_to_lua_identifier" [%var])::;
end --for-loop label scope end -- end of scope for stopping for-loop
..if (%stop_labels is not "") else %code stop
return %code
immediately immediately
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
@ -161,206 +197,208 @@ immediately
..as: for % from %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 parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body
# For-each loop
immediately immediately
compile [for %var in %iterable %body] to code compile [for %var in %iterable %body] to code
local [%continue_labels, %code, %stop_labels, %loop_var, %loop_var_shim] %continue_labels <- ""
set %continue_labels = "" for subtree % where
if: tree %body has function call \(do next for-loop) ((%'s "type") = "FunctionCall") and
%continue_labels join= "\n::continue_for::;" ((%'s "stub") == "do next %") and
if: tree %body has function call (tree \(do next %) with {"":%var}) ((3rd in (%'s "value"))'s "src") == (%var's "src")
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;" ..in %body
%continue_labels <- "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
stop
if: (%var's "type") is "Var" if: (%var's "type") is "Var"
set %loop_var = (%var as lua) %loop_var <- (%var as lua)
set %loop_var_shim = "" %loop_var_shim <- ""
..else ..else
set %loop_var = "value" %loop_var <- "value"
set %loop_var_shim = "\n\(%var as lua) = value;" %loop_var_shim <- "\n\(%var as lua) = value;"
# This trashes the loop variables, just like in Python. # This trashes the loop variables, just like in Python.
set %code = ".." %code <- ".."
for i,\%loop_var in ipairs(\(%iterable as lua)) do\ for i,\%loop_var in ipairs(\(%iterable as lua)) do\
..\%loop_var_shim ..\%loop_var_shim
\(%body as lua statements)\ \(%body as lua statements)\
..\%continue_labels ..\%continue_labels
end --foreach-loop end --foreach-loop
set %stop_labels = "" for subtree % where
if: tree %body has function call \(stop for-loop) ((%'s "type") = "FunctionCall") and
%stop_labels join= "\n::stop_for::;" ((%'s "stub") == "stop %") and
if: tree %body has function call (tree \(stop %) with {"":%var}) ((2nd in (%'s "value"))'s "src") == (%var's "src")
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;" ..in %body
if: %stop_labels is not "" %code <- ".."
set %code = ".." do -- scope for stopping for-loop
do --for-loop label scope \%code
\%code\%stop_labels ::stop_\(nomsu "var_to_lua_identifier" [%var])::;
end --for-loop label scope end -- end of scope for stopping for-loop
stop
return %code return %code
parse [for all %iterable %body] as: for % in %iterable %body parse [for all %iterable %body] as: for % in %iterable %body
immediately
compile [..]
repeat %n times %body, repeat %n x %body
..to code
local [%continue_labels, %code, %stop_labels]
set %continue_labels = ""
if: tree %body has function call \(do next repeat-loop)
%continue_labels join= "\n::continue_repeat::;"
# This trashes the loop variables, just like in Python.
set %code = ".."
for i=1,\(%n as lua) do
\(%body as lua statements)\
..\%continue_labels
end --numeric for-loop
set %stop_labels = ""
if: tree %body has function call \(stop repeat-loop)
%stop_labels join= "\n::stop_repeat::;"
return
".."
do --repeat-loop label scope
\%code\
..\%stop_labels
end --repeat-loop label scope
..if (%stop_labels is not "") else %code
# Dict iteration (lua's "pairs()") # Dict iteration (lua's "pairs()")
immediately immediately
compile [for %key = %value in %iterable %body] to code compile [for %key = %value in %iterable %body] to code
local [..] %continue_labels <- ""
%continue_labels, %code, %stop_labels, %key_loop_var, %key_loop_var_shim, for subtree % where
%value_loop_var, %value_loop_var_shim ((%'s "type") = "FunctionCall") and
set %continue_labels = "" ((%'s "stub") == "do next %") and
if: tree %body has function call \(do next for-loop) ((3rd in (%'s "value"))'s "src") == (%key's "src")
%continue_labels join= "\n::continue_for::;" ..in %body
if: tree %body has function call (tree \(do next %) with {"":%key}) <- %continue_labels + "\n::continue_\(nomsu "var_to_lua_identifier" [%key])::;"
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%key])::;" stop
if: tree %body has function call (tree \(do next %) with {"":%value})
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%value])::;" for subtree % where
((%'s "type") = "FunctionCall") and
((%'s "stub") == "do next %") and
((3rd in (%'s "value"))'s "src") == (%value's "src")
..in %body
<- %continue_labels + "\n::continue_\(nomsu "var_to_lua_identifier" [%value])::;"
stop
if: (%key's "type") is "Var" if: (%key's "type") is "Var"
set %key_loop_var = (%key as lua) %key_loop_var <- (%key as lua)
set %key_loop_var_shim = "" %key_loop_var_shim <- ""
..else ..else
set %key_loop_var = "key" %key_loop_var <- "key"
set %key_loop_var_shim = "\n\(%key as lua) = key;" %key_loop_var_shim <- "\n\(%key as lua) = key;"
if: (%value's "type") is "Var" if: (%value's "type") is "Var"
set %value_loop_var = (%value as lua) %value_loop_var <- (%value as lua)
set %value_loop_var_shim = "" %value_loop_var_shim <- ""
..else ..else
set %value_loop_var = "value" %value_loop_var <- "value"
set %value_loop_var_shim = "\n\(%value as lua) = value;" %value_loop_var_shim <- "\n\(%value as lua) = value;"
# This trashes the loop variables, just like in Python. # This trashes the loop variables, just like in Python.
set %code = ".." %code <- ".."
for \%key_loop_var,\%value_loop_var in pairs(\(%iterable as lua)) do\ for \%key_loop_var,\%value_loop_var in pairs(\(%iterable as lua)) do\
..\%key_loop_var_shim\%value_loop_var_shim ..\%key_loop_var_shim\%value_loop_var_shim
\(%body as lua statements)\ \(%body as lua statements)\
..\%continue_labels ..\%continue_labels
end --foreach-loop end --foreach-loop
set %stop_labels = "" %stop_labels <- ""
if: tree %body has function call \(stop for-loop) for subtree % where
%stop_labels join= "\n::stop_for::;" ((%'s "type") = "FunctionCall") and
if: tree %body has function call (tree \(stop %) with {"":%key}) ((%'s "stub") == "stop %") and
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;" ((2nd in (%'s "value"))'s "src") == (%key's "src")
if: tree %body has function call (tree \(stop %) with {"":%value}) ..in %body
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;" <- %stop_labels + "\n::stop_\(nomsu "var_to_lua_identifier" [%key])::;"
return stop
".."
do --for-loop label scope for subtree % where
\%code\ ((%'s "type") = "FunctionCall") and
..\%stop_labels ((%'s "stub") == "stop %") and
end --for-loop label scope ((2nd in (%'s "value"))'s "src") == (%value's "src")
..if (%stop_labels is not "") else %code ..in %body
<- %stop_labels + "\n::stop_\(nomsu "var_to_lua_identifier" [%value])::;"
stop
if: %stop_labels is not ""
%code <- ".."
do -- scope for stopping for % = % loop
\%code\%stop_labels
end
return %code
# Switch statement/multi-branch if # Switch statement/multi-branch if
immediately immediately
compile [when %body] to code compile [when %body] to code
local [%result, %fallthroughs, %first] %result <- ""
set %result = "" %fallthroughs <- []
set %fallthroughs = [] %is_first <- (yes)
set %first = (yes)
for %func_call in (%body's "value") for %func_call in (%body's "value")
local [%tokens, %star, %condition, %action]
assume ((%func_call's "type") is "FunctionCall") or barf ".." assume ((%func_call's "type") is "FunctionCall") or barf ".."
Invalid format for 'when' statement. Only '*' blocks are allowed. Invalid format for 'when' statement. Only '*' blocks are allowed.
set %tokens = (%func_call's "value") with [..]
set %star = (%tokens -> 1) %tokens <- (%func_call's "value")
%star <- (1st in %tokens)
%condition <- (2nd in %tokens)
%action <- (3rd in %tokens)
..
assume (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") or barf ".." assume (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' Invalid format for 'when' statement. Lines must begin with '*'
set %condition = (%tokens -> 2)
assume %condition or barf ".." assume %condition or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else"
set %action = (%tokens -> 3)
if: %action is (nil) if: %action is (nil)
lua do> "table.insert(\%fallthroughs, \%condition)" lua do> "table.insert(\%fallthroughs, \%condition)"
do next %func_call do next %func_call
if: =lua "\%condition.type == 'Word' and \%condition.value == 'else'" if: =lua "\%condition.type == 'Word' and \%condition.value == 'else'"
%result join= ".."
<- %result + ".."
else else
\(%action as lua statements) \(%action as lua statements)
stop for-loop stop
..else ..else
set %condition = (%condition as lua) %condition <- (%condition as lua)
for all %fallthroughs for all %fallthroughs
%condition join= " or \(% as lua)" <- %condition + " or \(% as lua)"
%result join= ".." <- %result + ".."
\("if" if %first else "elseif") \%condition then \("if" if %is_first else "elseif") \%condition then
\(%action as lua statements) \(%action as lua statements)
set %fallthroughs = [] %fallthroughs <- []
set %first = (no) %is_first <- (no)
if: %result is not "" if: %result is not ""
%result join= "\nend" <- %result + "\nend"
return %result return %result
# Switch statement # Switch statement
immediately immediately
compile [when %branch_value = ? %body, when %branch_value is ? %body] to code compile [when %branch_value = ? %body, when %branch_value is ? %body] to code
set %result = "" %result <- ""
set %fallthroughs = [] %fallthroughs <- []
set %first = (yes) %is_first <- (yes)
%seen_else <- (no)
for %func_call in (%body's "value") for %func_call in (%body's "value")
assume ((%func_call's "type") is "FunctionCall") or barf ".." assume ((%func_call's "type") is "FunctionCall") or barf ".."
Invalid format for 'when' statement. Only '*' blocks are allowed. Invalid format for 'when' statement. Only '*' blocks are allowed.
set %tokens = (%func_call's "value") %tokens <- (%func_call's "value")
set %star = (%tokens -> 1) with [%star<-(1st in %tokens), %condition<-(2nd in %tokens), %action<-(3rd in %tokens)]
assume (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") or barf ".." assume (=lua "\%star and \%star.type == 'Word' and \%star.value == '*'") or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' Invalid format for 'when' statement. Lines must begin with '*'
set %condition = (%tokens -> 2)
assume %condition or barf ".." assume %condition or barf ".."
Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else"
set %action = (%tokens -> 3)
if: %action is (nil) if: %action is (nil)
lua> "table.insert(\%fallthroughs, \%condition)" lua> "table.insert(\%fallthroughs, \%condition)"
do next %func_call do next %func_call
if: =lua "\%condition.type == 'Word' and \%condition.value == 'else'" if: =lua "\%condition.type == 'Word' and \%condition.value == 'else'"
%result join= ".." assume (not %is_first) or barf "'else' clause cannot be first in 'when % = ?' block"
<- %result + ".."
else else
\(%action as lua statements) \(%action as lua statements)
stop for-loop end
%seen_else <- (yes)
..else ..else
set %condition = "branch_value == (\(%condition as lua))" assume (not %seen_else) or barf "'else' clause needs to be last in 'when % = ?' block"
%clause <- ""
if: ((%condition's "type") is "Text") or ((%condition's "type") is "Number")
%clause <- "branch_value == (\(%condition as lua))"
..else
%clause <- "utils.equivalent(branch_value, \(%condition as lua))"
for all %fallthroughs for all %fallthroughs
%condition join= " or (branch_value == \(% as lua))" if: ((%'s "type") is "Text") or ((%'s "type") is "Number")
%result join= ".." <- %clause + " or branch_value == (\(%condition as lua))"
..else
<- %clause + " or utils.equivalent(branch_value, \(%condition as lua))"
<- %result + ".."
\("if" if %first else "elseif") \%condition then \("if" if %is_first else "elseif") \%clause then
\(%action as lua statements) \(%action as lua statements)
set %fallthroughs = [] %fallthroughs <- []
set %first = (no) %is_first <- (no)
if: %result is not "" assume (%result is not "") or barf "No body for 'when % = ?' block!"
set %result = ".." unless %seen_else
<- %result + "\nend"
%result <- ".."
do --when % = ? do --when % = ?
local branch_value = \(%branch_value as lua);\ local branch_value = \(%branch_value as lua);\
..\%result ..\%result
end
end --when % = ? end --when % = ?
return %result return %result
@ -417,27 +455,3 @@ immediately
end end
end end
immediately
compile [with %assignments %action] to code
local [%lua, %olds, %old_vals, %new_vals]
set {%temp_vars:[], %old_vals:[], %new_vals:[]}
for %i=%assignment in (%assignments' "value")
set (%temp_vars->%i) = "temp\%i"
set (%old_vals->%i) = ((%assignment's "dict_key") as lua)
set (%new_vals->%i) = ((%assignment's "dict_value") as lua)
return ".."
do
local \(join %temp_vars with ", ") = \(join %old_vals with ", ");
\(join %old_vals with ", ") = \(join %new_vals with ", ");
local fell_through = false;
local ok, ret = pcall(function()
do
\(%action as lua statements)
end
fell_through = true;
end);
\(join %old_vals with ", ") = \(join %temp_vars with ", ");
if not ok then error(ret, 0); end
if not fell_through then return ret end
end

22
lib/metaprogramming.nom
View File

@ -21,7 +21,6 @@ immediately
return names, args; return names, args;
else else
local alias = nomsu:tree_to_value(spec); local alias = nomsu:tree_to_value(spec);
print("ALIAS!!! "..repr(alias).." from "..repr(spec));
local junk, arg_names, junk = nomsu:get_stub(alias); local junk, arg_names, junk = nomsu:get_stub(alias);
local args = {}; local args = {};
for i, a in ipairs(arg_names) do args[i] = nomsu:var_to_lua_identifier(a); end for i, a in ipairs(arg_names) do args[i] = nomsu:var_to_lua_identifier(a); end
@ -37,7 +36,10 @@ immediately
local names, args = nomsu:parse_spec(\%names); local names, args = nomsu:parse_spec(\%names);
names, args = repr(names), table.concat(args, ", "); names, args = repr(names), table.concat(args, ", ");
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..";"); local body_code = body_lua.statements or ("return "..body_lua.expr..";");
if body_lua.locals and #body_lua.locals > 0 then
body_code = "local "..table.concat(body_lua.locals, ", ")..";\\n"..body_code;
end
local lua = ([[ local lua = ([[
do do
local function compile_action(%s) local function compile_action(%s)
@ -45,7 +47,7 @@ immediately
end end
local function compile_action_wrapper(%s) return {expr=compile_action(%s)}; end local function compile_action_wrapper(%s) return {expr=compile_action(%s)}; end
nomsu:define_compile_action(%s, %s, compile_action_wrapper, %s); nomsu:define_compile_action(%s, %s, compile_action_wrapper, %s);
end]]):format(args, body_lua, args, args, names, repr(\%names:get_line_no()), end]]):format(args, body_code, args, args, names, repr(\%names:get_line_no()),
repr(("compile %s\\n..to %s"):format(\%names.src, \%body.src))); repr(("compile %s\\n..to %s"):format(\%names.src, \%body.src)));
return {statements=lua}; return {statements=lua};
end, \(__src__ 1)); end, \(__src__ 1));
@ -55,7 +57,10 @@ immediately
local names, args = nomsu:parse_spec(\%names); local names, args = nomsu:parse_spec(\%names);
names, args = repr(names), table.concat(args, ", "); names, args = repr(names), table.concat(args, ", ");
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..";"); local body_code = body_lua.statements or ("return "..body_lua.expr..";");
if body_lua.locals and #body_lua.locals > 0 then
body_code = "local "..table.concat(body_lua.locals, ", ")..";\\n"..body_code;
end
local lua = ([[ local lua = ([[
do do
local function compile_action(%s) local function compile_action(%s)
@ -63,7 +68,7 @@ immediately
end end
local function compile_action_wrapper(%s) return {statements=compile_action(%s)}; end local function compile_action_wrapper(%s) return {statements=compile_action(%s)}; end
nomsu:define_compile_action(%s, %s, compile_action_wrapper, %s); nomsu:define_compile_action(%s, %s, compile_action_wrapper, %s);
end]]):format(args, body_lua, args, args, names, repr(\%names:get_line_no()), end]]):format(args, body_code, args, args, names, repr(\%names:get_line_no()),
repr(("compile %s\\n..to code %s"):format(\%names.src, \%body.src))); repr(("compile %s\\n..to code %s"):format(\%names.src, \%body.src)));
return {statements=lua}; return {statements=lua};
end, \(__src__ 1)); end, \(__src__ 1));
@ -75,12 +80,15 @@ immediately
local names, args = nomsu:parse_spec(\%names); local names, args = nomsu:parse_spec(\%names);
names, args = repr(names), table.concat(args, ", "); names, args = repr(names), table.concat(args, ", ");
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..";"); local body_code = body_lua.statements or ("return "..body_lua.expr..";");
if body_lua.locals and #body_lua.locals > 0 then
body_code = "local "..table.concat(body_lua.locals, ", ")..";\\n"..body_code;
end
local src = nomsu:dedent(nomsu:source_code(0)); local src = nomsu:dedent(nomsu:source_code(0));
local def_lua = ([[ local def_lua = ([[
nomsu:define_action(%s, \(__line_no__), function(%s) nomsu:define_action(%s, \(__line_no__), function(%s)
%s %s
end, %s);]]):format(names, args, body_lua, repr(src)); end, %s);]]):format(names, args, body_code, repr(src));
return def_lua; return def_lua;
# Macro to make nomsu macros: # Macro to make nomsu macros:

90
lib/operators.nom
View File

@ -11,7 +11,10 @@ immediately
It's also critical to have parens around %obj, otherwise Lua is too dumb to It's also critical to have parens around %obj, otherwise Lua is too dumb to
realize that {x=1}["x"] is the same as ({x=1})["x"] or that realize that {x=1}["x"] is the same as ({x=1})["x"] or that
{x=1}.x is the same as ({x=1}).x {x=1}.x is the same as ({x=1}).x
compile [%obj'%key, %obj's %key, %obj -> %key] to compile [..]
%obj' %key, %obj's %key, %key in %obj, %key'th in %obj, %key of %obj,
%key st in %obj, %key nd in %obj, %key rd in %obj, %key th in %obj,
..to
lua> ".." lua> ".."
local obj_lua = \(%obj as lua); local obj_lua = \(%obj as lua);
if not obj_lua:sub(-1,-1):match("[a-zA-Z)]") then if not obj_lua:sub(-1,-1):match("[a-zA-Z)]") then
@ -56,36 +59,56 @@ immediately
# Variable assignment operator, and += type versions # Variable assignment operator, and += type versions
immediately immediately
compile [local %vars] to code
lua> ".." lua> ".."
local locals = \%vars.type == "List" and \%vars.value or {\%vars}; nomsu:define_compile_action("%var <- %value", \(__line_no__), function(\%var, \%value)
local identifiers = {}; local lua = {};
for i,x in ipairs(locals) do lua.statements = ("%s = %s;"):format(
identifiers[i] = nomsu:tree_to_lua(x).expr; assert(nomsu:tree_to_lua(\%var).expr, "Invalid target for assignment: "..\%var.src),
assert(nomsu:tree_to_lua(\%value).expr, "Invalid value for assignment: "..\%value.src));
if \%var.type == "Var" then
lua.locals = {nomsu:tree_to_lua(\%var).expr};
end end
return "local "..table.concat(identifiers, ", "); return lua;
compile [set %var = %val] to code "\(%var as lua) = \(%val as lua);" end, \(__src__ 1));
compile [set %assignments] to code
assume ((%assignments' "type") is "Dict") or barf "Expected Dict, but got \(%assignments' "type")"
lua> ".." lua> ".."
local lhs, rhs = {}, {}; nomsu:define_compile_action("with %assignments %body", \(__line_no__), function(\%assignments, \%body)
for i,entry in ipairs(\%assignments.value) do local body_lua = nomsu:tree_to_lua(\%body);
lhs[i] = nomsu:tree_to_lua(entry.dict_key).expr; local declarations = "";
rhs[i] = nomsu:tree_to_lua(entry.dict_value).expr; local leftover_locals = {};
for _, body_local in ipairs(body_lua.locals or {}) do
leftover_locals[body_local] = true;
end end
return table.concat(lhs, ", ").." = "..table.concat(rhs, ", ")..";"; assert(\%assignments.type == "List",
"Expected a List for the assignments part of 'with' statement, not "..\%assignments.src);
# Update assignment operators for i, item in ipairs(\%assignments.value) do
compile [%var += %val] to code "\(%var as lua) = \(%var as lua) + \(%val as lua);" if item.type == "Var" then
compile [%var -= %val] to code "\(%var as lua) = \(%var as lua) - \(%val as lua);" local var = nomsu:tree_to_lua(item).expr;
compile [%var *= %val] to code "\(%var as lua) = \(%var as lua) * \(%val as lua);" leftover_locals[var] = nil;
compile [%var /= %val] to code "\(%var as lua) = \(%var as lua) / \(%val as lua);" declarations = declarations.."local "..var..";\\n ";
compile [%var ^= %val] to code "\(%var as lua) = \(%var as lua) ^ \(%val as lua);" else
compile [%var and= %val] to code "\(%var as lua) = \(%var as lua) and\(%val as lua);" assert(item.type == "FunctionCall" and #item.value == 3 and item.value[2].src == "<-",
compile [%var or= %val] to code "\(%var as lua) = \(%var as lua) or \(%val as lua);" "'with' statement expects entries of the form: '%var <- %value', not: "..item.src);
compile [%var join= %val] to code "\(%var as lua) = \(%var as lua) .. \(%val as lua);" local target, value = item.value[1], item.value[3];
compile [wrap %var around %val] to code "\(%var as lua) = \(%var as lua) % \(%val as lua);" if target.type == "Var" then
local var = nomsu:tree_to_lua(target).expr;
leftover_locals[var] = nil;
declarations = declarations..(("local %s = %s;\\n "):format(
var, assert(nomsu:tree_to_lua(value).expr, "Invalid value for assignment: "..value.src)));
else
declarations = declarations..(("%s = %s;\\n "):format(
assert(nomsu:tree_to_lua(target).expr, "Invalid target for assignment: "..target.src),
assert(nomsu:tree_to_lua(value).expr, "Invalid value for assignment: "..value.src)));
end
end
end
local code = ([[
do
%s%s
end]]):format(declarations, body_lua.statements or (body_lua.expr..";"));
return {statements=code, locals=utils.keys(leftover_locals)};
end, \(__src__ 1));
immediately
# Math Operators # Math Operators
compile [%x + %y] to "(\(%x as lua) + \(%y as lua))" compile [%x + %y] to "(\(%x as lua) + \(%y as lua))"
compile [%x - %y] to "(\(%x as lua) - \(%y as lua))" compile [%x - %y] to "(\(%x as lua) - \(%y as lua))"
@ -121,5 +144,16 @@ compile [%x ARSHIFT %shift, %x >> %shift] to "bit32.arshift(\(%x as lua), \(%shi
# TODO: implement OR, XOR, AND for multiple operands? # TODO: implement OR, XOR, AND for multiple operands?
# Unary operators # Unary operators
compile [- %] to "-(\(% as lua))" compile [- %] to "(- \(% as lua))"
compile [not %] to "not (\(% as lua))" compile [not %] to "(not \(% as lua))"
# Update operators
immediately
parse [<- %var + %] as: %var <- (%var + %)
parse [<- %var - %] as: %var <- (%var - %)
parse [<- %var * %] as: %var <- (%var * %)
parse [<- %var / %] as: %var <- (%var / %)
parse [<- %var ^ %] as: %var <- (%var ^ %)
parse [<- %var and %] as: %var <- (%var and %)
parse [<- %var or %] as: %var <- (%var or %)
parse [wrap %var around %] as: "\(%var as lua) = \(%var as lua) % \(% as lua);"

78
nomsu.lua
View File

@ -21,6 +21,12 @@ do
local _obj_0 = table local _obj_0 = table
insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat
end end
do
local STRING_METATABLE = getmetatable("")
STRING_METATABLE.__add = function(self, other)
return self .. stringify(other)
end
end
lpeg.setmaxstack(10000) lpeg.setmaxstack(10000)
local P, R, V, S, Cg, C, Cp, B, Cmt local P, R, V, S, Cg, C, Cp, B, Cmt
P, R, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.R, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt P, R, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.R, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt
@ -416,6 +422,10 @@ do
assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type)) assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type))
local lua = self:tree_to_lua(tree) local lua = self:tree_to_lua(tree)
local lua_code = lua.statements or (lua.expr .. ";") local lua_code = lua.statements or (lua.expr .. ";")
local locals = lua_code.locals or { }
if #locals > 0 then
lua_code = "local " .. concat(locals, ", ") .. ";\n" .. lua_code
end
lua_code = "-- File: " .. tostring(filename) .. "\n" .. lua_code lua_code = "-- File: " .. tostring(filename) .. "\n" .. lua_code
local ret = self:run_lua(lua_code) local ret = self:run_lua(lua_code)
if max_operations then if max_operations then
@ -875,6 +885,7 @@ do
if #tree.value == 1 then if #tree.value == 1 then
return self:tree_to_lua(tree.value[1]) return self:tree_to_lua(tree.value[1])
end end
local declared_locals = { }
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
@ -883,10 +894,32 @@ do
if not lua then if not lua then
error("No lua produced by " .. tostring(repr(line))) error("No lua produced by " .. tostring(repr(line)))
end end
if lua.locals then
local new_locals
do
local _accum_0 = { }
local _len_0 = 1
local _list_1 = lua.locals
for _index_1 = 1, #_list_1 do
local l = _list_1[_index_1]
if not declared_locals[l] then
_accum_0[_len_0] = l
_len_0 = _len_0 + 1
end
end
new_locals = _accum_0
end
if #new_locals > 0 then
insert(lua_bits, "local " .. tostring(concat(new_locals, ", ")) .. ";")
for _index_1 = 1, #new_locals do
local l = new_locals[_index_1]
declared_locals[l] = true
end
end
end
if lua.statements then if lua.statements then
insert(lua_bits, lua.statements) insert(lua_bits, lua.statements)
end elseif lua.expr then
if lua.expr then
insert(lua_bits, tostring(lua.expr) .. ";") insert(lua_bits, tostring(lua.expr) .. ";")
end end
end end
@ -903,6 +936,7 @@ do
} }
elseif "Block" == _exp_0 then elseif "Block" == _exp_0 then
local lua_bits = { } local lua_bits = { }
local locals = { }
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]
@ -912,15 +946,22 @@ do
expr = lua.expr expr = lua.expr
} }
end end
if lua.locals then
local _list_1 = lua.locals
for _index_1 = 1, #_list_1 do
local l = _list_1[_index_1]
locals[l] = true
end
end
if lua.statements then if lua.statements then
insert(lua_bits, lua.statements) insert(lua_bits, lua.statements)
end elseif lua.expr then
if lua.expr then
insert(lua_bits, tostring(lua.expr) .. ";") insert(lua_bits, tostring(lua.expr) .. ";")
end end
end end
return { return {
statements = concat(lua_bits, "\n") statements = concat(lua_bits, "\n"),
locals = (next(locals) and utils.keys(locals) or nil)
} }
elseif "FunctionCall" == _exp_0 then elseif "FunctionCall" == _exp_0 then
insert(self.compilestack, tree) insert(self.compilestack, tree)
@ -981,7 +1022,7 @@ do
insert(bits, tok.value) insert(bits, tok.value)
else else
local lua = self:tree_to_lua(tok) local lua = self:tree_to_lua(tok)
assert(lua.statements == nil, "non-expression value inside math expression") assert(lua.expr, "non-expression value inside math expression: " .. tostring(tok.src))
insert(bits, lua.expr) insert(bits, lua.expr)
end end
end end
@ -1001,7 +1042,7 @@ do
break break
end end
local lua = self:tree_to_lua(tok) local lua = self:tree_to_lua(tok)
assert(lua.expr, "Cannot use " .. tostring(tok.src) .. " as an argument, since it's not an expression, it produces: " .. tostring(repr(lua))) assert(lua.expr, tostring(tree:get_line_no()) .. ": Cannot use:\n" .. tostring(colored.yellow(tok.src)) .. "\nas an argument to " .. tostring(tree.stub) .. ", since it's not an expression, it produces: " .. tostring(repr(lua)))
insert(args, lua.expr) insert(args, lua.expr)
_continue_0 = true _continue_0 = true
until true until true
@ -1051,9 +1092,7 @@ do
self:print_tree(bit) self:print_tree(bit)
self:writeln(tostring(colored.bright("EXPR:")) .. " " .. tostring(lua.expr) .. ", " .. tostring(colored.bright("STATEMENT:")) .. " " .. tostring(lua.statements)) self:writeln(tostring(colored.bright("EXPR:")) .. " " .. tostring(lua.expr) .. ", " .. tostring(colored.bright("STATEMENT:")) .. " " .. tostring(lua.statements))
end end
if lua.statements then assert(lua.expr, "Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
end
insert(concat_parts, "stringify(" .. tostring(lua.expr) .. ")") insert(concat_parts, "stringify(" .. tostring(lua.expr) .. ")")
_continue_0 = true _continue_0 = true
until true until true
@ -1083,9 +1122,7 @@ do
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 lua = self:tree_to_lua(item) local lua = self:tree_to_lua(item)
if lua.statements then assert(lua.expr, "Cannot use [[" .. tostring(item.src) .. "]] as a list item, since it's not an expression.")
error("Cannot use [[" .. tostring(item.src) .. "]] as a list item, since it's not an expression.")
end
insert(items, lua.expr) insert(items, lua.expr)
end end
return { return {
@ -1104,13 +1141,9 @@ do
else else
key_lua = self:tree_to_lua(entry.dict_key) key_lua = self:tree_to_lua(entry.dict_key)
end end
if key_lua.statements then assert(key_lua.expr, "Cannot use [[" .. tostring(entry.dict_key.src) .. "]] as a dict key, since it's not an expression.")
error("Cannot use [[" .. tostring(entry.dict_key.src) .. "]] as a dict key, since it's not an expression.")
end
local value_lua = self:tree_to_lua(entry.dict_value) local value_lua = self:tree_to_lua(entry.dict_value)
if value_lua.statements then assert(value_lua.expr, "Cannot use [[" .. tostring(entry.dict_value.src) .. "]] as a dict value, since it's not an expression.")
error("Cannot use [[" .. tostring(entry.dict_value.src) .. "]] as a dict value, since it's not an expression.")
end
local key_str = key_lua.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_lua.expr)) insert(items, tostring(key_str) .. "=" .. tostring(value_lua.expr))
@ -1338,9 +1371,7 @@ do
insert(concat_parts, bit) insert(concat_parts, bit)
else else
local lua = nomsu:tree_to_lua(bit) local lua = nomsu:tree_to_lua(bit)
if lua.statements then assert(lua.expr, "Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
end
insert(concat_parts, lua.expr) insert(concat_parts, lua.expr)
end end
end end
@ -1352,7 +1383,8 @@ do
lua_code = "-- Immediately:\n" .. lua_code lua_code = "-- Immediately:\n" .. lua_code
nomsu:run_lua(lua_code) nomsu:run_lua(lua_code)
return { return {
statements = lua_code statements = lua_code,
locals = lua.locals
} }
end) end)
self:define_compile_action("lua> %code", "nomsu.moon", function(_code) self:define_compile_action("lua> %code", "nomsu.moon", function(_code)

51
nomsu.moon
View File

@ -19,6 +19,12 @@ colors = setmetatable({}, {__index:->""})
colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..(msg or '')..colors.reset)}) colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..(msg or '')..colors.reset)})
{:insert, :remove, :concat} = table {:insert, :remove, :concat} = table
-- Use + operator for string coercive concatenation (note: "asdf" + 3 == "asdf3")
-- Note: This globally affects all strings in this instance of Lua!
do
STRING_METATABLE = getmetatable("")
STRING_METATABLE.__add = (other)=> @ .. stringify(other)
-- TODO: -- TODO:
-- consider non-linear codegen, rather than doing thunks for things like comprehensions -- consider non-linear codegen, rather than doing thunks for things like comprehensions
-- improve indentation of generated lua code -- improve indentation of generated lua code
@ -301,6 +307,9 @@ class NomsuCompiler
lua = @tree_to_lua(tree) lua = @tree_to_lua(tree)
lua_code = lua.statements or (lua.expr..";") lua_code = lua.statements or (lua.expr..";")
locals = lua_code.locals or {}
if #locals > 0
lua_code = "local "..concat(locals, ", ")..";\n"..lua_code
lua_code = "-- File: #{filename}\n"..lua_code lua_code = "-- File: #{filename}\n"..lua_code
ret = @run_lua(lua_code) ret = @run_lua(lua_code)
if max_operations if max_operations
@ -616,13 +625,19 @@ class NomsuCompiler
when "File" when "File"
if #tree.value == 1 if #tree.value == 1
return @tree_to_lua(tree.value[1]) return @tree_to_lua(tree.value[1])
declared_locals = {}
lua_bits = {} lua_bits = {}
for line in *tree.value for line in *tree.value
lua = @tree_to_lua line lua = @tree_to_lua line
if not lua if not lua
error "No lua produced by #{repr line}" error "No lua produced by #{repr line}"
if lua.locals
new_locals = [l for l in *lua.locals when not declared_locals[l]]
if #new_locals > 0
insert lua_bits, "local #{concat new_locals, ", "};"
for l in *new_locals do declared_locals[l] = true
if lua.statements then insert lua_bits, lua.statements if lua.statements then insert lua_bits, lua.statements
if lua.expr then insert lua_bits, "#{lua.expr};" elseif lua.expr then insert lua_bits, "#{lua.expr};"
return statements:concat(lua_bits, "\n") return statements:concat(lua_bits, "\n")
when "Comment" when "Comment"
@ -633,13 +648,16 @@ class NomsuCompiler
when "Block" when "Block"
lua_bits = {} lua_bits = {}
locals = {}
for arg in *tree.value for arg in *tree.value
lua = @tree_to_lua arg lua = @tree_to_lua arg
if #tree.value == 1 and lua.expr and not lua.statements if #tree.value == 1 and lua.expr and not lua.statements
return expr:lua.expr return expr:lua.expr
if lua.locals
for l in *lua.locals do locals[l] = true
if lua.statements then insert lua_bits, lua.statements if lua.statements then insert lua_bits, lua.statements
if lua.expr then insert lua_bits, "#{lua.expr};" elseif lua.expr then insert lua_bits, "#{lua.expr};"
return statements:concat(lua_bits, "\n") return statements:concat(lua_bits, "\n"), locals:(next(locals) and utils.keys(locals) or nil)
when "FunctionCall" when "FunctionCall"
insert @compilestack, tree insert @compilestack, tree
@ -668,7 +686,7 @@ class NomsuCompiler
insert bits, tok.value insert bits, tok.value
else else
lua = @tree_to_lua(tok) lua = @tree_to_lua(tok)
assert(lua.statements == nil, "non-expression value inside math expression") assert(lua.expr, "non-expression value inside math expression: #{tok.src}")
insert bits, lua.expr insert bits, lua.expr
remove @compilestack remove @compilestack
return expr:"(#{concat bits, " "})" return expr:"(#{concat bits, " "})"
@ -677,7 +695,8 @@ class NomsuCompiler
for tok in *tree.value for tok in *tree.value
if tok.type == "Word" then continue if tok.type == "Word" then continue
lua = @tree_to_lua(tok) lua = @tree_to_lua(tok)
assert(lua.expr, "Cannot use #{tok.src} as an argument, since it's not an expression, it produces: #{repr lua}") assert lua.expr,
"#{tree\get_line_no!}: Cannot use:\n#{colored.yellow tok.src}\nas an argument to #{tree.stub}, since it's not an expression, it produces: #{repr lua}"
insert args, lua.expr insert args, lua.expr
if metadata and metadata.arg_orders if metadata and metadata.arg_orders
@ -702,8 +721,8 @@ class NomsuCompiler
@writeln (colored.bright "INTERP:") @writeln (colored.bright "INTERP:")
@print_tree bit @print_tree bit
@writeln "#{colored.bright "EXPR:"} #{lua.expr}, #{colored.bright "STATEMENT:"} #{lua.statements}" @writeln "#{colored.bright "EXPR:"} #{lua.expr}, #{colored.bright "STATEMENT:"} #{lua.statements}"
if lua.statements assert lua.expr,
error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression." "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
insert concat_parts, "stringify(#{lua.expr})" insert concat_parts, "stringify(#{lua.expr})"
if string_buffer ~= "" if string_buffer ~= ""
@ -719,8 +738,8 @@ class NomsuCompiler
items = {} items = {}
for item in *tree.value for item in *tree.value
lua = @tree_to_lua item lua = @tree_to_lua item
if lua.statements assert lua.expr,
error "Cannot use [[#{item.src}]] as a list item, since it's not an expression." "Cannot use [[#{item.src}]] as a list item, since it's not an expression."
insert items, lua.expr insert items, lua.expr
return expr:@@comma_separated_items("{", items, "}") return expr:@@comma_separated_items("{", items, "}")
@ -731,11 +750,11 @@ class NomsuCompiler
{expr:repr(entry.dict_key.value)} {expr:repr(entry.dict_key.value)}
else else
@tree_to_lua entry.dict_key @tree_to_lua entry.dict_key
if key_lua.statements assert key_lua.expr,
error "Cannot use [[#{entry.dict_key.src}]] as a dict key, since it's not an expression." "Cannot use [[#{entry.dict_key.src}]] as a dict key, since it's not an expression."
value_lua = @tree_to_lua entry.dict_value value_lua = @tree_to_lua entry.dict_value
if value_lua.statements assert value_lua.expr,
error "Cannot use [[#{entry.dict_value.src}]] as a dict value, since it's not an expression." "Cannot use [[#{entry.dict_value.src}]] as a dict value, since it's not an expression."
key_str = key_lua.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_lua.expr}" insert items, "#{key_str}=#{value_lua.expr}"
@ -888,8 +907,8 @@ class NomsuCompiler
insert concat_parts, bit insert concat_parts, bit
else else
lua = nomsu\tree_to_lua bit lua = nomsu\tree_to_lua bit
if lua.statements assert lua.expr,
error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression." "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
insert concat_parts, lua.expr insert concat_parts, lua.expr
return concat(concat_parts) return concat(concat_parts)
@ -898,7 +917,7 @@ class NomsuCompiler
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
nomsu\run_lua(lua_code) nomsu\run_lua(lua_code)
return statements:lua_code return statements:lua_code, locals:lua.locals
@define_compile_action "lua> %code", "nomsu.moon", (_code)-> @define_compile_action "lua> %code", "nomsu.moon", (_code)->
lua = nomsu_string_as_lua(_code) lua = nomsu_string_as_lua(_code)