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

Fully working, I think? (with a lot of shims)

Browse Source
This commit is contained in:
Bruce Hill 2018-09-28 22:15:06 -07:00
parent 678344182b
commit 63d8b1cd3f
12 changed files with 174 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
code_obj.moon
View File

@ -47,10 +47,10 @@ class Code
@bits = {} @bits = {}
if type(@source) == 'string' if type(@source) == 'string'
@source = Source\from_string(@source) @source = Source\from_string(@source)
assert(@source and Source\is_instance(@source), "Source has the wrong type") --assert(@source and Source\is_instance(@source), "Source has the wrong type")
@append(...) @append(...)
__tostring: => as_smext: =>
if @__str == nil if @__str == nil
buff, indent = {}, 0 buff, indent = {}, 0
{:match, :gsub, :rep} = string {:match, :gsub, :rep} = string
@ -59,21 +59,23 @@ class Code
if spaces = match(b, "\n([ ]*)[^\n]*$") if spaces = match(b, "\n([ ]*)[^\n]*$")
indent = #spaces indent = #spaces
else else
b = tostring(b) b = b\as_smext!
if indent > 0 if indent > 0
b = gsub(b, "\n", "\n"..rep(" ", indent)) b = gsub(b, "\n", "\n"..rep(" ", indent))
buff[#buff+1] = b buff[#buff+1] = b
@__str = concat(buff, "") @__str = concat(buff, "")
return @__str return @__str
__tostring: => @as_smext!
as_lua: => as_lua: =>
"#{@__class.__name}(#{concat {tostring(@source)\as_lua!, unpack([b\as_lua! for b in *@bits])}, ", "})" "#{@__class.__name}(#{concat {tostring(@source)\as_lua!, unpack([b\as_lua! for b in *@bits])}, ", "})"
__len: => #tostring(@) __len: => #@as_smext!
match: (...)=> tostring(@)\match(...) match: (...)=> @as_smext!\match(...)
gmatch: (...)=> tostring(@)\gmatch(...) gmatch: (...)=> @as_smext!\gmatch(...)
dirty: => dirty: =>
@__str = nil @__str = nil
@ -91,14 +93,14 @@ class Code
assert(not Source\is_instance(b), "code bit is a Source") assert(not Source\is_instance(b), "code bit is a Source")
if b == '' then continue if b == '' then continue
b.dirty = error if b.is_code b.dirty = error if b.is_code
if type(b) != 'string' and not (type(b) == 'table' and b.is_code) --if type(b) != 'string' and not (type(b) == 'table' and b.is_code)
b = b\as_lua! -- b = b\as_lua!
bits[#bits+1] = b bits[#bits+1] = b
@dirty! @dirty!
trailing_line_len: => trailing_line_len: =>
if @_trailing_line_len == nil if @_trailing_line_len == nil
@_trailing_line_len = #tostring(@)\match("[^\n]*$") @_trailing_line_len = #@as_smext!\match("[^\n]*$")
return @_trailing_line_len return @_trailing_line_len
is_multiline: => is_multiline: =>
@ -130,7 +132,8 @@ class Code
bits[#bits+1] = joiner bits[#bits+1] = joiner
bits[#bits+1] = b bits[#bits+1] = b
b.dirty = error if b.is_code b.dirty = error if b.is_code
b = tostring(b) unless type(b) == 'string'
b = b\as_smext!
line = match(b, "\n([^\n]*)$") line = match(b, "\n([^\n]*)$")
if line if line
line_len = #line line_len = #line
@ -146,8 +149,8 @@ class Code
for i=1,n for i=1,n
b = select(i, ...) b = select(i, ...)
b.dirty = error if b.is_code b.dirty = error if b.is_code
if type(b) != 'string' and not (type(b) == 'table' and b.is_code) --if type(b) != 'string' and not (type(b) == 'table' and b.is_code)
b = b\as_lua! -- b = b\as_lua!
bits[i] = b bits[i] = b
@dirty! @dirty!
@ -237,7 +240,8 @@ class LuaCode extends Code
nomsu_to_lua[lua.source.start] = pos nomsu_to_lua[lua.source.start] = pos
else else
walk b, pos walk b, pos
pos += #tostring(b) b = b\as_smext!
pos += #b
walk self, 1 walk self, 1
return { return {
nomsu_filename:@source.filename nomsu_filename:@source.filename

2
containers.moon
View File

@ -87,6 +87,8 @@ _list_mt =
__newindex: (k,v)=> __newindex: (k,v)=>
assert type(k) == 'number', "List indices must be numbers" assert type(k) == 'number', "List indices must be numbers"
rawset(@, k, v) rawset(@, k, v)
_list_mt.__index.as_lua = _list_mt.as_lua
_list_mt.__index.as_nomsu = _list_mt.as_nomsu
List = (t)-> setmetatable(t, _list_mt) List = (t)-> setmetatable(t, _list_mt)

125
core/control_flow.nom
View File

@ -16,11 +16,13 @@ compile [do nothing] to (Lua "")
test: test:
if (no): if (no):
barf "conditional fail" barf "conditional fail"
compile [if %condition %if_body] to (..) compile [if %condition %if_body] to:
Lua "\ %lua = (Lua "if ")
..if \(%condition as lua expr) then %lua::append (%condition as lua expr)
\(%if_body as lua statements) %lua::append " then\n "
end" %lua::append (%if_body as lua statements)
%lua::append "\nend"
return %lua
test: test:
unless (yes): unless (yes):
@ -28,13 +30,15 @@ test:
parse [unless %condition %unless_body] as (if (not %condition) %unless_body) parse [unless %condition %unless_body] as (if (not %condition) %unless_body)
compile [..] compile [..]
if %condition %if_body else %else_body, unless %condition %else_body else %if_body if %condition %if_body else %else_body, unless %condition %else_body else %if_body
..to (..) ..to:
Lua "\ %lua = (Lua "if ")
..if \(%condition as lua expr) then %lua::append (%condition as lua expr)
\(%if_body as lua statements) %lua::append " then\n "
else %lua::append (%if_body as lua statements)
\(%else_body as lua statements) %lua::append "\nelse\n "
end" %lua::append (%else_body as lua statements)
%lua::append "\nend"
return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -149,9 +153,8 @@ test:
compile [repeat %n times %body] to: compile [repeat %n times %body] to:
define mangler define mangler
%lua = (..) %lua = (..)
Lua "\ Lua "for \(mangle "i")=1,\(%n as lua expr) do\n "
..for \(mangle "i")=1,\(%n as lua expr) do %lua::append (%body as lua statements)
\(%body as lua statements)"
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
@ -208,18 +211,20 @@ compile [..]
..to: ..to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%var.type is "Var"): unless (%var.type is "Var"):
compile error at %var "Expected a variable here, not a \(%var.type)." compile error at %var "Expected a variable here, not a \(%var.type)"
%lua = (..) %lua = (..)
Lua "\ Lua "\
..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..) ..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
%step as lua expr %step as lua expr
.. do .. do"
\(%body as lua statements)" %lua::append "\n "
%lua::append (%body as lua statements)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append "\n \(compile as (===next %var ===))" %lua::append "\n "
%lua::append (compile as (===next %var ===))
%lua::append "\nend --numeric for-loop" %lua::append "\nend --numeric for-loop"
if (%body has subtree \(stop %var)): if (%body has subtree \(stop %var)):
%inner_lua = %lua %inner_lua = %lua
@ -254,14 +259,14 @@ compile [for %var in %iterable %body] to:
define mangler define mangler
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
%lua = (..) %lua = (..)
Lua "\ Lua "for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do\n "
..for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do %lua::append (%body as lua statements)
\(%body as lua statements)"
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append (Lua "\n\(compile as (===next %var ===))") %lua::append "\n "
%lua::append (compile as (===next %var ===))
%lua::append "\nend --foreach-loop" %lua::append "\nend --foreach-loop"
if (%body has subtree \(stop %var)): if (%body has subtree \(stop %var)):
%inner_lua = %lua %inner_lua = %lua
@ -277,14 +282,14 @@ compile [for %var in %iterable %body] to:
compile [for %var in %iterable at %i %body] to: compile [for %var in %iterable at %i %body] to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
%lua = (..) %lua = (..)
Lua "\ Lua "for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do\n "
..for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do %lua::append (%body as lua statements)
\(%body as lua statements)"
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append (Lua "\n\(compile as (===next %var ===))") %lua::append "\n "
%lua::append (compile as (===next %var ===))
%lua::append "\nend --foreach-loop" %lua::append "\nend --foreach-loop"
if (%body has subtree \(stop %var)): if (%body has subtree \(stop %var)):
%inner_lua = %lua %inner_lua = %lua
@ -312,28 +317,33 @@ compile [..]
..to: ..to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%key.type is "Var"): unless (%key.type is "Var"):
compile error at %key "Expected a variable here, not a \(%key.type)." compile error at %key "Expected a variable here, not a \(%key.type)"
unless (%value.type is "Var"): unless (%value.type is "Var"):
compile error at %value "Expected a variable here, not a \(%value.type)." compile error at %value "Expected a variable here, not a \(%value.type)"
%lua = (..) %lua = (..)
Lua "\ Lua "\
..for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..) ..for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
%iterable as lua expr %iterable as lua expr
..) do ..) do"
\(%body as lua statements)" %lua::append "\n "
%lua::append (%body as lua statements)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %key)): if (%body has subtree \(do next %key)):
%lua::append (Lua "\n\(compile as (===next %key ===))") %lua::append "\n "
%lua::append (compile as (===next %key ===))
if (%body has subtree \(do next %value)): if (%body has subtree \(do next %value)):
%lua::append (Lua "\n\(compile as (===next %value ===))") %lua::append "\n "
%lua::append (compile as (===next %value ===))
%lua::append "\nend --foreach-loop" %lua::append "\nend --foreach-loop"
%stop_labels = (Lua "") %stop_labels = (Lua "")
if (%body has subtree \(stop %key)): if (%body has subtree \(stop %key)):
%stop_labels::append "\n\(compile as (===stop %key ===))" %stop_labels::append "\n"
%stop_labels::append (compile as (===stop %key ===))
if (%body has subtree \(stop %value)): if (%body has subtree \(stop %value)):
%stop_labels::append "\n\(compile as (===stop %value ===))" %stop_labels::append "\n"
%stop_labels::append (compile as (===stop %value ===))
if ((size of "\%stop_labels") > 0): if ((size of "\%stop_labels") > 0):
%inner_lua = %lua %inner_lua = %lua
%lua = (Lua "do -- scope for stopping for % = % loop\n ") %lua = (Lua "do -- scope for stopping for % = % loop\n ")
@ -390,7 +400,8 @@ compile [if %body, when %body] to:
%code::append (%action as lua statements) %code::append (%action as lua statements)
%else_allowed = (no) %else_allowed = (no)
..else: ..else:
%code::append "\%clause " %code::append %clause
%code::append " "
for %i in 1 to ((size of %line) - 1): for %i in 1 to ((size of %line) - 1):
if (%i > 1): if (%i > 1):
%code::append " or " %code::append " or "
@ -450,11 +461,13 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
%code::append (%action as lua statements) %code::append (%action as lua statements)
%else_allowed = (no) %else_allowed = (no)
..else: ..else:
%code::append "\%clause " %code::append %clause
%code::append " "
for %i in 1 to ((size of %line) - 1): for %i in 1 to ((size of %line) - 1):
if (%i > 1): if (%i > 1):
%code::append " or " %code::append " or "
%code::append "\(mangle "branch value") == \(%line.%i as lua expr)" %code::append "\(mangle "branch value") == "
%code::append (%line.%i as lua expr)
%code::append " then\n " %code::append " then\n "
%code::append (%action as lua statements) %code::append (%action as lua statements)
@ -467,18 +480,19 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
%lua = (..) %lua = (..)
Lua "\ Lua "\
..do --if % is... ..do --if % is...
local \(mangle "branch value") = \(%branch_value as lua expr)" local \(mangle "branch value") = "
%lua::append (%branch_value as lua expr)
%lua::append "\n " %lua::append "\n "
%lua::append %code %lua::append %code
%lua::append "\nend --if % is..." %lua::append "\nend --if % is..."
return %lua return %lua
# Do/finally # Do/finally
compile [do %action] to (..) compile [do %action] to:
Lua "\ %lua = (Lua "do\n ")
..do %lua::append (%action as lua statements)
\(%action as lua statements) %lua::append "\nend -- do"
end --do" return %lua
test: test:
%d = {} %d = {}
@ -492,16 +506,20 @@ test:
assume (%d.x == "good") assume (%d.x == "good")
compile [do %action then always %final_action] to: compile [do %action then always %final_action] to:
define mangler define mangler
return (..) %lua = (..)
Lua "\ Lua "\
..do ..do
local \(mangle "fell_through") = false local \(mangle "fell_through") = false
local \(mangle "ok"), \(mangle "ret") = pcall(function() local \(mangle "ok"), \(mangle "ret") = pcall(function()"
\(%action as lua statements) %lua::append "\n "
\(mangle "fell_through") = true %lua::append (%action as lua statements)
end) %lua::append "\
\(%final_action as lua statements) .. \(mangle "fell_through") = true
if not \(mangle "ok") then error(ret, 0) end end)"
%lua::append "\n "
%lua::append (%final_action as lua statements)
%lua::append "\
.. if not \(mangle "ok") then error(ret, 0) end
if not \(mangle "fell_through") then return ret end if not \(mangle "fell_through") then return ret end
end" end"
@ -532,8 +550,9 @@ compile [for %var in recursive %structure %body] to (..)
..do ..do
local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)} local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)}
while #\(mangle "stack \(%var.1)") > 0 do while #\(mangle "stack \(%var.1)") > 0 do
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1) \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)"
\(%body as lua statements)" %lua::append "\n "
%lua::append (%body as lua statements)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"

