Cleaned up metaprogramming to go "compile to" -> "rule =" -> "parse as".
This speeds things up a bit, and is more intuitive.
This commit is contained in:
Bruce Hill
parent
f97ab858ed
commit
421abe1a6f
@ -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
|
||||
|
||||
|
||||
@ -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:
|
||||
|
||||
15
nomsu.lua
15
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)
|
||||
|
||||
13
nomsu.moon
13
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)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user