Making forward progress.
This commit is contained in:
Bruce Hill
parent
02def0af92
commit
10d61df78b
@ -3,137 +3,99 @@ require "lib/operators.nom"
|
||||
require "lib/utils.nom"
|
||||
|
||||
# Conditionals
|
||||
macro statement [if %condition %if_body] =:
|
||||
".."|if \%condition as lua\ then
|
||||
| \(lua expr "vars.if_body.value") as lua\
|
||||
|end
|
||||
parse (if %condition %if_body) as lua code ".."
|
||||
|if \(%condition) then
|
||||
| \(lua expr "vars.if_body.value")
|
||||
|end
|
||||
|
||||
macro statement [if %condition %if_body else %else_body] =:
|
||||
".."|if \%condition as lua\ then
|
||||
| \(lua expr "vars.if_body.value") as lua\
|
||||
|else
|
||||
| \(lua expr "vars.else_body.value") as lua\
|
||||
|end
|
||||
parse (if %condition %if_body else %else_body) as lua code ".."
|
||||
|if \(%condition) then
|
||||
| \(lua expr "vars.if_body.value")
|
||||
|else
|
||||
| \(lua expr "vars.else_body.value")
|
||||
|end
|
||||
|
||||
# Return
|
||||
macro statement [return] =: "do return end"
|
||||
macro block [return %return-value] =: ".."
|
||||
|return \%return-value as lua\
|
||||
|
||||
macro [do %action] =: ".."
|
||||
|(\%action as lua\)(nomsu, setmetatable({}, {__index=vars}))
|
||||
parse (return) as lua code "do return end"
|
||||
parse (return %return-value) as lua code "do return \(%return-value)"
|
||||
parse (do %action) as lua expr ".."
|
||||
|(\(%action))(nomsu, setmetatable({}, {__index=vars}))
|
||||
|
||||
|
||||
# GOTOs
|
||||
macro statement [-> %label] =: ".."
|
||||
|::label_\nomsu "var_to_lua_identifier" [%label]\::
|
||||
macro statement [go to %label] =: ".."
|
||||
|goto label_\nomsu "var_to_lua_identifier" [%label]\
|
||||
parse (-> %label) as lua code ".."
|
||||
|::label_\(nomsu "var_to_lua_identifier" [%label])::
|
||||
parse (go to %label) as lua code ".."
|
||||
|goto label_\(nomsu "var_to_lua_identifier" [%label])
|
||||
|
||||
# Loop control flow
|
||||
macro statement [stop, stop loop, break] =: "break"
|
||||
macro statement [stop for, stop for-loop, break for] =: "goto break_for"
|
||||
macro statement [stop repeat, stop repeat-loop, break repeat] =: "goto break_repeat"
|
||||
macro statement [stop %var, break %var] =: ".."
|
||||
|goto break_\nomsu "var_to_lua_identifier" [%var]\
|
||||
parse (stop; stop loop; break) as lua code "break"
|
||||
parse (stop for; stop for-loop; break for) as lua code "goto break_for"
|
||||
parse (stop repeat; stop repeat-loop; break repeat) as lua code "goto break_repeat"
|
||||
parse (stop %var; break %var) as lua code ".."
|
||||
|goto break_\(nomsu "var_to_lua_identifier" [%var])
|
||||
|
||||
macro statement [continue, continue loop] =: "continue"
|
||||
macro statement [continue for, continue for-loop] =: "goto continue_for"
|
||||
macro statement [continue repeat, continue repeat-loop] =: "goto continue_repeat"
|
||||
macro statement [continue %var, go to next %var, on to the next %var] =: ".."
|
||||
|goto continue_\nomsu "var_to_lua_identifier" [%var]\
|
||||
parse (continue; continue loop) as lua code "continue"
|
||||
parse (continue for; continue for-loop) as lua code "goto continue_for"
|
||||
parse (continue repeat; continue repeat-loop) as lua code "goto continue_repeat"
|
||||
parse (continue %var; go to next %var; on to the next %var) as lua code ".."
|
||||
|goto continue_\(nomsu "var_to_lua_identifier" [%var])
|
||||
|
||||
# While loops
|
||||
macro block [repeat %body] =:
|
||||
".."|while true do
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_repeat::
|
||||
|end
|
||||
|::break_repeat::
|
||||
macro block [repeat while %condition %body] =:
|
||||
".."|while \%condition as lua\ do
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_repeat::
|
||||
|end
|
||||
|::break_repeat::
|
||||
macro block [repeat until %condition %body] =:
|
||||
".."|while not (\%condition as lua\) do
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_repeat::
|
||||
|end
|
||||
|::break_repeat::
|
||||
parse (repeat %body) as lua block ".."
|
||||
|while true do
|
||||
| \(lua expr "vars.body.value")
|
||||
| ::continue_repeat::
|
||||
|end
|
||||
|::break_repeat::
|
||||
parse (repeat while %condition %body) as lua block ".."
|
||||
|while \(%condition) do
|
||||
| \(lua expr "vars.body.value")
|
||||
| ::continue_repeat::
|
||||
|end
|
||||
|::break_repeat::
|
||||
parse (repeat until %condition %body) as lua block ".."
|
||||
|while not (\(%condition)) do
|
||||
| \(lua expr "vars.body.value")
|
||||
| ::continue_repeat::
|
||||
|end
|
||||
|::break_repeat::
|
||||
|
||||
# Numeric range for loops
|
||||
macro block [for %var from %start to %stop by %step %body] =:
|
||||
%var-type =: lua expr "vars.var.type"
|
||||
assert (%var-type == "Var") ".."
|
||||
|For loop has the wrong type for the loop variable. Expected Var, but got: \%var-type\
|
||||
parse:
|
||||
for %var from %start to %stop by %step %body
|
||||
for %var from %start to %stop via %step %body
|
||||
..as lua block ".."
|
||||
|for i=\(%start),\(%stop),\(%step) do
|
||||
# This trashes the loop variables, just like in Python.
|
||||
".."
|
||||
|for i=\%start as lua\,\%stop as lua\,\%step as lua\ do
|
||||
| \%var as lua\ = i
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_for::
|
||||
| ::continue_\nomsu "var_to_lua_identifier" [%var]\::
|
||||
|end
|
||||
|::break_for::
|
||||
|::break_\nomsu "var_to_lua_identifier" [%var]\::
|
||||
macro block [for %var from %start to %stop %body] =:
|
||||
%thunk =: :for %var from %start to %stop by 1 %body
|
||||
lua block ".."
|
||||
|for i,x in ipairs(vars.thunk.value) do
|
||||
| if x.type == 'Var' then vars.thunk.type == vars[x.value] end
|
||||
|end
|
||||
|return compiler:run_macro(vars.thunk, 'Statement')
|
||||
| \(%var) = i
|
||||
| \(lua expr "vars.body.value")
|
||||
| ::continue_for::
|
||||
| ::continue_\(nomsu "var_to_lua_identifier" [%var])::
|
||||
|end
|
||||
|::break_for::
|
||||
|::break_\(nomsu "var_to_lua_identifier" [%var])::
|
||||
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
|
||||
|
||||
macro block [for all %start to %stop by %step %body] =:
|
||||
parse (for %var in %iterable %body) as lua block ".."
|
||||
|for i,value in ipairs(\(%iterable)) do
|
||||
# This trashes the loop variables, just like in Python.
|
||||
".."
|
||||
|for i=\%start as lua\,\%stop as lua\,\%step as lua\ do
|
||||
| vars[''] = i
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_for::
|
||||
| ::continue_\nomsu "var_to_lua_identifier" [%]\::
|
||||
|end
|
||||
|::break_for::
|
||||
|::break_\nomsu "var_to_lua_identifier" [%]\::
|
||||
macro block [for %var from %start to %stop %body] =:
|
||||
%thunk =: :for %var from %start to %stop by 1 %body
|
||||
lua block ".."
|
||||
|for i,x in ipairs(vars.thunk.value) do
|
||||
| if x.type == 'Var' then vars.thunk.type == vars[x.value] end
|
||||
|end
|
||||
|return compiler:run_macro(vars.thunk, 'Statement')
|
||||
|
||||
macro block [for %var in %iterable %body] =:
|
||||
%var-type =: lua expr "vars.var.type"
|
||||
assert (%var-type == "Var") ".."
|
||||
|For loop has the wrong type for the loop variable. Expected Var, but got: \%var-type\
|
||||
# This trashes the loop variables, just like in Python.
|
||||
".."
|
||||
|for i,value in ipairs(\%iterable as lua\) do
|
||||
| \%var as lua\ = value
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_for::
|
||||
| ::continue_\nomsu "var_to_lua_identifier" [%var]\::
|
||||
|end
|
||||
|::break_for::
|
||||
|::break_\nomsu "var_to_lua_identifier" [%var]\::
|
||||
|
||||
macro block [for all %iterable %body] =:
|
||||
pass # TODO: fix compiler bug
|
||||
# This trashes the loop variables, just like in Python.
|
||||
".."|for i,value in ipairs(\%iterable as lua\) do
|
||||
| vars[''] = value
|
||||
| \(lua expr "vars.body.value") as lua\
|
||||
| ::continue_for::
|
||||
| ::continue_\nomsu "var_to_lua_identifier" [%]\::
|
||||
|end
|
||||
|::break_for::
|
||||
|::break_\nomsu "var_to_lua_identifier" [%]\::
|
||||
| \(%var) = value
|
||||
| \(lua expr "vars.body.value")
|
||||
| ::continue_for::
|
||||
| ::continue_\(nomsu "var_to_lua_identifier" [%var])::
|
||||
|end
|
||||
|::break_for::
|
||||
|::break_\(nomsu "var_to_lua_identifier" [%var])::
|
||||
parse (for all %iterable %body) as: for % in %iterable %body
|
||||
|
||||
# Switch statement/multi-branch if
|
||||
macro block [when %body] =:
|
||||
parse (when %body) as lua block:
|
||||
%result =: ""
|
||||
%fallthroughs =: []
|
||||
for %statement in (lua expr "vars.body.value.value"):
|
||||
@ -156,15 +118,18 @@ macro block [when %body] =:
|
||||
go to next %statement
|
||||
|
||||
if (lua expr "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
|
||||
%result join=: ".."|
|
||||
%result join=: ".."
|
||||
|
|
||||
|do
|
||||
..else:
|
||||
%condition =: %condition as lua
|
||||
for all %fallthroughs: %condition join=: ".."| or \% as lua\
|
||||
%result join=: ".."|
|
||||
|if \%condition\ then
|
||||
%result join=: ".."|
|
||||
| \(lua expr "vars.thunk.value") as lua\
|
||||
for all %fallthroughs: %condition join= " or \(%)"
|
||||
%result join=: ".."
|
||||
|
|
||||
|if \(%condition) then
|
||||
%result join=: ".."
|
||||
|
|
||||
| \(lua expr "vars.thunk.value")
|
||||
| goto finished_when
|
||||
|end
|
||||
|
||||
@ -174,8 +139,8 @@ macro block [when %body] =:
|
||||
%result
|
||||
|
||||
# Switch statement
|
||||
macro block [when %branch-value == ? %body] =:
|
||||
%result =: ".."|local branch_value = \%branch-value as lua\
|
||||
parse (when %branch-value == ? %body) as lua block:
|
||||
%result =: "local branch_value = \(%branch-value)"
|
||||
%fallthroughs =: []
|
||||
for %statement in (lua expr "vars.body.value.value"):
|
||||
%func-call =: lua expr "vars.statement.value"
|
||||
@ -197,15 +162,18 @@ macro block [when %branch-value == ? %body] =:
|
||||
go to next %statement
|
||||
|
||||
if (lua expr "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
|
||||
%result join=: ".."|
|
||||
%result join=: ".."
|
||||
|
|
||||
|do
|
||||
..else:
|
||||
%condition =: ".."|branch_value == (\%condition as lua\)
|
||||
for all %fallthroughs: %condition join=: ".."| or (branch_value == \% as lua\)
|
||||
%result join=: ".."|
|
||||
%condition =: "branch_value == (\(%condition))"
|
||||
for all %fallthroughs: %condition join= " or (branch_value == \(%))"
|
||||
%result join=: ".."
|
||||
|
|
||||
|if \%condition\ then
|
||||
%result join=: ".."|
|
||||
| \(lua expr "vars.thunk.value") as lua\
|
||||
%result join=: ".."
|
||||
|
|
||||
| \((lua expr "vars.thunk.value"))
|
||||
| goto finished_when
|
||||
|end
|
||||
|
||||
@ -213,4 +181,3 @@ macro block [when %branch-value == ? %body] =:
|
||||
|
||||
%result join=: "\n::finished_when::"
|
||||
%result
|
||||
|
||||
|
||||
@ -27,7 +27,6 @@ lua code ".."
|
||||
|end
|
||||
|nomsu:def("parse nomsu %shorthand as nomsu %longhand", parse_as)
|
||||
parse nomsu \(parse %shorthand as %longhand) as nomsu \(parse nomsu \%shorthand as nomsu \%longhand)
|
||||
parse (foo %x) as (baz %x)
|
||||
|
||||
lua code ".."
|
||||
|nomsu:defmacro("lua expr %code", function(nomsu, vars)
|
||||
@ -71,17 +70,12 @@ parse (lua block %block) as:
|
||||
|
||||
parse (nomsu) as: lua expr "nomsu"
|
||||
parse (nomsu's %key) as:
|
||||
lua expr "nomsu[\(%key as lua)]"
|
||||
lua expr "nomsu['\(%key)']"
|
||||
parse (nomsu %method %args) as:
|
||||
lua block ".."
|
||||
|local args = {"nomsu"}
|
||||
|for _,arg in ipairs(vars.args.value) do
|
||||
| table.insert(args, nomsu:tree_to_lua(arg))
|
||||
|end
|
||||
|local method_name = nomsu:repr(nomsu:tree_to_value(vars.method, vars))
|
||||
..with value ".."
|
||||
|("nomsu[%s](%s)"):format(method_name, table.concat(args, ", "))
|
||||
lua expr "nomsu['\(%method)'](nomsu, unpack(\(%args)))"
|
||||
parse (repr %) as: nomsu "repr" [%]
|
||||
repr 5
|
||||
|
||||
|
||||
# Get the source code for a function
|
||||
rule (help %rule) =:
|
||||
@ -111,3 +105,18 @@ parse (source code %body) as: source code from tree \%body
|
||||
|
||||
parse (parse tree %code) as: repr (nomsu "tree_to_str" [\%code])
|
||||
|
||||
parse (parse %code as lua code %lua) as:
|
||||
parse nomsu \%code as nomsu:
|
||||
nomsu "replaced_vars" [\(lua code %lua), lua expr "vars"]
|
||||
|
||||
parse (parse %code as lua expr %lua) as:
|
||||
parse nomsu \%code as nomsu:
|
||||
nomsu "replaced_vars" [\(lua expr %lua), lua expr "vars"]
|
||||
|
||||
parse (parse %code as lua block %lua) as:
|
||||
parse nomsu \%code as nomsu:
|
||||
nomsu "replaced_vars" [\(lua block %lua), lua expr "vars"]
|
||||
|
||||
parse (pass) as lua code: ""
|
||||
|
||||
pass
|
||||
|
||||
@ -1,25 +1,25 @@
|
||||
require "lib/metaprogramming.nom"
|
||||
|
||||
# Literals
|
||||
macro [true, yes] =: "true"
|
||||
macro [false, no] =: "false"
|
||||
macro [nil, null] =: "nil"
|
||||
macro [inf, infinity] =: "math.huge"
|
||||
macro [nan, NaN, not a number] =: "(0/0)"
|
||||
macro statement [nop, pass] =: ""
|
||||
parse (true; yes) as lua expr "true"
|
||||
parse (false; no) as lua expr "false"
|
||||
parse (nil; null) as lua expr "nil"
|
||||
parse (inf; infinity) as lua expr "math.huge"
|
||||
parse (nan; NaN; not a number) as lua expr "(0/0)"
|
||||
parse (nop; pass) as lua code ""
|
||||
|
||||
# Ternary operator
|
||||
macro [%if_expr if %condition else %else_expr] =:
|
||||
pass # TODO: Fix compiler bug that doesn't parse right here
|
||||
parse (%if_expr if %condition else %else_expr) as lua expr ".."
|
||||
|(function(nomsu, vars)
|
||||
# TODO: fix compiler bug that breaks this code if comments immediately follow ".."
|
||||
#.. Note: this uses a function instead of (condition and if_expr or else_expr)
|
||||
because that breaks if %if_expr is falsey.
|
||||
".."|(function(nomsu, vars)
|
||||
| if \%condition as lua\ then
|
||||
| return \%if_expr as lua\
|
||||
| else
|
||||
| return \%else_expr as lua\
|
||||
| end
|
||||
|end)(nomsu, vars)
|
||||
| if \(%condition) then
|
||||
| return \(%if_expr)
|
||||
| else
|
||||
| return \(%else_expr)
|
||||
| end
|
||||
|end)(nomsu, vars)
|
||||
|
||||
# Variable assignment operator, and += type versions
|
||||
lua block ".."
|
||||
@ -64,11 +64,11 @@ lua block ".."
|
||||
| end
|
||||
| nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars, kind)
|
||||
| return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")"
|
||||
| end), [[".."|(\\%a as lua\\ ]]..op..[[ \\%b as lua\\)]])
|
||||
| end), [["(\\(%a) ]]..op..[[ \\(%b))"]])
|
||||
|end
|
||||
# == and != do equivalence checking, rather than identity checking
|
||||
macro [%a == %b] =: ".."|nomsu.utils.equivalent(\%a as lua\, \%b as lua\)
|
||||
macro [%a != %b] =: ".."|(not nomsu.utils.equivalent(\%a as lua\, \%b as lua\))
|
||||
parse (%a == %b) as lua expr "nomsu.utils.equivalent(\(%a), \(%b))"
|
||||
parse (%a != %b) as lua expr "(not nomsu.utils.equivalent(\(%a), \(%b)))"
|
||||
|
||||
# Commutative Operators defined for up to 8 operands
|
||||
# TODO: work out solution for commutative operators using more clever macros
|
||||
@ -125,5 +125,5 @@ lua block ".."
|
||||
|end
|
||||
|
||||
# Unary operators
|
||||
macro [- %a] =: ".."|-(\%a as lua\)
|
||||
macro [not %a] =: ".."|not (\%a as lua\)
|
||||
parse (- %a) as lua expr "-(\(%a))"
|
||||
parse (not %a) as lua expr "not (\(%a))"
|
||||
|
||||
@ -1,73 +1,66 @@
|
||||
require "lib/metaprogramming.nom"
|
||||
|
||||
# Error functions
|
||||
rule [error!, panic!, fail!, abort!] =:
|
||||
nomsu "error"[]
|
||||
rule [error %msg] =:
|
||||
rule (error!; panic!; fail!; abort!) =:
|
||||
nomsu "error" []
|
||||
rule (error %msg) =:
|
||||
nomsu "error"[%msg]
|
||||
macro statement [assert %condition] =: ".."
|
||||
|if not (\%condition as lua\) then
|
||||
parse (assert %condition) as: lua code ".."
|
||||
|if not (\(%condition)) then
|
||||
| nomsu:error()
|
||||
|end
|
||||
macro statement [assert %condition %msg] =: ".."
|
||||
|if not (\%condition as lua\) then
|
||||
| nomsu:error(\%msg as lua\)
|
||||
parse (assert %condition %msg) as: lua code ".."
|
||||
|if not (\(%condition)) then
|
||||
| nomsu:error(\(%msg))
|
||||
|end
|
||||
|
||||
macro statement [show generated lua %block] =: ".."
|
||||
|nomsu:writeln(\lua expr "nomsu:repr(nomsu:tree_to_lua(vars.block.value))"\)
|
||||
parse (show generated lua %block) as: lua code ".."
|
||||
|nomsu:writeln(\(repr (nomsu "tree_to_lua" [%block])))
|
||||
|
||||
|
||||
# String functions
|
||||
rule [join %strs] =:
|
||||
rule (join %strs) =:
|
||||
lua block ".."
|
||||
|local str_bits = {}
|
||||
|for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu.utils.repr_if_not_string(bit) end
|
||||
|return table.concat(str_bits)
|
||||
|
||||
rule [join %strs with glue %glue] =:
|
||||
rule (join %strs with glue %glue) =:
|
||||
lua block ".."
|
||||
|local str_bits = {}
|
||||
|for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu.utils.repr_if_not_string(bit) end
|
||||
|return table.concat(str_bits, vars.glue)
|
||||
|
||||
macro [capitalize %str, %str capitalized] =: ".."
|
||||
|(\%str as lua\):gsub("%l", string.upper, 1)
|
||||
parse (capitalize %str; %str capitalized) as: lua expr "(\(%str)):gsub('%l', string.upper, 1)"
|
||||
|
||||
macro [repr %obj] =:
|
||||
".."|nomsu:repr(\%obj as lua\)
|
||||
|
||||
macro [%obj as string] =:
|
||||
".."|nomsu.utils.repr_if_not_string(\%obj as lua\)
|
||||
|
||||
macro [say %str] =:
|
||||
".."|nomsu:writeln(nomsu.utils.repr_if_not_string(\%str as lua\))
|
||||
parse (say %str) as: lua block ".."
|
||||
|nomsu:writeln(nomsu.utils.repr_if_not_string(\(%str)))
|
||||
|
||||
# Number ranges
|
||||
macro [%start to %stop] =: ".."
|
||||
|nomsu.utils.range(\%start as lua\, \%stop as lua\)
|
||||
macro [%start to %stop by %step, %start to %stop via %step] =: ".."
|
||||
|nomsu.utils.range(\%start as lua\, \%stop as lua\, \%step as lua\)
|
||||
parse (%start to %stop) as: lua expr ".."
|
||||
|nomsu.utils.range(\(%start), \(%stop))
|
||||
parse (%start to %stop by %step; %start to %stop via %step) as: lua expr ".."
|
||||
|nomsu.utils.range(\(%start), \(%stop), \(%step))
|
||||
|
||||
# Common utility functions
|
||||
macro [random number, random, rand] =: "math.random()"
|
||||
macro [random int %n, random integer %n, randint %n] =: ".."|math.random(\%n as lua\)
|
||||
macro [random from %low to %high, random number from %low to %high, rand %low %high] =: ".."
|
||||
|math.random(\%low as lua\, \%high as lua\)
|
||||
rule [random choice from %elements, random choice %elements, random %elements] =:
|
||||
lua expr ".."|vars.elements[math.random(#vars.elements)]
|
||||
macro [sum of %items, sum %items] =: ".."|nomsu.utils.sum(\%items as lua\)
|
||||
macro [product of %items, product %items] =: ".."|nomsu.utils.product(\%items as lua\)
|
||||
macro [all of %items] =: ".."|nomsu.utils.all(\%items as lua\)
|
||||
macro [any of %items] =: ".."|nomsu.utils.any(\%items as lua\)
|
||||
parse (random number; random; rand) as: lua expr "math.random()"
|
||||
parse (random int %n; random integer %n; randint %n) as: lua expr "math.random(\(%n))"
|
||||
parse (random from %low to %high; random number from %low to %high; rand %low %high) as:
|
||||
lua expr "math.random(\(%low), \(%high))"
|
||||
rule (random choice from %elements; random choice %elements; random %elements) =:
|
||||
lua expr "vars.elements[math.random(#vars.elements)]"
|
||||
parse (sum of %items; sum %items) as: lua expr "nomsu.utils.sum(\(%items))"
|
||||
parse (product of %items; product %items) as: lua expr "nomsu.utils.product(\(%items))"
|
||||
parse (all of %items) as: lua expr "nomsu.utils.all(\(%items))"
|
||||
parse (any of %items) as: lua expr "nomsu.utils.any(\(%items))"
|
||||
# This is a rule, not a macro so we can use vars.items twice without running it twice.
|
||||
rule [avg of %items, average of %items] =:
|
||||
lua expr ".."|(nomsu.utils.sum(vars.items)/#vars.items)
|
||||
macro [min of %items, smallest of %items, lowest of %items] =:
|
||||
".."|nomsu.utils.min(\%items as lua\)
|
||||
macro [max of %items, biggest of %items, largest of %items, highest of %items] =:
|
||||
".."|nomsu.utils.min(\%items as lua\)
|
||||
macro [min of %items with respect to %keys] =:
|
||||
".."|nomsu.utils.min(\%items as lua\, \%keys as lua\)
|
||||
macro [max of %items with respect to %keys] =:
|
||||
".."|nomsu.utils.max(\%items as lua\, \%keys as lua\)
|
||||
rule (avg of %items; average of %items) =:
|
||||
lua expr "(nomsu.utils.sum(vars.items)/#vars.items)"
|
||||
parse (min of %items; smallest of %items; lowest of %items) as:
|
||||
lua expr "nomsu.utils.min(\(%items))"
|
||||
parse (max of %items; biggest of %items; largest of %items; highest of %items) as:
|
||||
lua expr "nomsu.utils.max(\(%items))"
|
||||
parse (min of %items with respect to %keys) as:
|
||||
lua expr "nomsu.utils.min(\(%items), \(%keys))"
|
||||
parse (max of %items with respect to %keys) as:
|
||||
lua expr "nomsu.utils.max(\(%items), \(%keys))"
|
||||
|
||||
263
nomsu.lua
263
nomsu.lua
@ -7,10 +7,6 @@ do
|
||||
local _obj_0 = table
|
||||
insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat
|
||||
end
|
||||
local pcall
|
||||
pcall = function(fn, ...)
|
||||
return true, fn(...)
|
||||
end
|
||||
lpeg.setmaxstack(10000)
|
||||
local P, V, S, Cg, C, Cp, B, Cmt
|
||||
P, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt
|
||||
@ -65,13 +61,13 @@ local nomsu = [=[ file <- ({ {| shebang?
|
||||
inline_block <- ({ {| "(" inline_statements ")" |} }) -> Block
|
||||
eol_block <- ({ {| ":" %ws? noeol_statements eol |} }) -> Block
|
||||
indented_block <- ({ {| (":" / "(..)") indent
|
||||
statements
|
||||
statements (nodent statements)*
|
||||
(dedent / (({.+} ("" -> "Error while parsing block")) => error))
|
||||
|} }) -> Block
|
||||
|
||||
inline_nomsu <- ({ ("\" inline_block ) }) -> Nomsu
|
||||
eol_nomsu <- ({ ("\" eol_block ) }) -> Nomsu
|
||||
indented_nomsu <- ({ ("\" {indented_block} ) }) -> Nomsu
|
||||
inline_nomsu <- ({ ("\" inline_expression) }) -> Nomsu
|
||||
eol_nomsu <- ({ ("\" noeol_expression) }) -> Nomsu
|
||||
indented_nomsu <- ({ ("\" expression) }) -> Nomsu
|
||||
|
||||
inline_expression <- number / variable / inline_string / inline_list / inline_block / inline_nomsu
|
||||
noeol_expression <- indented_string / indented_block / indented_nomsu / indented_list / inline_expression
|
||||
@ -192,27 +188,15 @@ do
|
||||
return self:write("\n")
|
||||
end,
|
||||
def = function(self, invocation, thunk, src)
|
||||
if type(invocation) ~= 'string' then
|
||||
self:error("Invocation should be string, not: " .. tostring(repr(invocation)))
|
||||
end
|
||||
local stub, arg_names = self:get_stub(invocation)
|
||||
assert(stub, "NO STUB FOUND: " .. tostring(repr(invocation)))
|
||||
if self.debug then
|
||||
self:writeln("Defining rule: " .. tostring(repr(invocation)))
|
||||
self:writeln("Defining rule: " .. tostring(repr(stub)) .. " with args " .. tostring(repr(arg_names)))
|
||||
end
|
||||
local stub = invocation:gsub("'", " '"):gsub("%%%S+", "%%"):gsub("%s+", " ")
|
||||
local args
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for arg in invocation:gmatch("%%(%S[^%s']*)") do
|
||||
_accum_0[_len_0] = arg
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
args = _accum_0
|
||||
end
|
||||
for i = 1, #args - 1 do
|
||||
for j = i + 1, #args do
|
||||
if args[i] == args[j] then
|
||||
self:error("Duplicate argument in function def: " .. tostring(args[i]))
|
||||
for i = 1, #arg_names - 1 do
|
||||
for j = i + 1, #arg_names do
|
||||
if arg_names[i] == arg_names[j] then
|
||||
self:error("Duplicate argument in function " .. tostring(stub) .. ": '" .. tostring(arg_names[i]) .. "'")
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -220,11 +204,11 @@ do
|
||||
local _with_0 = {
|
||||
thunk = thunk,
|
||||
invocation = invocation,
|
||||
args = args,
|
||||
arg_names = arg_names,
|
||||
src = src,
|
||||
is_macro = false
|
||||
}
|
||||
self.defs[invocation] = _with_0
|
||||
self.defs[stub] = _with_0
|
||||
local _ = nil
|
||||
return _with_0
|
||||
end
|
||||
@ -236,30 +220,31 @@ do
|
||||
return _with_0
|
||||
end
|
||||
end,
|
||||
call = function(self, alias, ...)
|
||||
local def = self.defs[alias]
|
||||
call = function(self, stub, ...)
|
||||
local def = self.defs[stub]
|
||||
if def == nil then
|
||||
self:error("Attempt to call undefined function: " .. tostring(alias))
|
||||
self:error("Attempt to call undefined function: " .. tostring(stub))
|
||||
end
|
||||
if def.is_macro and self.callstack[#self.callstack] ~= "#macro" then
|
||||
self:error("Attempt to call macro at runtime: " .. tostring(alias) .. "\nThis can be caused by using a macro in a function that is defined before the macro.")
|
||||
self:error("Attempt to call macro at runtime: " .. tostring(stub) .. "\nThis can be caused by using a macro in a function that is defined before the macro.")
|
||||
end
|
||||
if not (self:check_permission(def)) then
|
||||
self:error("You do not have the authority to call: " .. tostring(alias))
|
||||
self:error("You do not have the authority to call: " .. tostring(stub))
|
||||
end
|
||||
local thunk, args
|
||||
thunk, args = def.thunk, def.args
|
||||
local thunk, arg_names
|
||||
thunk, arg_names = def.thunk, def.arg_names
|
||||
local args
|
||||
do
|
||||
local _tbl_0 = { }
|
||||
for i, name in ipairs(args) do
|
||||
for i, name in ipairs(arg_names) do
|
||||
_tbl_0[name] = select(i, ...)
|
||||
end
|
||||
args = _tbl_0
|
||||
end
|
||||
if self.debug then
|
||||
self:writeln("Calling " .. tostring(repr(alias)) .. " with args: " .. tostring(repr(args)))
|
||||
self:writeln("Calling " .. tostring(repr(stub)) .. " with args: " .. tostring(repr(args)))
|
||||
end
|
||||
insert(self.callstack, alias)
|
||||
insert(self.callstack, stub)
|
||||
local rets = {
|
||||
thunk(self, args)
|
||||
}
|
||||
@ -270,10 +255,9 @@ do
|
||||
if kind == nil then
|
||||
kind = "Expression"
|
||||
end
|
||||
local args, alias
|
||||
alias, args = self:get_alias(tree)
|
||||
local stub, args = self:get_stub(tree)
|
||||
insert(self.callstack, "#macro")
|
||||
local expr, statement = self:call(alias, unpack(args))
|
||||
local expr, statement = self:call(stub, unpack(args))
|
||||
remove(self.callstack)
|
||||
return expr, statement
|
||||
end,
|
||||
@ -319,13 +303,17 @@ do
|
||||
run = function(self, src, filename)
|
||||
local tree = self:parse(src, filename)
|
||||
assert(tree, "Tree failed to compile: " .. tostring(src))
|
||||
assert(tree.type == "File")
|
||||
assert(tree.type == "File", "Attempt to run non-file: " .. tostring(tree.type))
|
||||
local buffer = { }
|
||||
local vars = { }
|
||||
local return_value = nil
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local statement = _list_0[_index_0]
|
||||
if self.debug then
|
||||
self:writeln("RUNNING TREE:")
|
||||
self:print_tree(statement)
|
||||
end
|
||||
local ok, expr, statements = pcall(self.tree_to_lua, self, statement)
|
||||
if not ok then
|
||||
self:writeln("Error occurred in statement:\n" .. tostring(statement.src))
|
||||
@ -350,7 +338,7 @@ do
|
||||
end
|
||||
if not ok then
|
||||
self:writeln("Error occurred in statement:\n" .. tostring(statement.src))
|
||||
self:error(return_value)
|
||||
self:error(repr(return_value))
|
||||
end
|
||||
insert(buffer, tostring(statements or '') .. "\n" .. tostring(expr and "ret = " .. tostring(expr) or ''))
|
||||
end
|
||||
@ -372,6 +360,7 @@ do
|
||||
tree_to_lua = function(self, tree)
|
||||
assert(tree, "No tree provided.")
|
||||
if not tree.type then
|
||||
self:writeln(debug.traceback())
|
||||
self:error("Invalid tree: " .. tostring(repr(tree)))
|
||||
end
|
||||
local _exp_0 = tree.type
|
||||
@ -379,15 +368,12 @@ do
|
||||
return error("Should not be converting File to lua through this function.")
|
||||
elseif "Nomsu" == _exp_0 then
|
||||
return repr(tree.value), nil
|
||||
elseif "Block" == _exp_0 then
|
||||
elseif "Thunk" == _exp_0 then
|
||||
local lua_bits = { }
|
||||
local _list_0 = tree.value
|
||||
local _list_0 = tree.value.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local arg = _list_0[_index_0]
|
||||
local expr, statement = self:tree_to_lua(arg)
|
||||
if expr and not statement and #tree.value == 1 then
|
||||
return expr, nil
|
||||
end
|
||||
if statement then
|
||||
insert(lua_bits, statement)
|
||||
end
|
||||
@ -395,18 +381,34 @@ do
|
||||
insert(lua_bits, "ret = " .. tostring(expr))
|
||||
end
|
||||
end
|
||||
return ([[ function(nomsu, vars)
|
||||
return ([[ (function(nomsu, vars)
|
||||
local ret
|
||||
%s
|
||||
return ret
|
||||
end]]):format(concat(lua_bits, "\n"))
|
||||
end)]]):format(concat(lua_bits, "\n"))
|
||||
elseif "Block" == _exp_0 then
|
||||
if #tree.value == 0 then
|
||||
return "nil", nil
|
||||
end
|
||||
if #tree.value == 1 then
|
||||
local expr, statement = self:tree_to_lua(tree.value[1])
|
||||
if not statement then
|
||||
return expr, nil
|
||||
end
|
||||
end
|
||||
local thunk_lua = self:tree_to_lua({
|
||||
type = "Thunk",
|
||||
value = tree,
|
||||
src = tree.src
|
||||
})
|
||||
return ("%s(nomsu, vars)"):format(thunk_lua), nil
|
||||
elseif "FunctionCall" == _exp_0 then
|
||||
local alias = self:get_alias(tree)
|
||||
if self.defs[alias] and self.defs[alias].is_macro then
|
||||
local stub = self:get_stub(tree)
|
||||
if self.defs[stub] and self.defs[stub].is_macro then
|
||||
return self:run_macro(tree, "Expression")
|
||||
end
|
||||
local args = {
|
||||
repr(alias)
|
||||
repr(stub)
|
||||
}
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
@ -460,6 +462,9 @@ do
|
||||
if string_buffer ~= "" then
|
||||
insert(concat_parts, repr(string_buffer))
|
||||
end
|
||||
if #concat_parts == 0 then
|
||||
return "''", nil
|
||||
end
|
||||
return "(" .. tostring(concat(concat_parts, "..")) .. ")", nil
|
||||
elseif "List" == _exp_0 then
|
||||
local items = { }
|
||||
@ -481,25 +486,49 @@ do
|
||||
return self:error("Unknown/unimplemented thingy: " .. tostring(tree.type))
|
||||
end
|
||||
end,
|
||||
print_tree = function(self, tree, ind)
|
||||
if ind == nil then
|
||||
ind = ""
|
||||
walk_tree = function(self, tree, depth)
|
||||
if depth == nil then
|
||||
depth = 0
|
||||
end
|
||||
coroutine.yield(tree, depth)
|
||||
if type(tree) ~= 'table' or not tree.type then
|
||||
self:writeln(tostring(ind) .. tostring(repr(tree)))
|
||||
return
|
||||
end
|
||||
self:writeln(tostring(ind) .. tostring(tree.type) .. ":")
|
||||
local _exp_0 = tree.type
|
||||
if "List" == _exp_0 or "File" == _exp_0 or "Block" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then
|
||||
if "List" == _exp_0 or "File" == _exp_0 or "Nomsu" == _exp_0 or "Block" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local v = _list_0[_index_0]
|
||||
self:print_tree(v, ind .. " ")
|
||||
self:walk_tree(v, depth + 1)
|
||||
end
|
||||
else
|
||||
return self:print_tree(tree.value, ind .. " ")
|
||||
self:walk_tree(tree.value, depth + 1)
|
||||
end
|
||||
return nil
|
||||
end,
|
||||
print_tree = function(self, tree)
|
||||
for node, depth in coroutine.wrap(function()
|
||||
return self:walk_tree(tree)
|
||||
end) do
|
||||
if type(node) ~= 'table' or not node.type then
|
||||
self:writeln((" "):rep(depth) .. repr(node))
|
||||
else
|
||||
self:writeln(tostring((" "):rep(depth)) .. tostring(node.type) .. ":")
|
||||
end
|
||||
end
|
||||
end,
|
||||
tree_to_str = function(self, tree)
|
||||
local bits = { }
|
||||
for node, depth in coroutine.wrap(function()
|
||||
return self:walk_tree(tree)
|
||||
end) do
|
||||
if type(node) ~= 'table' or not node.type then
|
||||
insert(bits, ((" "):rep(depth) .. repr(node)))
|
||||
else
|
||||
insert(bits, (tostring((" "):rep(depth)) .. tostring(node.type) .. ":"))
|
||||
end
|
||||
end
|
||||
return concat(bits, "\n")
|
||||
end,
|
||||
replaced_vars = function(self, tree, vars)
|
||||
if type(tree) ~= 'table' then
|
||||
@ -510,8 +539,8 @@ do
|
||||
if vars[tree.value] then
|
||||
tree = vars[tree.value]
|
||||
end
|
||||
elseif "File" == _exp_0 or "Thunk" == _exp_0 or "Statement" == _exp_0 or "Block" == _exp_0 or "List" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then
|
||||
local new_value = self:replaced_vars(tree.value)
|
||||
elseif "File" == _exp_0 or "Nomsu" == _exp_0 or "Thunk" == _exp_0 or "Block" == _exp_0 or "List" == _exp_0 or "FunctionCall" == _exp_0 or "String" == _exp_0 then
|
||||
local new_value = self:replaced_vars(tree.value, vars)
|
||||
if new_value ~= tree.value then
|
||||
do
|
||||
local _tbl_0 = { }
|
||||
@ -526,7 +555,7 @@ do
|
||||
local new_values = { }
|
||||
local any_different = false
|
||||
for k, v in pairs(tree) do
|
||||
new_values[k] = self:replaced_vars(v)
|
||||
new_values[k] = self:replaced_vars(v, vars)
|
||||
any_different = any_different or (new_values[k] ~= tree[k])
|
||||
end
|
||||
if any_different then
|
||||
@ -535,84 +564,47 @@ do
|
||||
end
|
||||
return tree
|
||||
end,
|
||||
get_alias = function(self, x)
|
||||
get_stub = function(self, x)
|
||||
if not x then
|
||||
self:error("Nothing to get alias from")
|
||||
self:error("Nothing to get stub from")
|
||||
end
|
||||
if type(x) == 'string' then
|
||||
local alias = x:gsub("'", " '"):gsub("%%%S+", "%%"):gsub("%s+", " ")
|
||||
local stub = x:gsub("'", " '"):gsub("%%%S+", "%%"):gsub("%s+", " ")
|
||||
local args
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for arg in x:gmatch("%%(%S[^%s']*)") do
|
||||
for arg in x:gmatch("%%([^%s']*)") do
|
||||
_accum_0[_len_0] = arg
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
args = _accum_0
|
||||
end
|
||||
return alias, args
|
||||
return stub, args
|
||||
end
|
||||
local _exp_0 = x.type
|
||||
if "String" == _exp_0 then
|
||||
return self:get_alias(x.value)
|
||||
elseif "Statement" == _exp_0 then
|
||||
return self:get_alias(x.value)
|
||||
return self:get_stub(x.value)
|
||||
elseif "FunctionCall" == _exp_0 then
|
||||
local alias, args = { }, { }, { }
|
||||
local stub, args = { }, { }, { }
|
||||
local _list_0 = x.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local token = _list_0[_index_0]
|
||||
local _exp_1 = token.type
|
||||
if "Word" == _exp_1 then
|
||||
insert(alias, token.value)
|
||||
insert(stub, token.value)
|
||||
elseif "Var" == _exp_1 then
|
||||
insert(alias, "%")
|
||||
insert(stub, "%")
|
||||
insert(args, token.value)
|
||||
else
|
||||
insert(alias, "%")
|
||||
insert(stub, "%")
|
||||
insert(args, token)
|
||||
end
|
||||
end
|
||||
return concat(alias, " "), args
|
||||
end
|
||||
end,
|
||||
get_aliases = function(self, x)
|
||||
if not x then
|
||||
self:error("Nothing to get aliases from")
|
||||
end
|
||||
if type(x) == 'string' then
|
||||
local alias, args = self:get_alias(x)
|
||||
return {
|
||||
[alias] = args
|
||||
}
|
||||
end
|
||||
local _exp_0 = x.type
|
||||
if "String" == _exp_0 then
|
||||
return self:get_aliases({
|
||||
x.value
|
||||
})
|
||||
elseif "Statement" == _exp_0 then
|
||||
return self:get_aliases({
|
||||
x.value
|
||||
})
|
||||
elseif "FunctionCall" == _exp_0 then
|
||||
return self:get_aliases({
|
||||
x
|
||||
})
|
||||
elseif "List" == _exp_0 then
|
||||
x = x.value
|
||||
return concat(stub, " "), args
|
||||
elseif "Block" == _exp_0 then
|
||||
x = x.value
|
||||
end
|
||||
do
|
||||
local _with_0 = { }
|
||||
for _index_0 = 1, #x do
|
||||
local y = x[_index_0]
|
||||
local alias, args = self:get_alias(y)
|
||||
_with_0[alias] = args
|
||||
end
|
||||
return _with_0
|
||||
self:writeln(debug.traceback())
|
||||
return self:error("Please pass in a single line from a block, not the whole thing:\n" .. tostring(self:tree_to_str(x)))
|
||||
end
|
||||
end,
|
||||
var_to_lua_identifier = function(self, var)
|
||||
@ -629,7 +621,9 @@ do
|
||||
end,
|
||||
error = function(self, ...)
|
||||
self:writeln("ERROR!")
|
||||
self:writeln(...)
|
||||
if select(1, ...) then
|
||||
self:writeln(...)
|
||||
end
|
||||
self:writeln("Callstack:")
|
||||
for i = #self.callstack, 1, -1 do
|
||||
self:writeln(" " .. tostring(self.callstack[i]))
|
||||
@ -639,17 +633,22 @@ do
|
||||
return error()
|
||||
end,
|
||||
initialize_core = function(self)
|
||||
self:defmacro("lua code %statements with value %value", function(self, vars)
|
||||
local inner_vars = setmetatable({ }, {
|
||||
__index = function(_, key)
|
||||
return "vars[" .. tostring(repr(key)) .. "]"
|
||||
end
|
||||
})
|
||||
local statements = self:tree_to_value(vars.statements, inner_vars)
|
||||
local value = self:tree_to_value(vars.value, inner_vars)
|
||||
return value, statements
|
||||
end)
|
||||
self:def("require %filename", function(self, vars)
|
||||
local lua_code
|
||||
lua_code = function(self, vars)
|
||||
local inner_vars = vars
|
||||
local lua = self:tree_to_value(vars.code, inner_vars)
|
||||
return nil, lua
|
||||
end
|
||||
self:defmacro("lua code %code", lua_code)
|
||||
local lua_value
|
||||
lua_value = function(self, vars)
|
||||
local inner_vars = vars
|
||||
local lua = self:tree_to_value(vars.code, inner_vars)
|
||||
return lua, nil
|
||||
end
|
||||
self:defmacro("lua value %code", lua_value)
|
||||
local _require
|
||||
_require = function(self, vars)
|
||||
if not self.loaded_files[vars.filename] then
|
||||
local file = io.open(vars.filename)
|
||||
if not file then
|
||||
@ -658,14 +657,17 @@ do
|
||||
self.loaded_files[vars.filename] = (self:run(file:read('*a'), vars.filename)) or true
|
||||
end
|
||||
return self.loaded_files[vars.filename]
|
||||
end)
|
||||
return self:def("run file %filename", function(self, vars)
|
||||
end
|
||||
self:def("require %filename", _require)
|
||||
local run_file
|
||||
run_file = function(self, vars)
|
||||
local file = io.open(vars.filename)
|
||||
if not file then
|
||||
self:error("File does not exist: " .. tostring(vars.filename))
|
||||
end
|
||||
return self:run(file:read('*a'), vars.filename)
|
||||
end)
|
||||
end
|
||||
return self:def("run file %filename", run_file)
|
||||
end
|
||||
}
|
||||
_base_0.__index = _base_0
|
||||
@ -726,7 +728,6 @@ do
|
||||
end
|
||||
if arg and arg[1] then
|
||||
local c = NomsuCompiler()
|
||||
c.debug = true
|
||||
local input = io.open(arg[1]):read("*a")
|
||||
local _write = c.write
|
||||
if arg[2] == "-" then
|
||||
|
||||
10
nomsu.moon
10
nomsu.moon
@ -70,7 +70,7 @@ nomsu = [=[
|
||||
inline_block <- ({ {| "(" inline_statements ")" |} }) -> Block
|
||||
eol_block <- ({ {| ":" %ws? noeol_statements eol |} }) -> Block
|
||||
indented_block <- ({ {| (":" / "(..)") indent
|
||||
statements
|
||||
statements (nodent statements)*
|
||||
(dedent / (({.+} ("" -> "Error while parsing block")) => error))
|
||||
|} }) -> Block
|
||||
|
||||
@ -329,6 +329,8 @@ class NomsuCompiler
|
||||
end)]])\format(concat lua_bits, "\n")
|
||||
|
||||
when "Block"
|
||||
if #tree.value == 0
|
||||
return "nil",nil
|
||||
if #tree.value == 1
|
||||
expr,statement = @tree_to_lua tree.value[1]
|
||||
if not statement
|
||||
@ -367,6 +369,8 @@ class NomsuCompiler
|
||||
if string_buffer ~= ""
|
||||
insert concat_parts, repr(string_buffer)
|
||||
|
||||
if #concat_parts == 0
|
||||
return "''", nil
|
||||
return "(#{concat(concat_parts, "..")})", nil
|
||||
|
||||
when "List"
|
||||
@ -502,13 +506,13 @@ class NomsuCompiler
|
||||
initialize_core: =>
|
||||
-- Sets up some core functionality
|
||||
lua_code = (vars)=>
|
||||
inner_vars = setmetatable({}, {__index:(_,key)-> "vars[#{repr(key)}]"})
|
||||
inner_vars = vars-- setmetatable({}, {__index:(_,key)-> "vars[#{repr(key)}]"})
|
||||
lua = @tree_to_value(vars.code, inner_vars)
|
||||
return nil, lua
|
||||
@defmacro "lua code %code", lua_code
|
||||
|
||||
lua_value = (vars)=>
|
||||
inner_vars = setmetatable({}, {__index:(_,key)-> "vars[#{repr(key)}]"})
|
||||
inner_vars = vars--setmetatable({}, {__index:(_,key)-> "vars[#{repr(key)}]"})
|
||||
lua = @tree_to_value(vars.code, inner_vars)
|
||||
return lua, nil
|
||||
@defmacro "lua value %code", lua_value
|
||||
|
||||
Loading…
Reference in New Issue
Block a user