8
core/math.nom
View File

@ -72,21 +72,21 @@ action [%n to the nearest %rounder] (..)
compile [all of %items, all %items] to: compile [all of %items, all %items] to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.all(\(%items as lua expr))") return (Lua value "utils.all(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = (((% as lua expr)::as smext) for % in %items)
return (Lua value "(\(%clauses::joined with " and "))") return (Lua value "(\(%clauses::joined with " and "))")
parse [not all of %items, not all %items] as (not (all of %items)) parse [not all of %items, not all %items] as (not (all of %items))
compile [any of %items, any %items] to: compile [any of %items, any %items] to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.any(\(%items as lua expr))") return (Lua value "utils.any(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = (((% as lua expr)::as smext) for % in %items)
return (Lua value "(\(%clauses::joined with " or "))") return (Lua value "(\(%clauses::joined with " or "))")
parse [none of %items, none %items] as (not (any of %items)) parse [none of %items, none %items] as (not (any of %items))
compile [sum of %items, sum %items] to: compile [sum of %items, sum %items] to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.sum(\(%items as lua expr))") return (Lua value "utils.sum(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = (((% as lua expr)::as smext) for % in %items)
return (Lua value "(\(%clauses::joined with " + "))") return (Lua value "(\(%clauses::joined with " + "))")
parse [if all of %items %body, if all of %items then %body] as (..) parse [if all of %items %body, if all of %items then %body] as (..)
@ -118,7 +118,7 @@ parse [unless none of %items %body else %else, unless none of %items then %body
compile [product of %items, product %items] to: compile [product of %items, product %items] to:
unless (%items.type is "List"): unless (%items.type is "List"):
return (Lua value "utils.product(\(%items as lua expr))") return (Lua value "utils.product(\(%items as lua expr))")
%clauses = ((% as lua expr) for % in %items) %clauses = (((% as lua expr)::as smext) for % in %items)
return (Lua value "(\(%clauses::joined with " * "))") return (Lua value "(\(%clauses::joined with " * "))")
action [avg of %items, average of %items] (=lua "(utils.sum(\%items)/#\%items)") action [avg of %items, average of %items] (=lua "(utils.sum(\%items)/#\%items)")

18
core/metaprogramming.nom
View File

@ -23,7 +23,7 @@ lua> "\
..COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body) ..COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
local lua = LuaCode.Value(tree.source, "(function(") local lua = LuaCode.Value(tree.source, "(function(")
if AST.is_syntax_tree(\%args, "Action") then \%args = \%args:get_args() end if AST.is_syntax_tree(\%args, "Action") then \%args = \%args:get_args() end
local lua_args = table.map(\%args, function(a) return AST.is_syntax_tree(a) and tostring(nomsu:compile(a)) or a end) local lua_args = table.map(\%args, function(a) return AST.is_syntax_tree(a) and nomsu:compile(a):as_smext() or a end)
lua:concat_append(lua_args, ", ") lua:concat_append(lua_args, ", ")
local body_lua = AST.is_syntax_tree(\%body) and nomsu:compile(\%body):as_statements("return ") or \%body local body_lua = AST.is_syntax_tree(\%body) and nomsu:compile(\%body):as_statements("return ") or \%body
body_lua:remove_free_vars(lua_args) body_lua:remove_free_vars(lua_args)
@ -64,14 +64,14 @@ test:
assume (%tmp is (nil)) or barf "compile to is leaking variables" assume (%tmp is (nil)) or barf "compile to is leaking variables"
lua> "\ lua> "\
..COMPILE_ACTIONS["compile 1 to 2"] = function(nomsu, tree, \%actions, \%body) ..COMPILE_ACTIONS["compile 1 to 2"] = function(nomsu, tree, \%actions, \%body)
local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(\ local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(\
..a)) end))} ..a):as_smext() end))}
local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", \%actions[1].stub:as_lua(),
"] = ", \(compile as (%args -> %body))) "] = ", \(compile as (%args -> %body)))
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return tostring(nomsu:compile(\ local \%alias_args = {"nomsu", "tree", unpack(table.map(alias:get_args(), function(a) return nomsu:compile(\
..a)) end))} ..a):as_smext() end))}
lua:append("\\nCOMPILE_ACTIONS[", alias.stub:as_lua(), "] = ") lua:append("\\nCOMPILE_ACTIONS[", alias.stub:as_lua(), "] = ")
if utils.equivalent(\%args, \%alias_args) then if utils.equivalent(\%args, \%alias_args) then
lua:append("COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), "]") lua:append("COMPILE_ACTIONS[", \%actions[1].stub:as_lua(), "]")
@ -114,14 +114,14 @@ test:
compile [local action %actions %body] to: compile [local action %actions %body] to:
lua> "\ lua> "\
..local fn_name = \%actions[1].stub:as_lua_id() ..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end) local \%args = table.map(\%actions[1]:get_args(), function(a) return nomsu:compile(a):as_smext() end)
local lua = LuaCode(tree.source, fn_name, " = ", \(compile as (%args -> %body))) local lua = LuaCode(tree.source, fn_name, " = ", \(compile as (%args -> %body)))
lua:add_free_vars({fn_name}) lua:add_free_vars({fn_name})
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id() local alias_name = alias.stub:as_lua_id()
lua:add_free_vars({alias_name}) lua:add_free_vars({alias_name})
local \%alias_args = table.map(alias:get_args(), function(a) return tostring(nomsu:compile(a)) end) local \%alias_args = table.map(alias:get_args(), function(a) return nomsu:compile(a):as_smext() end)
lua:append("\\n", alias_name, " = ") lua:append("\\n", alias_name, " = ")
if utils.equivalent(\%args, \%alias_args) then if utils.equivalent(\%args, \%alias_args) then
lua:append(fn_name) lua:append(fn_name)
@ -170,7 +170,7 @@ compile [parse %actions as %body] to (..)
lua> "\ lua> "\
..local replacements = {} ..local replacements = {}
for i,arg in ipairs(\%actions[1]:get_args()) do for i,arg in ipairs(\%actions[1]:get_args()) do
replacements[arg[1]] = tostring(nomsu:compile(arg)) replacements[arg[1]] = nomsu:compile(arg):as_smext()
end end
local function make_tree(t) local function make_tree(t)
if AST.is_syntax_tree(t, "Var") then if AST.is_syntax_tree(t, "Var") then
@ -239,7 +239,7 @@ action [%var as lua identifier, %var as lua id] (..)
elseif AST.is_syntax_tree(\%var, 'Var') then return \%var[1]:as_lua_id() elseif AST.is_syntax_tree(\%var, 'Var') then return \%var[1]:as_lua_id()
elseif AST.is_syntax_tree(\%var) then elseif AST.is_syntax_tree(\%var) then
local lua = \(%var as lua expr) local lua = \(%var as lua expr)
if not tostring(lua):match("^[_a-zA-Z][_a-zA-Z0-9]*$") then if not lua:as_smext():match("^[_a-zA-Z][_a-zA-Z0-9]*$") then
nomsu:compile_error(\%var, "This is not a valid Lua identifier.") nomsu:compile_error(\%var, "This is not a valid Lua identifier.")
end end
return lua return lua

8
core/operators.nom
View File

@ -34,7 +34,7 @@ compile [%var = %value] to:
lua> "\ lua> "\
..local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';') ..local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
if \%var.type == 'Var' then if \%var.type == 'Var' then
lua:add_free_vars({tostring(nomsu:compile(\%var))}) lua:add_free_vars({nomsu:compile(\%var):as_smext()})
end end
return lua" return lua"
@ -66,7 +66,7 @@ compile [set %assignments] to:
%value as text %value as text
..) end ..) end
if \%target.type == "Var" then if \%target.type == "Var" then
lhs:add_free_vars({tostring(target_lua)}) lhs:add_free_vars({target_lua:as_smext()})
end end
if i > 1 then if i > 1 then
lhs:append(", ") lhs:append(", ")
@ -107,7 +107,7 @@ test:
compile [with external %externs %body] to: compile [with external %externs %body] to:
%body_lua = (%body as lua statements) %body_lua = (%body as lua statements)
lua> "\ lua> "\
..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))" ..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return nomsu:compile(v):as_smext() end))"
return %body_lua return %body_lua
test: test:
@ -141,7 +141,7 @@ compile [with %assignments %body] to:
lhs:append(target_lua) lhs:append(target_lua)
rhs:append(value_lua) rhs:append(value_lua)
if \%target.type == "Var" then if \%target.type == "Var" then
vars[i] = tostring(target_lua) vars[i] = target_lua:as_smext()
end end
end end
\%lua:remove_free_vars(vars) \%lua:remove_free_vars(vars)

3
nomnom/ast.nom
View File

@ -16,6 +16,8 @@ object (Syntax Tree):
%stub_bits::add "\%argnum" %stub_bits::add "\%argnum"
%argnum += 1 %argnum += 1
%me.stub = (%stub_bits::joined with " ") %me.stub = (%stub_bits::joined with " ")
if (%me.stub == "Lua Code 1 2"):
lua> "require('ldt').breakpoint()"
(Syntax Tree).source_code_for_tree = (..) (Syntax Tree).source_code_for_tree = (..)
{} with fallback % -> (read file %.source.filename) {} with fallback % -> (read file %.source.filename)
@ -86,3 +88,4 @@ object (Syntax Tree):
%args::add % %args::add %
return %args return %args
(Syntax Tree).map = (Syntax Tree).map_1

60
nomnom/code_obj.nom
View File

@ -14,11 +14,10 @@ object (Code):
for % in %old_bits: for % in %old_bits:
%me::add % %me::add %
%depth = 0
my action [as text]: my action [as text]:
external %depth = (%depth + 1) barf "Not implemented"
if (%depth > 10):
lua> "require('ldt').breakpoint()" my action [as smext]:
if (%me.__str == (nil)): if (%me.__str == (nil)):
set {%buff:[], %indent:0} set {%buff:[], %indent:0}
for %bit in %me.bits: for %bit in %me.bits:
@ -26,21 +25,21 @@ object (Code):
%spaces = (%bit::matching "\n([ ]*)[^\n]*$") %spaces = (%bit::matching "\n([ ]*)[^\n]*$")
if %spaces: %indent = (size of %spaces.1) if %spaces: %indent = (size of %spaces.1)
..else: ..else:
%bit = "\%bit" %bit = (%bit::as smext)
if (%indent > 0): if (%indent > 0):
%bit = (%bit::with "\n" -> "\n\(" "::* %indent)") %bit = (%bit::with "\n" -> "\n\(" "::* %indent)")
%buff::add %bit %buff::add %bit
%me.__str = (%buff::joined) %me.__str = (%buff::joined)
external %depth = (%depth - 1)
return %me.__str return %me.__str
my action [as lua] (..) my action [as lua]:
"\(%me.class.name::as lua id)_1_2(\(%me.source::as lua), \(%me.bits::as lua))" barf
return "\(%me.class.name::as lua id)_from_1_2(\(%me.source::as lua), \(%me.bits::as lua))"
my action [as nomsu] (..) my action [as nomsu] (..)
"(\(%me.class.name) \(%me.source::as nomsu) \(%me.bits::as nomsu))" "(\(%me.class.name) \(%me.source::as nomsu) \(%me.bits::as nomsu))"
my action [size] (size of "\%me") my action [size] (size of (%me::as smext))
my action [mark as dirty]: my action [mark as dirty]:
%me.__str = (nil) %me.__str = (nil)
@ -52,14 +51,14 @@ object (Code):
%new_bits = [%new_bits] %new_bits = [%new_bits]
for % in %new_bits: for % in %new_bits:
if (% == ""): do next % if (% == ""): do next %
if ((% isn't text) and (% isn't a (Code))): #if ((% isn't text) and (% isn't a (Code))):
% = (%::as lua) % = (%::as lua)
%me.bits::add % %me.bits::add %
%me::mark as dirty %me::mark as dirty
my action [trailing line length]: my action [trailing line length]:
if (%me._trailing_line_len == (nil)): if (%me._trailing_line_len == (nil)):
%me._trailing_line_len = (size of ("\%me"::matching "[^\n]*$")) %me._trailing_line_len = (size of ((%me::as smext)::matching "[^\n]*$"))
return %me._trailing_line_len return %me._trailing_line_len
my action [number of lines]: my action [number of lines]:
@ -83,7 +82,6 @@ object (Code):
%line_len = 0 %line_len = 0
%bits = %me.bits %bits = %me.bits
for %value in %values at %i: for %value in %values at %i:
assume (%value != %me)
if (%i > 1): if (%i > 1):
if (%line_len > 80): if (%line_len > 80):
%bits::add %wrapping_joiner %bits::add %wrapping_joiner
@ -91,7 +89,9 @@ object (Code):
..else: ..else:
%bits::add %joiner %bits::add %joiner
%bits::add %value %bits::add %value
%line = ("\%value"::matching "\n([^\n]*)$") unless (%value is text):
%value = (%value::as smext)
%line = (%value::matching "\n([^\n]*)$")
if %line: if %line:
%line_len = (size of %line) %line_len = (size of %line)
..else: ..else:
@ -99,7 +99,7 @@ object (Code):
%me::mark as dirty %me::mark as dirty
my action [prepend %]: my action [prepend %]:
if ((% isn't text) and (% isn't a %me.__type)): #if ((% isn't text) and (% isn't a %me.__type)):
% = (%::as lua) % = (%::as lua)
%me.bits::add % at index 1 %me.bits::add % at index 1
%me::mark as dirty %me::mark as dirty
@ -129,17 +129,21 @@ object (Lua Code) extends (Code):
%removals.%var = (yes) %removals.%var = (yes)
%stack = [%me] %stack = [%me]
while ((size of %stack) > 0): repeat while ((size of %stack) > 0):
%lua = (%stack::pop) %lua = (%stack::pop)
for %i in (size of %lua.free_vars) to 1 by -1: for %i in (size of %lua.free_vars) to 1 by -1:
if %removals.(%lua.%free_vars.%i): if %removals.(%lua.free_vars.%i):
%lua.free_vars::remove index %i lua> "table.remove(\%lua.free_vars, \%i)"
#TODO: reinstate this
#%lua.free_vars::remove at index %i
for % in %lua.bits: for % in %lua.bits:
if (% is a "Lua Code"): unless (% is text):
%stack::add % %stack::add %
%me::mark as dirty %me::mark as dirty
my action [declare locals]: my action [declare locals] (%me::declare locals (nil))
my action [declare locals %to_declare]:
unless %to_declare:
set {%to_declare:[], %seen:{}} set {%to_declare:[], %seen:{}}
for %lua in recursive %me: for %lua in recursive %me:
for %var in %lua.free_vars: for %var in %lua.free_vars:
@ -147,11 +151,8 @@ object (Lua Code) extends (Code):
%seen.%var = (yes) %seen.%var = (yes)
%to_declare::add %var %to_declare::add %var
for % in %lua.bits: for % in %lua.bits:
if (% is a "Lua Code"): unless (% is text):
recurse %lua on % recurse %lua on %
return (%me::declare locals %to_declare)
my action [declare locals %to_declare]:
if ((size of %to_declare) > 0): if ((size of %to_declare) > 0):
%me::remove free vars %to_declare %me::remove free vars %to_declare
%me::prepend "local \(%to_declare::joined with ", ");\n" %me::prepend "local \(%to_declare::joined with ", ");\n"
@ -163,11 +164,11 @@ object (Lua Code) extends (Code):
unless %me.is_value: unless %me.is_value:
return %me return %me
%statements = (Lua Code from %me.source []) %statements = (Lua Code from %me.source [])
if (%prefix != ""): if ((%prefix or "") != ""):
%statements::add %prefix %statements::add %prefix
%statements::add %me %statements::add %me
if (%suffix != ""): if (%suffix != ""):
%statements::add %suffix %statements::add (%suffix or ";")
return %statements return %statements
action [Lua Code from %source %bits]: action [Lua Code from %source %bits]:
@ -176,12 +177,17 @@ object (Lua Code) extends (Code):
return (..) return (..)
Lua Code {source:%source, bits:%bits, is_value:(no), free_vars:[]} Lua Code {source:%source, bits:%bits, is_value:(no), free_vars:[]}
action [Lua Code from %source] (Lua Code from %source []) action [Lua Code from %source] (Lua Code from %source [])
action [Lua Value from %tree %bits]: action [Lua Value from %source %bits]:
if (%bits is text): %bits = [%bits] if (%bits is text): %bits = [%bits]
if (%source is a "Syntax Tree"): %source = %source.source if (%source is a "Syntax Tree"): %source = %source.source
return (..) return (..)
Lua Code {source:%source, bits:%bits, is_value:(yes), free_vars:[]} Lua Code {source:%source, bits:%bits, is_value:(yes), free_vars:[]}
action [Lua Value from %tree] (Lua Value from %tree []) action [Lua Value from %source] (Lua Value from %source [])
(Lua Code).add_free_vars = (Lua Code).add_free_vars_1
(Lua Code).remove_free_vars = (Lua Code).remove_free_vars_1
(Lua Code).declare_locals = (Lua Code).declare_locals_1
(Lua Code).as_statements = (Lua Code).as_statements_1_2
object (Nomsu Code) extends (Code): object (Nomsu Code) extends (Code):
action [Nomsu Code from %source %bits]: action [Nomsu Code from %source %bits]:

30
nomnom/compile.nom
View File

@ -4,6 +4,7 @@ use "nomnom/code_obj.nom"
use "nomnom/parser.nom" use "nomnom/parser.nom"
use "nomnom/pretty_errors.nom" use "nomnom/pretty_errors.nom"
# TODO: use pretty_errors
local action [report compile error at %pos %err]: local action [report compile error at %pos %err]:
barf "Compile error at \%pos: \%err" barf "Compile error at \%pos: \%err"
@ -23,7 +24,9 @@ action [compile %tree using %compile_actions]:
%compile_action = %compile_actions.%stub %compile_action = %compile_actions.%stub
# Don't apply compiler actions to methods # Don't apply compiler actions to methods
if (%compile_action and (not %tree.target)): if (%compile_action and (not %tree.target)):
%args = ["tree", "compile_actions"] # TODO: restore this:
#%args = [%tree, %compile_actions]
%args = [%nomsu, %tree]
for % in (%tree::get args): %args::add % for % in (%tree::get args): %args::add %
%result = (call %compile_action with %args) %result = (call %compile_action with %args)
if (%result == (nil)): if (%result == (nil)):
@ -43,7 +46,7 @@ action [compile %tree using %compile_actions]:
%lua = (Lua Value from %tree) %lua = (Lua Value from %tree)
if %tree.target: # Method call if %tree.target: # Method call
%target_lua = (compile %tree.target using %compile_actions) %target_lua = (compile %tree.target using %compile_actions)
if (("\%target_lua"::matches "^%(.*%)$") or ("\%target_lua"::matches "^[_a-zA-Z][_a-zA-Z0-9]*$")): if (((%target_lua::as smext)::matches "^%(.*%)$") or ((%target_lua::as smext)::matches "^[_a-zA-Z][_a-zA-Z0-9]*$")):
%lua::add [%target_lua, ":"] %lua::add [%target_lua, ":"]
..else: ..else:
%lua::add ["(", %target_lua, "):"] %lua::add ["(", %target_lua, "):"]
@ -51,12 +54,13 @@ action [compile %tree using %compile_actions]:
%args = [] %args = []
for %tok in %tree at %i: for %tok in %tree at %i:
if (%tok is text): do next %tok if (%tok is text): do next %tok
# TODO: maybe translate Lua comments # TODO: maybe don't translate Lua comments
if (%tok.type == "Comment"): do next %tok #if (%tok.type == "Comment"): do next %tok
if (%tok.type == "Block"): if (%tok.type == "Block"):
%values = (..) %values = []
(compile %line using %compile_actions) for %line in %tok for %line in %tok:
..unless (%line.type == "Comment") #unless (%line.type == "Comment"):
%values::add (compile %line using %compile_actions)
if all of (%.is_value for % in %values): if all of (%.is_value for % in %values):
if ((size of %values) == 1): if ((size of %values) == 1):
%arg_lua = %values.1 %arg_lua = %values.1
@ -153,11 +157,11 @@ action [compile %tree using %compile_actions]:
unless %value_lua.is_value: unless %value_lua.is_value:
report compile error at %tree.2 "\ report compile error at %tree.2 "\
..Can't use this as a dict value, since it's not an expression." ..Can't use this as a dict value, since it's not an expression."
%key_str = ("\%key_lua"::matching "^[\"']([a-zA-Z_][a-zA-Z0-9_]*)['\"]$") %key_str = ((%key_lua::as smext)::matching "^[\"']([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
if: if:
%key_str: %key_str:
return (Lua Code from %tree [%key_str, "=", %value_lua]) return (Lua Code from %tree [%key_str, "=", %value_lua])
("\%key_lua".1 == "["): ((%key_lua::as smext).1 == "["):
# NOTE: this *must* use a space after the [ to avoid freaking out # NOTE: this *must* use a space after the [ to avoid freaking out
Lua's parser if the inner expression is a long string. Lua Lua's parser if the inner expression is a long string. Lua
parses x[[[y]]] as x("[y]"), not as x["y"] parses x[[[y]]] as x("[y]"), not as x["y"]
@ -170,7 +174,7 @@ action [compile %tree using %compile_actions]:
unless %lua.is_value: unless %lua.is_value:
report compile error at %tree.1 "\ report compile error at %tree.1 "\
..Can't index into this, since it's not an expression." ..Can't index into this, since it's not an expression."
%first_char = "\%lua".1 %first_char = (%lua::as smext).1
if (any of [%first_char == "{", %first_char == "\"", %first_char == "["]): if (any of [%first_char == "{", %first_char == "\"", %first_char == "["]):
%lua::parenthesize %lua::parenthesize
@ -180,7 +184,7 @@ action [compile %tree using %compile_actions]:
unless %key_lua.is_value: unless %key_lua.is_value:
report compile error at %key "\ report compile error at %key "\
..Can't use this as an index, since it's not an expression." ..Can't use this as an index, since it's not an expression."
%key_lua_str = "\%key_lua" %key_lua_str = (%key_lua::as smext)
%lua_id = (%key_lua_str::matching "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$") %lua_id = (%key_lua_str::matching "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
if: if:
%lua_id: %lua_id:
@ -206,8 +210,8 @@ action [compile %tree using %compile_actions]:
..compilation depends on the earlier chunks" ..compilation depends on the earlier chunks"
"Comment": "Comment":
# TODO: implement? # TODO: de-implement?
return (Lua Code from %tree) return (Lua Code from %tree "-- \(%tree.1::with "\n" -> "\n-- ")")
"Error": "Error":
barf "Can't compile errors" barf "Can't compile errors"

2
nomnom/decompile.nom
View File

@ -266,7 +266,7 @@ action [decompile %tree]:
(((size of %line) > 10) and ((%nomsu::trailing line length) > %max_line)): (((size of %line) > 10) and ((%nomsu::trailing line length) > %max_line)):
%nomsu::add "\\\n.." %nomsu::add "\\\n.."
while ((size of %line) > 0): repeat while ((size of %line) > 0):
%space = (%max_line - (%nomsu::trailing line length)) %space = (%max_line - (%nomsu::trailing line length))
%split = (%line::position of "[%p%s]" after %space) %split = (%line::position of "[%p%s]" after %space)
if ((not %split) or (%split > %space + 10)): if ((not %split) or (%split > %space + 10)):

2
nomnom/parser.nom
View File

@ -30,7 +30,7 @@ set {..}
Tree: [%t, %userdata] ->: Tree: [%t, %userdata] ->:
%source = (..) %source = (..)
Source {filename:%userdata.filename, start:%t.start, stop:%t.stop} Source {filename:%userdata.filename, start:%t.start, stop:%t.stop}
set {%t.start: nil, %t.stop: nil} set {%t.start: nil, %t.stop: nil, %t.source: %source}
%t = (Syntax Tree %t) %t = (Syntax Tree %t)
(Syntax Tree).source_code_for_tree.%t = %userdata.source (Syntax Tree).source_code_for_tree.%t = %userdata.source
return %t return %t

3
syntax_tree.moon
View File

@ -6,7 +6,7 @@ unpack or= table.unpack
AST = {} AST = {}
AST.is_syntax_tree = (n, t=nil)-> AST.is_syntax_tree = (n, t=nil)->
type(n) == 'table' and getmetatable(n) and AST[n.type] == getmetatable(n) and (t == nil or n.type == t) type(n) == 'table' and getmetatable(n) and getmetatable(n).__type == "Syntax Tree" and (t == nil or n.type == t)
as_lua = => as_lua = =>
if type(@) == 'number' if type(@) == 'number'
@ -25,6 +25,7 @@ for name in *types
.__index = cls .__index = cls
.__name = name .__name = name
.type = name .type = name
.__type = "Syntax Tree"
.is_instance = (x)=> getmetatable(x) == @ .is_instance = (x)=> getmetatable(x) == @
.__tostring = => .__tostring = =>
bits = [tostring(b) for b in *@] bits = [tostring(b) for b in *@]