Renamed append/concat_append to add/concat_add for Code objects.
This commit is contained in:
parent
09e571ffa6
commit
efd743591e
14
code_obj.lua
14
code_obj.lua
@ -154,7 +154,7 @@ do
|
||||
self._is_multiline = nil
|
||||
end
|
||||
end,
|
||||
append = function(self, ...)
|
||||
add = function(self, ...)
|
||||
local n = select("#", ...)
|
||||
local match = string.match
|
||||
local bits = self.bits
|
||||
@ -206,7 +206,7 @@ do
|
||||
end
|
||||
return self._is_multiline
|
||||
end,
|
||||
concat_append = function(self, values, joiner, wrapping_joiner)
|
||||
concat_add = function(self, values, joiner, wrapping_joiner)
|
||||
wrapping_joiner = wrapping_joiner or joiner
|
||||
local match = string.match
|
||||
local bits = self.bits
|
||||
@ -254,14 +254,14 @@ do
|
||||
end,
|
||||
parenthesize = function(self)
|
||||
self:prepend("(")
|
||||
return self:append(")")
|
||||
return self:add(")")
|
||||
end
|
||||
}
|
||||
_base_0.__index = _base_0
|
||||
_class_0 = setmetatable({
|
||||
__init = function(self, ...)
|
||||
self.bits = { }
|
||||
return self:append(...)
|
||||
return self:add(...)
|
||||
end,
|
||||
__base = _base_0,
|
||||
__name = "Code"
|
||||
@ -418,7 +418,7 @@ do
|
||||
end,
|
||||
parenthesize = function(self)
|
||||
self:prepend("(")
|
||||
return self:append(")")
|
||||
return self:add(")")
|
||||
end
|
||||
}
|
||||
_base_0.__index = _base_0
|
||||
@ -496,8 +496,8 @@ do
|
||||
end
|
||||
NomsuCode = _class_0
|
||||
end
|
||||
Code.__base.add_1_joined_with = assert(Code.__base.concat_append)
|
||||
Code.__base.add = assert(Code.__base.append)
|
||||
Code.__base.add_1_joined_with = assert(Code.__base.concat_add)
|
||||
Code.__base.add = assert(Code.__base.add)
|
||||
return {
|
||||
Code = Code,
|
||||
NomsuCode = NomsuCode,
|
||||
|
||||
@ -44,7 +44,7 @@ class Source
|
||||
class Code
|
||||
new: (...)=>
|
||||
@bits = {}
|
||||
@append(...)
|
||||
@add(...)
|
||||
|
||||
@from: (source, ...)=>
|
||||
inst = self(...)
|
||||
@ -91,7 +91,7 @@ class Code
|
||||
-- Multi-line only goes from false->true, since there is no API for removing bits
|
||||
@_is_multiline = nil if @_is_multiline == false
|
||||
|
||||
append: (...)=>
|
||||
add: (...)=>
|
||||
n = select("#",...)
|
||||
match = string.match
|
||||
bits = @bits
|
||||
@ -123,7 +123,7 @@ class Code
|
||||
break
|
||||
return @_is_multiline
|
||||
|
||||
concat_append: (values, joiner, wrapping_joiner)=>
|
||||
concat_add: (values, joiner, wrapping_joiner)=>
|
||||
wrapping_joiner or= joiner
|
||||
match = string.match
|
||||
bits = @bits
|
||||
@ -160,7 +160,7 @@ class Code
|
||||
|
||||
parenthesize: =>
|
||||
@prepend "("
|
||||
@append ")"
|
||||
@add ")"
|
||||
|
||||
class LuaCode extends Code
|
||||
__tostring: Code.__tostring
|
||||
@ -239,14 +239,14 @@ class LuaCode extends Code
|
||||
|
||||
parenthesize: =>
|
||||
@prepend "("
|
||||
@append ")"
|
||||
@add ")"
|
||||
|
||||
class NomsuCode extends Code
|
||||
__tostring: Code.__tostring
|
||||
as_lua: Code.as_lua
|
||||
__len: Code.__len
|
||||
|
||||
Code.__base.add_1_joined_with = assert Code.__base.concat_append
|
||||
Code.__base.add = assert Code.__base.append
|
||||
Code.__base.add_1_joined_with = assert Code.__base.concat_add
|
||||
Code.__base.add = assert Code.__base.add
|
||||
|
||||
return {:Code, :NomsuCode, :LuaCode, :Source}
|
||||
|
||||
@ -16,9 +16,9 @@ upgrade action [add %item to %list at index %i] to "3.6" as (..)
|
||||
upgrade action [pop from %list, remove last from %list] to "3.6" as (%list::pop)
|
||||
upgrade action [remove index %index from %list] to "3.6" as (..)
|
||||
%list::remove index %index
|
||||
upgrade action [to %1 write %2, %1 <-write %2] to "3.6" as (%1::append %2)
|
||||
upgrade action [to %1 write %2, %1 <-write %2] to "3.6" as (%1::add %2)
|
||||
upgrade action [to %1 write %2 joined by %3] to "3.6" as (..)
|
||||
%1::append %2 joined by %3
|
||||
%1::add %2 joined by %3
|
||||
upgrade action [declare locals in %lua] to "3.6" as (%lua::declare locals)
|
||||
upgrade action [declare locals %locs in %lua] to "3.6" as (..)
|
||||
%lua::declare locals %locs
|
||||
|
||||
@ -49,10 +49,10 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
|
||||
return (quote %t)
|
||||
|
||||
unless ("\%lua" == ""):
|
||||
%lua::append "\n"
|
||||
%lua::add "\n"
|
||||
|
||||
%retval = (make tree %body)
|
||||
%lua::append (..)
|
||||
%lua::add (..)
|
||||
Lua "\
|
||||
..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(\%tree as lua id))
|
||||
return \%retval
|
||||
|
||||
@ -131,8 +131,8 @@ test:
|
||||
(repeat while %condition %body) compiles to:
|
||||
%lua = (Lua "while \(%condition as lua expr) do\n \(%body as lua)")
|
||||
if (%body has subtree \(do next)):
|
||||
%lua::append "\n ::continue::"
|
||||
%lua::append "\nend --while-loop"
|
||||
%lua::add "\n ::continue::"
|
||||
%lua::add "\nend --while-loop"
|
||||
return %lua
|
||||
|
||||
(repeat %body) parses as (repeat while (yes) %body)
|
||||
@ -167,20 +167,20 @@ test:
|
||||
..all compile to:
|
||||
# This uses Lua's approach of only allowing loop-scoped variables in a loop
|
||||
%lua = (Lua "for \(%var as lua identifier)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do")
|
||||
%lua::append "\n " (%body as lua)
|
||||
%lua::add "\n " (%body as lua)
|
||||
if (%body has subtree \(do next)):
|
||||
%lua::append "\n ::continue::"
|
||||
%lua::add "\n ::continue::"
|
||||
|
||||
if (%body has subtree \(do next %var)):
|
||||
%lua::append "\n " (\(---next %var ---) as lua)
|
||||
%lua::add "\n " (\(---next %var ---) as lua)
|
||||
|
||||
%lua::append "\nend --numeric for-loop"
|
||||
%lua::add "\nend --numeric for-loop"
|
||||
if (%body has subtree \(stop %var)):
|
||||
%inner_lua = %lua
|
||||
%lua = (Lua "do -- scope for stopping for-loop\n ")
|
||||
%lua::append %inner_lua "\n "
|
||||
%lua::append (\(---stop %var ---) as lua)
|
||||
%lua::append "\nend -- end of scope for stopping for-loop"
|
||||
%lua::add %inner_lua "\n "
|
||||
%lua::add (\(---stop %var ---) as lua)
|
||||
%lua::add "\nend -- end of scope for stopping for-loop"
|
||||
return %lua
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
@ -219,20 +219,20 @@ test:
|
||||
Lua "\
|
||||
..for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
|
||||
"
|
||||
%lua::append (%body as lua)
|
||||
%lua::add (%body as lua)
|
||||
if (%body has subtree \(do next)):
|
||||
%lua::append "\n ::continue::"
|
||||
%lua::add "\n ::continue::"
|
||||
|
||||
if (%body has subtree \(do next %var)):
|
||||
%lua::append "\n " (\(---next %var ---) as lua)
|
||||
%lua::add "\n " (\(---next %var ---) as lua)
|
||||
|
||||
%lua::append "\nend --for \(%var as lua identifier) loop"
|
||||
%lua::add "\nend --for \(%var as lua identifier) loop"
|
||||
if (%body has subtree \(stop %var)):
|
||||
%inner_lua = %lua
|
||||
%lua = (Lua "do -- scope for stopping for-loop\n ")
|
||||
%lua::append %inner_lua "\n "
|
||||
%lua::append (\(---stop %var ---) as lua)
|
||||
%lua::append "\nend -- end of scope for stopping for-loop"
|
||||
%lua::add %inner_lua "\n "
|
||||
%lua::add (\(---stop %var ---) as lua)
|
||||
%lua::add "\nend -- end of scope for stopping for-loop"
|
||||
return %lua
|
||||
|
||||
(for %var in %iterable %body) parses as (..)
|
||||
@ -255,28 +255,28 @@ test:
|
||||
[for %key = %value in %iterable %body, for %key %value in %iterable %body] \
|
||||
..all compile to:
|
||||
%lua = (Lua "for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do")
|
||||
%lua::append "\n " (%body as lua)
|
||||
%lua::add "\n " (%body as lua)
|
||||
if (%body has subtree \(do next)):
|
||||
%lua::append "\n ::continue::"
|
||||
%lua::add "\n ::continue::"
|
||||
|
||||
if (%body has subtree \(do next %key)):
|
||||
%lua::append "\n " (\(---next %key ---) as lua)
|
||||
%lua::add "\n " (\(---next %key ---) as lua)
|
||||
|
||||
if (%body has subtree \(do next %value)):
|
||||
%lua::append "\n " (\(---next %value ---) as lua)
|
||||
%lua::add "\n " (\(---next %value ---) as lua)
|
||||
|
||||
%lua::append "\nend --foreach-loop"
|
||||
%lua::add "\nend --foreach-loop"
|
||||
%stop_labels = (Lua "")
|
||||
if (%body has subtree \(stop %key)):
|
||||
%stop_labels::append "\n" (\(---stop %key ---) as lua)
|
||||
%stop_labels::add "\n" (\(---stop %key ---) as lua)
|
||||
|
||||
if (%body has subtree \(stop %value)):
|
||||
%stop_labels::append "\n" (\(---stop %value ---) as lua)
|
||||
%stop_labels::add "\n" (\(---stop %value ---) as lua)
|
||||
|
||||
if ((size of "\%stop_labels") > 0):
|
||||
%inner_lua = %lua
|
||||
%lua = (Lua "do -- scope for stopping for % = % loop\n ")
|
||||
%lua::append %inner_lua %stop_labels "\nend"
|
||||
%lua::add %inner_lua %stop_labels "\nend"
|
||||
|
||||
return %lua
|
||||
|
||||
@ -326,22 +326,22 @@ test:
|
||||
..If you want the code in this block to always execute, you don't need a conditional block around it. \
|
||||
..Otherwise, make sure the 'else' block comes last."
|
||||
|
||||
%code::append "\nelse\n " (%action as lua)
|
||||
%code::add "\nelse\n " (%action as lua)
|
||||
%else_allowed = (no)
|
||||
..else:
|
||||
%code::append %clause " "
|
||||
%code::add %clause " "
|
||||
for %i in 1 to ((size of %line) - 1):
|
||||
if (%i > 1):
|
||||
%code::append " or "
|
||||
%code::append (%line.%i as lua expr)
|
||||
%code::append " then\n " (%action as lua)
|
||||
%code::add " or "
|
||||
%code::add (%line.%i as lua expr)
|
||||
%code::add " then\n " (%action as lua)
|
||||
%clause = "\nelseif"
|
||||
|
||||
if ((size of "\%code") == 0):
|
||||
compile error at %body "'if' block has an empty body." "\
|
||||
..This means nothing would happen, so the 'if' block should be deleted."
|
||||
|
||||
%code::append "\nend --when"
|
||||
%code::add "\nend --when"
|
||||
return %code
|
||||
|
||||
test:
|
||||
@ -388,22 +388,22 @@ test:
|
||||
..If you want the code in this block to always execute, you don't need a conditional block around it. \
|
||||
..Otherwise, make sure the 'else' block comes last."
|
||||
|
||||
%code::append "\nelse\n " (%action as lua)
|
||||
%code::add "\nelse\n " (%action as lua)
|
||||
%else_allowed = (no)
|
||||
..else:
|
||||
%code::append %clause " "
|
||||
%code::add %clause " "
|
||||
for %i in 1 to ((size of %line) - 1):
|
||||
if (%i > 1):
|
||||
%code::append " or "
|
||||
%code::append "\(mangle "branch value") == " (%line.%i as lua expr)
|
||||
%code::append " then\n " (%action as lua)
|
||||
%code::add " or "
|
||||
%code::add "\(mangle "branch value") == " (%line.%i as lua expr)
|
||||
%code::add " then\n " (%action as lua)
|
||||
%clause = "\nelseif"
|
||||
|
||||
if ((size of "\%code") == 0):
|
||||
compile error at %body "'if' block has an empty body." "\
|
||||
..This means nothing would happen, so the 'if' block should be deleted."
|
||||
|
||||
%code::append "\nend --when"
|
||||
%code::add "\nend --when"
|
||||
return (..)
|
||||
Lua "\
|
||||
..do --if % is...
|
||||
@ -470,13 +470,13 @@ test:
|
||||
\(%body as lua)"
|
||||
|
||||
if (%body has subtree \(do next)):
|
||||
%lua::append "\n ::continue::"
|
||||
%lua::add "\n ::continue::"
|
||||
|
||||
if (%body has subtree \(do next %var)):
|
||||
%lua::append "\n \(\(---next %var ---) as lua)"
|
||||
%lua::add "\n \(\(---next %var ---) as lua)"
|
||||
|
||||
%lua::append "\n end -- Recursive loop"
|
||||
%lua::add "\n end -- Recursive loop"
|
||||
if (%body has subtree \(stop %var)):
|
||||
%lua::append "\n \(\(---stop %var ---) as lua)"
|
||||
%lua::append "\nend -- Recursive scope"
|
||||
%lua::add "\n \(\(---stop %var ---) as lua)"
|
||||
%lua::add "\nend -- Recursive scope"
|
||||
return %lua
|
||||
|
||||
@ -79,7 +79,7 @@ externally [all of %items, all %items] all mean:
|
||||
|
||||
%lua = (Lua "(")
|
||||
%lua::add [: for % in %items: add (% as lua expr)] joined with " and "
|
||||
%lua::append ")"
|
||||
%lua::add ")"
|
||||
return %lua
|
||||
|
||||
[not all of %items, not all %items] all parse as (not (all of %items))
|
||||
@ -98,7 +98,7 @@ externally [any of %items, any %items] all mean:
|
||||
|
||||
%lua = (Lua "(")
|
||||
%lua::add [: for % in %items: add (% as lua expr)] joined with " or "
|
||||
%lua::append ")"
|
||||
%lua::add ")"
|
||||
return %lua
|
||||
|
||||
[none of %items, none %items] all parse as (not (any of %items))
|
||||
@ -119,7 +119,7 @@ externally [sum of %items, sum %items] all mean:
|
||||
|
||||
%lua = (Lua "(")
|
||||
%lua::add [: for % in %items: add (% as lua expr)] joined with " + "
|
||||
%lua::append ")"
|
||||
%lua::add ")"
|
||||
return %lua
|
||||
|
||||
externally [product of %items, product %items] all mean:
|
||||
@ -137,7 +137,7 @@ externally [product of %items, product %items] all mean:
|
||||
|
||||
%lua = (Lua "(")
|
||||
%lua::add [: for % in %items: add (% as lua expr)] joined with " * "
|
||||
%lua::append ")"
|
||||
%lua::add ")"
|
||||
return %lua
|
||||
|
||||
externally [avg of %items, average of %items] all mean (..)
|
||||
|
||||
@ -40,11 +40,11 @@ lua> "\
|
||||
"This does not compile to a Lua identifier, so it can't be used as a function argument.",
|
||||
"This should probably be a Nomsu variable instead (like %x).")
|
||||
end
|
||||
lua:append(i > 1 and ", " or "", arg_lua)
|
||||
lua:add(i > 1 and ", " or "", arg_lua)
|
||||
body_lua:remove_free_vars({arg_lua})
|
||||
end
|
||||
body_lua:declare_locals()
|
||||
lua:append(")\\n ", body_lua, "\\nend)")
|
||||
lua:add(")\\n ", body_lua, "\\nend)")
|
||||
return lua
|
||||
end
|
||||
compile.action["->"] = compile.action["1 ->"]
|
||||
@ -55,8 +55,8 @@ lua> "\
|
||||
local lua = LuaCode("compile.action[", \%action.stub:as_lua(), "](")
|
||||
local lua_args = table.map(\%action:get_args(), compile)
|
||||
table.insert(lua_args, 1, "compile")
|
||||
lua:concat_append(lua_args, ", ")
|
||||
lua:append(")")
|
||||
lua:concat_add(lua_args, ", ")
|
||||
lua:add(")")
|
||||
return lua
|
||||
end"
|
||||
|
||||
@ -106,15 +106,15 @@ lua> "\
|
||||
for i=2,#\%actions do
|
||||
local alias = \%actions[i]
|
||||
local \%alias_args = List{\(\%compile), unpack(alias:get_args())}
|
||||
lua:append("\\ncompile.action[", alias.stub:as_lua(), "] = ")
|
||||
lua:add("\\ncompile.action[", alias.stub:as_lua(), "] = ")
|
||||
if \%alias_args == \%args then
|
||||
lua:append("compile.action[", \%actions[1].stub:as_lua(), "]")
|
||||
lua:add("compile.action[", \%actions[1].stub:as_lua(), "]")
|
||||
else
|
||||
lua:append("function(")
|
||||
lua:concat_append(table.map(\%alias_args, compile), ", ")
|
||||
lua:append(") return compile.action[", \%actions[1].stub:as_lua(), "](")
|
||||
lua:concat_append(\%compiled_args, ", ")
|
||||
lua:append(") end")
|
||||
lua:add("function(")
|
||||
lua:concat_add(table.map(\%alias_args, compile), ", ")
|
||||
lua:add(") return compile.action[", \%actions[1].stub:as_lua(), "](")
|
||||
lua:concat_add(\%compiled_args, ", ")
|
||||
lua:add(") end")
|
||||
end
|
||||
end
|
||||
return lua"
|
||||
@ -137,9 +137,9 @@ test:
|
||||
..
|
||||
local lua = LuaCode()
|
||||
local fn_name = \%action.stub:as_lua_id()
|
||||
if \%action.target then lua:append(compile(\%action.target), ".")
|
||||
if \%action.target then lua:add(compile(\%action.target), ".")
|
||||
else lua:add_free_vars({fn_name}) end
|
||||
lua:append(fn_name, " = ", \(\(%action -> %body) as lua), ";")
|
||||
lua:add(fn_name, " = ", \(\(%action -> %body) as lua), ";")
|
||||
return lua"
|
||||
|
||||
(%actions all mean %body) compiles to:
|
||||
@ -152,18 +152,18 @@ test:
|
||||
local alias = \%actions[i]
|
||||
local alias_name = alias.stub:as_lua_id()
|
||||
local \%alias_args = List(alias:get_args())
|
||||
lua:append("\\n")
|
||||
lua:add("\\n")
|
||||
if alias.target then
|
||||
lua:append(compile(alias.target), ".")
|
||||
lua:add(compile(alias.target), ".")
|
||||
else
|
||||
lua:add_free_vars({alias_name})
|
||||
end
|
||||
lua:append(alias_name, " = ")
|
||||
lua:add(alias_name, " = ")
|
||||
if \%args == \%alias_args then
|
||||
if target then lua:append(target, ".") end
|
||||
lua:append(fn_name, ";")
|
||||
if target then lua:add(target, ".") end
|
||||
lua:add(fn_name, ";")
|
||||
else
|
||||
lua:append(\(\(%alias_args -> %actions.1) as lua), ";")
|
||||
lua:add(\(\(%alias_args -> %actions.1) as lua), ";")
|
||||
end
|
||||
end
|
||||
return lua"
|
||||
@ -393,10 +393,10 @@ test:
|
||||
lua> "\
|
||||
..local lua = \(Lua "do return ")
|
||||
for i=1,select('#',...) do
|
||||
if i > 1 then lua:append(", ") end
|
||||
lua:append(_1_as_lua((select(i, ...))))
|
||||
if i > 1 then lua:add(", ") end
|
||||
lua:add(_1_as_lua((select(i, ...))))
|
||||
end
|
||||
lua:append(" end")
|
||||
lua:add(" end")
|
||||
return lua"
|
||||
|
||||
# Literals
|
||||
|
||||
@ -39,14 +39,14 @@ test:
|
||||
local lua = LuaCode()
|
||||
if \%var.type == "List" then
|
||||
for i, \%assignment in ipairs(\%var) do
|
||||
if i > 1 then lua:append(", ") end
|
||||
if i > 1 then lua:add(", ") end
|
||||
local assignment_lua = \(%assignment as lua expr)
|
||||
lua:append(assignment_lua)
|
||||
lua:add(assignment_lua)
|
||||
if \%assignment.type == 'Var' then
|
||||
lua:add_free_vars({assignment_lua:text()})
|
||||
end
|
||||
end
|
||||
lua:append(' = ')
|
||||
lua:add(' = ')
|
||||
if \%value.type == "List" then
|
||||
if #\%value ~= #\%var then
|
||||
compile_error_at(\%value,
|
||||
@ -55,21 +55,21 @@ test:
|
||||
..=' operator.")
|
||||
end
|
||||
for i, \%val in ipairs(\%value) do
|
||||
if i > 1 then lua:append(", ") end
|
||||
if i > 1 then lua:add(", ") end
|
||||
local val_lua = \(%val as lua expr)
|
||||
lua:append(val_lua)
|
||||
lua:add(val_lua)
|
||||
end
|
||||
lua:append(";")
|
||||
lua:add(";")
|
||||
else
|
||||
lua:append(\(%value as lua expr), ';')
|
||||
lua:add(\(%value as lua expr), ';')
|
||||
end
|
||||
else
|
||||
local var_lua = \(%var as lua expr)
|
||||
lua:append(var_lua)
|
||||
lua:add(var_lua)
|
||||
if \%var.type == 'Var' then
|
||||
lua:add_free_vars({var_lua:text()})
|
||||
end
|
||||
lua:append(' = ', \(%value as lua expr), ';')
|
||||
lua:add(' = ', \(%value as lua expr), ';')
|
||||
end
|
||||
return lua"
|
||||
|
||||
@ -122,11 +122,11 @@ test:
|
||||
end
|
||||
local value_lua = \%value and \(%value as lua) or "nil"
|
||||
if i > 1 then
|
||||
lhs:append(", ")
|
||||
rhs:append(", ")
|
||||
lhs:add(", ")
|
||||
rhs:add(", ")
|
||||
end
|
||||
lhs:append(target_lua)
|
||||
rhs:append(value_lua)
|
||||
lhs:add(target_lua)
|
||||
rhs:add(value_lua)
|
||||
vars[i] = target_lua:text()
|
||||
end
|
||||
\%lua:remove_free_vars(vars)
|
||||
|
||||
@ -66,11 +66,11 @@ test:
|
||||
local alias_name = alias.stub:as_lua_id()
|
||||
local \%alias_args = List(alias:get_args())
|
||||
table.insert(\%alias_args, 1, \(\%me))
|
||||
lua:append("\\nclass.", alias_name, " = ")
|
||||
lua:add("\\nclass.", alias_name, " = ")
|
||||
if \%args == \%alias_args then
|
||||
lua:append("class.", fn_name)
|
||||
lua:add("class.", fn_name)
|
||||
else
|
||||
lua:append(\(what (%alias_args -> %actions.1) compiles to))
|
||||
lua:add(\(what (%alias_args -> %actions.1) compiles to))
|
||||
end
|
||||
end
|
||||
return lua"
|
||||
|
||||
@ -75,18 +75,18 @@ local compile = setmetatable({
|
||||
[""] = function(compile, fn, ...)
|
||||
local lua = LuaCode()
|
||||
local fn_lua = compile(fn)
|
||||
lua:append(fn_lua)
|
||||
lua:add(fn_lua)
|
||||
if not (fn_lua:text():match("^%(.*%)$") or fn_lua:text():match("^[_a-zA-Z][_a-zA-Z0-9.]*$")) then
|
||||
lua:parenthesize()
|
||||
end
|
||||
lua:append("(")
|
||||
lua:add("(")
|
||||
for i = 1, select('#', ...) do
|
||||
if i > 1 then
|
||||
lua:append(", ")
|
||||
lua:add(", ")
|
||||
end
|
||||
lua:append(compile((select(i, ...))))
|
||||
lua:add(compile((select(i, ...))))
|
||||
end
|
||||
lua:append(")")
|
||||
lua:add(")")
|
||||
return lua
|
||||
end,
|
||||
["Lua"] = function(compile, code)
|
||||
@ -107,15 +107,15 @@ local compile = setmetatable({
|
||||
elseif bit.type == "Text" then
|
||||
bit_lua = operate_on_text(bit)
|
||||
elseif bit.type == "Block" then
|
||||
bit_lua = LuaCode:from(bit.source, "(function()", "\n local _lua = LuaCode:from(", tostring(bit.source):as_lua(), ")", "\n local function add(bit) _lua:append(bit) end", "\n local function join_with(glue)", "\n local old_bits = _lua.bits", "\n _lua = LuaCode:from(_lua.source)", "\n _lua:concat_append(old_bits, glue)", "\n end", "\n ", compile(bit), "\n return _lua", "\nend)()")
|
||||
bit_lua = LuaCode:from(bit.source, "(function()", "\n local _lua = LuaCode:from(", tostring(bit.source):as_lua(), ")", "\n local function add(bit) _lua:add(bit) end", "\n local function join_with(glue)", "\n local old_bits = _lua.bits", "\n _lua = LuaCode:from(_lua.source)", "\n _lua:concat_add(old_bits, glue)", "\n end", "\n ", compile(bit), "\n return _lua", "\nend)()")
|
||||
else
|
||||
bit_lua = compile(bit)
|
||||
end
|
||||
local bit_leading_len = #(bit_lua:match("^[^\n]*"))
|
||||
lua:append(lua:trailing_line_len() + bit_leading_len > MAX_LINE and ",\n " or ", ")
|
||||
lua:append(bit_lua)
|
||||
lua:add(lua:trailing_line_len() + bit_leading_len > MAX_LINE and ",\n " or ", ")
|
||||
lua:add(bit_lua)
|
||||
end
|
||||
lua:append(")")
|
||||
lua:add(")")
|
||||
return lua
|
||||
end
|
||||
return operate_on_text(code)
|
||||
@ -130,11 +130,11 @@ local compile = setmetatable({
|
||||
for _index_0 = 1, #text do
|
||||
local bit = text[_index_0]
|
||||
if type(bit) == "string" then
|
||||
lua:append(bit)
|
||||
lua:add(bit)
|
||||
elseif bit.type == "Text" then
|
||||
lua:append(operate_on_text(bit))
|
||||
lua:add(operate_on_text(bit))
|
||||
else
|
||||
lua:append(compile(bit))
|
||||
lua:add(compile(bit))
|
||||
end
|
||||
end
|
||||
return lua
|
||||
@ -187,16 +187,16 @@ local compile = setmetatable({
|
||||
local lua = LuaCode:from(tree.source)
|
||||
for i, tok in ipairs(tree) do
|
||||
if type(tok) == 'string' then
|
||||
lua:append(tok)
|
||||
lua:add(tok)
|
||||
else
|
||||
local tok_lua = compile(tok)
|
||||
if tok.type == "Action" then
|
||||
tok_lua:parenthesize()
|
||||
end
|
||||
lua:append(tok_lua)
|
||||
lua:add(tok_lua)
|
||||
end
|
||||
if i < #tree then
|
||||
lua:append(" ")
|
||||
lua:add(" ")
|
||||
end
|
||||
end
|
||||
return lua
|
||||
@ -234,12 +234,12 @@ local compile = setmetatable({
|
||||
local target_lua = compile(tree.target)
|
||||
local target_text = target_lua:text()
|
||||
if target_text:match("^%(.*%)$") or target_text:match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or tree.target.type == "IndexChain" then
|
||||
lua:append(target_lua, ":")
|
||||
lua:add(target_lua, ":")
|
||||
else
|
||||
lua:append("(", target_lua, "):")
|
||||
lua:add("(", target_lua, "):")
|
||||
end
|
||||
end
|
||||
lua:append((stub):as_lua_id(), "(")
|
||||
lua:add((stub):as_lua_id(), "(")
|
||||
local args = { }
|
||||
for i, tok in ipairs(tree) do
|
||||
local _continue_0 = false
|
||||
@ -259,8 +259,8 @@ local compile = setmetatable({
|
||||
break
|
||||
end
|
||||
end
|
||||
lua:concat_append(args, ", ")
|
||||
lua:append(")")
|
||||
lua:concat_add(args, ", ")
|
||||
lua:add(")")
|
||||
return lua
|
||||
elseif "EscapedNomsu" == _exp_0 then
|
||||
local lua = LuaCode:from(tree.source, "SyntaxTree{")
|
||||
@ -277,32 +277,32 @@ local compile = setmetatable({
|
||||
end
|
||||
for k, v in pairs((SyntaxTree:is_instance(tree[1]) and tree[1].type == "EscapedNomsu" and tree) or tree[1]) do
|
||||
if needs_comma then
|
||||
lua:append(", ")
|
||||
lua:add(", ")
|
||||
else
|
||||
needs_comma = true
|
||||
end
|
||||
if k == i then
|
||||
i = i + 1
|
||||
elseif type(k) == 'string' and match(k, "[_a-zA-Z][_a-zA-Z0-9]*") then
|
||||
lua:append(k, "= ")
|
||||
lua:add(k, "= ")
|
||||
else
|
||||
lua:append("[", as_lua(k), "]= ")
|
||||
lua:add("[", as_lua(k), "]= ")
|
||||
end
|
||||
if k == "source" then
|
||||
lua:append(tostring(v):as_lua())
|
||||
lua:add(tostring(v):as_lua())
|
||||
else
|
||||
lua:append(as_lua(v))
|
||||
lua:add(as_lua(v))
|
||||
end
|
||||
end
|
||||
lua:append("}")
|
||||
lua:add("}")
|
||||
return lua
|
||||
elseif "Block" == _exp_0 then
|
||||
local lua = LuaCode:from(tree.source)
|
||||
for i, line in ipairs(tree) do
|
||||
if i > 1 then
|
||||
lua:append("\n")
|
||||
lua:add("\n")
|
||||
end
|
||||
lua:append(compile(line))
|
||||
lua:add(compile(line))
|
||||
end
|
||||
return lua
|
||||
elseif "Text" == _exp_0 then
|
||||
@ -320,12 +320,12 @@ local compile = setmetatable({
|
||||
if string_buffer ~= "" then
|
||||
string_buffer = string_buffer:as_lua()
|
||||
if lua:trailing_line_len() + #string_buffer > MAX_LINE then
|
||||
lua:append("\n ")
|
||||
lua:add("\n ")
|
||||
end
|
||||
if added > 0 then
|
||||
lua:append("..")
|
||||
lua:add("..")
|
||||
end
|
||||
lua:append(string_buffer)
|
||||
lua:add(string_buffer)
|
||||
added = added + 1
|
||||
string_buffer = ""
|
||||
end
|
||||
@ -334,15 +334,15 @@ local compile = setmetatable({
|
||||
bit_lua = LuaCode:from(bit.source, "(function()", "\n local _buffer = List{}", "\n local function add(bit) _buffer:add(bit) end", "\n local function join_with(glue) _buffer = _buffer:joined_with(glue) end", "\n ", bit_lua, "\n if lua_type_of(_buffer) == 'table' then _buffer = _buffer:joined() end", "\n return _buffer", "\nend)()")
|
||||
end
|
||||
if lua:trailing_line_len() + #bit_lua:text() > MAX_LINE then
|
||||
lua:append("\n ")
|
||||
lua:add("\n ")
|
||||
end
|
||||
if added > 0 then
|
||||
lua:append("..")
|
||||
lua:add("..")
|
||||
end
|
||||
if bit.type ~= "Text" then
|
||||
bit_lua = LuaCode:from(bit.source, "tostring(", bit_lua, ")")
|
||||
end
|
||||
lua:append(bit_lua)
|
||||
lua:add(bit_lua)
|
||||
added = added + 1
|
||||
_continue_0 = true
|
||||
until true
|
||||
@ -353,12 +353,12 @@ local compile = setmetatable({
|
||||
if string_buffer ~= "" or #lua.bits == 0 then
|
||||
string_buffer = string_buffer:as_lua()
|
||||
if lua:trailing_line_len() + #string_buffer > MAX_LINE then
|
||||
lua:append("\n ")
|
||||
lua:add("\n ")
|
||||
end
|
||||
if added > 0 then
|
||||
lua:append("..")
|
||||
lua:add("..")
|
||||
end
|
||||
lua:append(string_buffer)
|
||||
lua:add(string_buffer)
|
||||
added = added + 1
|
||||
end
|
||||
if #lua.bits > 1 then
|
||||
@ -374,13 +374,13 @@ local compile = setmetatable({
|
||||
if item.type == "Block" then
|
||||
break
|
||||
end
|
||||
lua:append(sep)
|
||||
lua:add(sep)
|
||||
if item.type == "Comment" then
|
||||
lua:append(compile(item), "\n")
|
||||
lua:add(compile(item), "\n")
|
||||
sep = ''
|
||||
else
|
||||
local item_lua = compile(item)
|
||||
lua:append(item_lua)
|
||||
lua:add(item_lua)
|
||||
sep = ', '
|
||||
end
|
||||
i = i + 1
|
||||
@ -393,23 +393,23 @@ local compile = setmetatable({
|
||||
if i <= #tree then
|
||||
lua = LuaCode:from(tree.source, "(function()\n local comprehension = ", lua)
|
||||
if tree.type == "List" then
|
||||
lua:append("\n local function add(x) comprehension[#comprehension+1] = x end")
|
||||
lua:add("\n local function add(x) comprehension[#comprehension+1] = x end")
|
||||
else
|
||||
lua:append("\n local function " .. tostring(("add 1 ="):as_lua_id()) .. "(k, v) comprehension[k] = v end")
|
||||
lua:add("\n local function " .. tostring(("add 1 ="):as_lua_id()) .. "(k, v) comprehension[k] = v end")
|
||||
end
|
||||
while i <= #tree do
|
||||
lua:append("\n ")
|
||||
lua:add("\n ")
|
||||
if tree[i].type == 'Block' or tree[i].type == 'Comment' then
|
||||
lua:append(compile(tree[i]))
|
||||
lua:add(compile(tree[i]))
|
||||
elseif tree[i].type == "DictEntry" then
|
||||
local entry_lua = compile(tree[i])
|
||||
lua:append((entry_lua:text():sub(1, 1) == '[' and "comprehension" or "comprehension."), entry_lua)
|
||||
lua:add((entry_lua:text():sub(1, 1) == '[' and "comprehension" or "comprehension."), entry_lua)
|
||||
else
|
||||
lua:append("comprehension[#comprehension+1] = ", compile(tree[i]))
|
||||
lua:add("comprehension[#comprehension+1] = ", compile(tree[i]))
|
||||
end
|
||||
i = i + 1
|
||||
end
|
||||
lua:append("\n return comprehension\nend)()")
|
||||
lua:add("\n return comprehension\nend)()")
|
||||
end
|
||||
return lua
|
||||
elseif "DictEntry" == _exp_0 then
|
||||
@ -436,11 +436,11 @@ local compile = setmetatable({
|
||||
local key_lua_str = key_lua:text()
|
||||
local lua_id = match(key_lua_str, "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
|
||||
if lua_id and lua_id:is_lua_id() then
|
||||
lua:append("." .. tostring(lua_id))
|
||||
lua:add("." .. tostring(lua_id))
|
||||
elseif sub(key_lua_str, 1, 1) == '[' then
|
||||
lua:append("[ ", key_lua, " ]")
|
||||
lua:add("[ ", key_lua, " ]")
|
||||
else
|
||||
lua:append("[", key_lua, "]")
|
||||
lua:add("[", key_lua, "]")
|
||||
end
|
||||
end
|
||||
return lua
|
||||
|
||||
@ -53,14 +53,14 @@ compile = setmetatable({
|
||||
[""]: (compile, fn, ...)->
|
||||
lua = LuaCode!
|
||||
fn_lua = compile(fn)
|
||||
lua\append fn_lua
|
||||
lua\add fn_lua
|
||||
unless fn_lua\text!\match("^%(.*%)$") or fn_lua\text!\match("^[_a-zA-Z][_a-zA-Z0-9.]*$")
|
||||
lua\parenthesize!
|
||||
lua\append "("
|
||||
lua\add "("
|
||||
for i=1,select('#',...)
|
||||
lua\append(", ") if i > 1
|
||||
lua\append compile((select(i, ...)))
|
||||
lua\append ")"
|
||||
lua\add(", ") if i > 1
|
||||
lua\add compile((select(i, ...)))
|
||||
lua\add ")"
|
||||
return lua
|
||||
|
||||
["Lua"]: (compile, code)->
|
||||
@ -80,11 +80,11 @@ compile = setmetatable({
|
||||
elseif bit.type == "Block"
|
||||
bit_lua = LuaCode\from bit.source, "(function()",
|
||||
"\n local _lua = LuaCode:from(", tostring(bit.source)\as_lua!, ")",
|
||||
"\n local function add(bit) _lua:append(bit) end",
|
||||
"\n local function add(bit) _lua:add(bit) end",
|
||||
"\n local function join_with(glue)",
|
||||
"\n local old_bits = _lua.bits",
|
||||
"\n _lua = LuaCode:from(_lua.source)",
|
||||
"\n _lua:concat_append(old_bits, glue)",
|
||||
"\n _lua:concat_add(old_bits, glue)",
|
||||
"\n end",
|
||||
"\n ", compile(bit),
|
||||
"\n return _lua",
|
||||
@ -93,9 +93,9 @@ compile = setmetatable({
|
||||
bit_lua = compile(bit)
|
||||
|
||||
bit_leading_len = #(bit_lua\match("^[^\n]*"))
|
||||
lua\append(lua\trailing_line_len! + bit_leading_len > MAX_LINE and ",\n " or ", ")
|
||||
lua\append(bit_lua)
|
||||
lua\append ")"
|
||||
lua\add(lua\trailing_line_len! + bit_leading_len > MAX_LINE and ",\n " or ", ")
|
||||
lua\add(bit_lua)
|
||||
lua\add ")"
|
||||
return lua
|
||||
|
||||
return operate_on_text code
|
||||
@ -107,11 +107,11 @@ compile = setmetatable({
|
||||
lua = LuaCode\from(text.source)
|
||||
for bit in *text
|
||||
if type(bit) == "string"
|
||||
lua\append bit
|
||||
lua\add bit
|
||||
elseif bit.type == "Text"
|
||||
lua\append(operate_on_text(bit))
|
||||
lua\add(operate_on_text(bit))
|
||||
else
|
||||
lua\append compile(bit)
|
||||
lua\add compile(bit)
|
||||
return lua
|
||||
return operate_on_text code
|
||||
|
||||
@ -146,12 +146,12 @@ compile = setmetatable({
|
||||
lua = LuaCode\from(tree.source)
|
||||
for i,tok in ipairs tree
|
||||
if type(tok) == 'string'
|
||||
lua\append tok
|
||||
lua\add tok
|
||||
else
|
||||
tok_lua = compile(tok)
|
||||
tok_lua\parenthesize! if tok.type == "Action"
|
||||
lua\append tok_lua
|
||||
lua\append " " if i < #tree
|
||||
lua\add tok_lua
|
||||
lua\add " " if i < #tree
|
||||
return lua
|
||||
|
||||
if compile_action and not tree.target
|
||||
@ -178,10 +178,10 @@ compile = setmetatable({
|
||||
-- TODO: this parenthesizing is maybe overly conservative
|
||||
if target_text\match("^%(.*%)$") or target_text\match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or
|
||||
tree.target.type == "IndexChain"
|
||||
lua\append target_lua, ":"
|
||||
lua\add target_lua, ":"
|
||||
else
|
||||
lua\append "(", target_lua, "):"
|
||||
lua\append((stub)\as_lua_id!,"(")
|
||||
lua\add "(", target_lua, "):"
|
||||
lua\add((stub)\as_lua_id!,"(")
|
||||
args = {}
|
||||
for i, tok in ipairs tree
|
||||
if type(tok) == "string" then continue
|
||||
@ -189,8 +189,8 @@ compile = setmetatable({
|
||||
if tok.type == "Block"
|
||||
arg_lua = LuaCode\from(tok.source, "(function()\n ", arg_lua, "\nend)()")
|
||||
insert args, arg_lua
|
||||
lua\concat_append args, ", "
|
||||
lua\append ")"
|
||||
lua\concat_add args, ", "
|
||||
lua\add ")"
|
||||
return lua
|
||||
|
||||
when "EscapedNomsu"
|
||||
@ -204,26 +204,26 @@ compile = setmetatable({
|
||||
else x\as_lua!
|
||||
|
||||
for k,v in pairs((SyntaxTree\is_instance(tree[1]) and tree[1].type == "EscapedNomsu" and tree) or tree[1])
|
||||
if needs_comma then lua\append ", "
|
||||
if needs_comma then lua\add ", "
|
||||
else needs_comma = true
|
||||
if k == i
|
||||
i += 1
|
||||
elseif type(k) == 'string' and match(k,"[_a-zA-Z][_a-zA-Z0-9]*")
|
||||
lua\append(k, "= ")
|
||||
lua\add(k, "= ")
|
||||
else
|
||||
lua\append("[", as_lua(k), "]= ")
|
||||
lua\add("[", as_lua(k), "]= ")
|
||||
if k == "source"
|
||||
lua\append tostring(v)\as_lua!
|
||||
lua\add tostring(v)\as_lua!
|
||||
else
|
||||
lua\append as_lua(v)
|
||||
lua\append "}"
|
||||
lua\add as_lua(v)
|
||||
lua\add "}"
|
||||
return lua
|
||||
|
||||
when "Block"
|
||||
lua = LuaCode\from(tree.source)
|
||||
for i, line in ipairs tree
|
||||
if i > 1 then lua\append "\n"
|
||||
lua\append compile(line)
|
||||
if i > 1 then lua\add "\n"
|
||||
lua\add compile(line)
|
||||
return lua
|
||||
|
||||
when "Text"
|
||||
@ -237,9 +237,9 @@ compile = setmetatable({
|
||||
if string_buffer != ""
|
||||
string_buffer = string_buffer\as_lua!
|
||||
if lua\trailing_line_len! + #string_buffer > MAX_LINE
|
||||
lua\append "\n "
|
||||
if added > 0 then lua\append ".."
|
||||
lua\append string_buffer
|
||||
lua\add "\n "
|
||||
if added > 0 then lua\add ".."
|
||||
lua\add string_buffer
|
||||
added += 1
|
||||
string_buffer = ""
|
||||
|
||||
@ -254,19 +254,19 @@ compile = setmetatable({
|
||||
"\n return _buffer",
|
||||
"\nend)()"
|
||||
if lua\trailing_line_len! + #bit_lua\text! > MAX_LINE
|
||||
lua\append "\n "
|
||||
if added > 0 then lua\append ".."
|
||||
lua\add "\n "
|
||||
if added > 0 then lua\add ".."
|
||||
if bit.type != "Text"
|
||||
bit_lua = LuaCode\from(bit.source, "tostring(",bit_lua,")")
|
||||
lua\append bit_lua
|
||||
lua\add bit_lua
|
||||
added += 1
|
||||
|
||||
if string_buffer ~= "" or #lua.bits == 0
|
||||
string_buffer = string_buffer\as_lua!
|
||||
if lua\trailing_line_len! + #string_buffer > MAX_LINE
|
||||
lua\append "\n "
|
||||
if added > 0 then lua\append ".."
|
||||
lua\append string_buffer
|
||||
lua\add "\n "
|
||||
if added > 0 then lua\add ".."
|
||||
lua\add string_buffer
|
||||
added += 1
|
||||
|
||||
if #lua.bits > 1
|
||||
@ -281,13 +281,13 @@ compile = setmetatable({
|
||||
item = tree[i]
|
||||
if item.type == "Block"
|
||||
break
|
||||
lua\append sep
|
||||
lua\add sep
|
||||
if item.type == "Comment"
|
||||
lua\append compile(item), "\n"
|
||||
lua\add compile(item), "\n"
|
||||
sep = ''
|
||||
else
|
||||
item_lua = compile(item)
|
||||
lua\append item_lua
|
||||
lua\add item_lua
|
||||
sep = ', '
|
||||
i += 1
|
||||
|
||||
@ -300,20 +300,20 @@ compile = setmetatable({
|
||||
if i <= #tree
|
||||
lua = LuaCode\from tree.source, "(function()\n local comprehension = ", lua
|
||||
if tree.type == "List"
|
||||
lua\append "\n local function add(x) comprehension[#comprehension+1] = x end"
|
||||
lua\add "\n local function add(x) comprehension[#comprehension+1] = x end"
|
||||
else
|
||||
lua\append "\n local function #{("add 1 =")\as_lua_id!}(k, v) comprehension[k] = v end"
|
||||
lua\add "\n local function #{("add 1 =")\as_lua_id!}(k, v) comprehension[k] = v end"
|
||||
while i <= #tree
|
||||
lua\append "\n "
|
||||
lua\add "\n "
|
||||
if tree[i].type == 'Block' or tree[i].type == 'Comment'
|
||||
lua\append compile(tree[i])
|
||||
lua\add compile(tree[i])
|
||||
elseif tree[i].type == "DictEntry"
|
||||
entry_lua = compile(tree[i])
|
||||
lua\append (entry_lua\text!\sub(1,1) == '[' and "comprehension" or "comprehension."), entry_lua
|
||||
lua\add (entry_lua\text!\sub(1,1) == '[' and "comprehension" or "comprehension."), entry_lua
|
||||
else
|
||||
lua\append "comprehension[#comprehension+1] = ", compile(tree[i])
|
||||
lua\add "comprehension[#comprehension+1] = ", compile(tree[i])
|
||||
i += 1
|
||||
lua\append "\n return comprehension\nend)()"
|
||||
lua\add "\n return comprehension\nend)()"
|
||||
|
||||
return lua
|
||||
|
||||
@ -344,14 +344,14 @@ compile = setmetatable({
|
||||
key_lua_str = key_lua\text!
|
||||
lua_id = match(key_lua_str, "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
|
||||
if lua_id and lua_id\is_lua_id!
|
||||
lua\append ".#{lua_id}"
|
||||
lua\add ".#{lua_id}"
|
||||
elseif sub(key_lua_str,1,1) == '['
|
||||
-- NOTE: this *must* use a space after the [ to avoid freaking out
|
||||
-- Lua's parser if the inner expression is a long string. Lua
|
||||
-- parses x[[[y]]] as x("[y]"), not as x["y"]
|
||||
lua\append "[ ",key_lua," ]"
|
||||
lua\add "[ ",key_lua," ]"
|
||||
else
|
||||
lua\append "[",key_lua,"]"
|
||||
lua\add "[",key_lua,"]"
|
||||
return lua
|
||||
|
||||
when "Number"
|
||||
|
||||
@ -54,7 +54,7 @@ tree_to_inline_nomsu = function(tree)
|
||||
if tree.target.type == "Action" then
|
||||
inline_target:parenthesize()
|
||||
end
|
||||
nomsu:append(inline_target, "::")
|
||||
nomsu:add(inline_target, "::")
|
||||
end
|
||||
for i, bit in ipairs(tree) do
|
||||
if type(bit) == "string" then
|
||||
@ -65,31 +65,31 @@ tree_to_inline_nomsu = function(tree)
|
||||
clump_words = bit == "'"
|
||||
end
|
||||
if i > 1 and not clump_words then
|
||||
nomsu:append(" ")
|
||||
nomsu:add(" ")
|
||||
end
|
||||
nomsu:append(bit)
|
||||
nomsu:add(bit)
|
||||
else
|
||||
local arg_nomsu = tree_to_inline_nomsu(bit)
|
||||
if bit.type == "Block" then
|
||||
if i > 1 and i < #tree then
|
||||
nomsu:append(" ")
|
||||
nomsu:add(" ")
|
||||
end
|
||||
if not (i == #tree) then
|
||||
arg_nomsu:parenthesize()
|
||||
end
|
||||
else
|
||||
if i > 1 then
|
||||
nomsu:append(" ")
|
||||
nomsu:add(" ")
|
||||
end
|
||||
if bit.type == "Action" then
|
||||
arg_nomsu:parenthesize()
|
||||
end
|
||||
end
|
||||
nomsu:append(arg_nomsu)
|
||||
nomsu:add(arg_nomsu)
|
||||
end
|
||||
end
|
||||
if #tree == 1 and type(tree[1]) ~= "string" then
|
||||
nomsu:append("()")
|
||||
nomsu:add("()")
|
||||
end
|
||||
return nomsu
|
||||
elseif "EscapedNomsu" == _exp_0 then
|
||||
@ -101,8 +101,8 @@ tree_to_inline_nomsu = function(tree)
|
||||
elseif "Block" == _exp_0 then
|
||||
local nomsu = NomsuCode:from(tree.source, ":")
|
||||
for i, line in ipairs(tree) do
|
||||
nomsu:append(i == 1 and " " or "; ")
|
||||
nomsu:append(tree_to_inline_nomsu(line))
|
||||
nomsu:add(i == 1 and " " or "; ")
|
||||
nomsu:add(tree_to_inline_nomsu(line))
|
||||
end
|
||||
if #tree > 1 then
|
||||
nomsu:parenthesize()
|
||||
@ -114,7 +114,7 @@ tree_to_inline_nomsu = function(tree)
|
||||
for i, bit in ipairs(tree) do
|
||||
if type(bit) == 'string' then
|
||||
local escaped = inline_escape(bit)
|
||||
nomsu:append(inline_escape(bit))
|
||||
nomsu:add(inline_escape(bit))
|
||||
elseif bit.type == "Text" then
|
||||
add_text(nomsu, bit)
|
||||
else
|
||||
@ -124,7 +124,7 @@ tree_to_inline_nomsu = function(tree)
|
||||
elseif bit.type == "Var" and type(tree[i + 1]) == 'string' and not match(tree[i + 1], "^[ \n\t,.:;#(){}[%]]") then
|
||||
interp_nomsu:parenthesize()
|
||||
end
|
||||
nomsu:append("\\", interp_nomsu)
|
||||
nomsu:add("\\", interp_nomsu)
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -135,11 +135,11 @@ tree_to_inline_nomsu = function(tree)
|
||||
local nomsu = NomsuCode:from(tree.source, (tree.type == "List" and "[" or "{"))
|
||||
for i, item in ipairs(tree) do
|
||||
if i > 1 then
|
||||
nomsu:append(", ")
|
||||
nomsu:add(", ")
|
||||
end
|
||||
nomsu:append(tree_to_inline_nomsu(item))
|
||||
nomsu:add(tree_to_inline_nomsu(item))
|
||||
end
|
||||
nomsu:append(tree.type == "List" and "]" or "}")
|
||||
nomsu:add(tree.type == "List" and "]" or "}")
|
||||
return nomsu
|
||||
elseif "DictEntry" == _exp_0 then
|
||||
local key, value = tree[1], tree[2]
|
||||
@ -153,19 +153,19 @@ tree_to_inline_nomsu = function(tree)
|
||||
nomsu:parenthesize()
|
||||
end
|
||||
if value then
|
||||
nomsu:append(": ")
|
||||
nomsu:add(": ")
|
||||
local value_nomsu = tree_to_inline_nomsu(value)
|
||||
if value.type == "Block" then
|
||||
value_nomsu:parenthesize()
|
||||
end
|
||||
nomsu:append(value_nomsu)
|
||||
nomsu:add(value_nomsu)
|
||||
end
|
||||
return nomsu
|
||||
elseif "IndexChain" == _exp_0 then
|
||||
local nomsu = NomsuCode:from(tree.source)
|
||||
for i, bit in ipairs(tree) do
|
||||
if i > 1 then
|
||||
nomsu:append(".")
|
||||
nomsu:add(".")
|
||||
end
|
||||
local bit_nomsu
|
||||
if i > 1 and bit.type == "Text" and #bit == 1 and type(bit[1]) == 'string' and is_identifier(bit[1]) then
|
||||
@ -177,7 +177,7 @@ tree_to_inline_nomsu = function(tree)
|
||||
if bit.type == "Action" or bit.type == "IndexChain" or (bit.type == "Number" and i < #tree) then
|
||||
bit_nomsu:parenthesize()
|
||||
end
|
||||
nomsu:append(bit_nomsu)
|
||||
nomsu:add(bit_nomsu)
|
||||
end
|
||||
return nomsu
|
||||
elseif "Number" == _exp_0 then
|
||||
@ -244,20 +244,20 @@ tree_to_nomsu = function(tree)
|
||||
local _exp_0 = tree.type
|
||||
if "FileChunks" == _exp_0 then
|
||||
if tree.shebang then
|
||||
nomsu:append(tree.shebang)
|
||||
nomsu:add(tree.shebang)
|
||||
end
|
||||
for chunk_no, chunk in ipairs(tree) do
|
||||
if chunk_no > 1 then
|
||||
nomsu:append("\n\n" .. tostring(("~"):rep(80)) .. "\n\n")
|
||||
nomsu:add("\n\n" .. tostring(("~"):rep(80)) .. "\n\n")
|
||||
end
|
||||
if chunk.type == "Block" then
|
||||
nomsu:append(NomsuCode:from(chunk.source, table.unpack(tree_to_nomsu(chunk).bits, 2)))
|
||||
nomsu:add(NomsuCode:from(chunk.source, table.unpack(tree_to_nomsu(chunk).bits, 2)))
|
||||
else
|
||||
nomsu:append(tree_to_nomsu(chunk))
|
||||
nomsu:add(tree_to_nomsu(chunk))
|
||||
end
|
||||
end
|
||||
if not (nomsu:match("\n$")) then
|
||||
nomsu:append('\n')
|
||||
nomsu:add('\n')
|
||||
end
|
||||
return nomsu
|
||||
elseif "Action" == _exp_0 then
|
||||
@ -267,8 +267,8 @@ tree_to_nomsu = function(tree)
|
||||
if tree.target.type == "Block" and not target_nomsu:is_multiline() then
|
||||
target_nomsu:parenthesize()
|
||||
end
|
||||
nomsu:append(target_nomsu)
|
||||
nomsu:append(target_nomsu:is_multiline() and "\n..::" or "::")
|
||||
nomsu:add(target_nomsu)
|
||||
nomsu:add(target_nomsu:is_multiline() and "\n..::" or "::")
|
||||
end
|
||||
local word_buffer = { }
|
||||
for i, bit in ipairs(tree) do
|
||||
@ -291,7 +291,7 @@ tree_to_nomsu = function(tree)
|
||||
next_space = ""
|
||||
end
|
||||
end
|
||||
nomsu:append(next_space, words)
|
||||
nomsu:add(next_space, words)
|
||||
word_buffer = { }
|
||||
next_space = " "
|
||||
end
|
||||
@ -309,9 +309,9 @@ tree_to_nomsu = function(tree)
|
||||
end
|
||||
end
|
||||
if not (next_space == " " and bit.type == "Block") then
|
||||
nomsu:append(next_space)
|
||||
nomsu:add(next_space)
|
||||
end
|
||||
nomsu:append(bit_nomsu)
|
||||
nomsu:add(bit_nomsu)
|
||||
next_space = (bit_nomsu:is_multiline() or bit.type == 'Block') and "\n.." or " "
|
||||
_continue_0 = true
|
||||
until true
|
||||
@ -328,14 +328,14 @@ tree_to_nomsu = function(tree)
|
||||
next_space = ""
|
||||
end
|
||||
end
|
||||
nomsu:append(next_space, words)
|
||||
nomsu:add(next_space, words)
|
||||
next_space = " "
|
||||
end
|
||||
if #tree == 1 and type(tree[1]) ~= "string" then
|
||||
if next_space == " " then
|
||||
next_space = ""
|
||||
end
|
||||
nomsu:append(next_space, "()")
|
||||
nomsu:add(next_space, "()")
|
||||
end
|
||||
return nomsu
|
||||
elseif "EscapedNomsu" == _exp_0 then
|
||||
@ -349,15 +349,15 @@ tree_to_nomsu = function(tree)
|
||||
for i, line in ipairs(tree) do
|
||||
local line_nomsu = tree_to_nomsu(line)
|
||||
if i > 1 then
|
||||
nomsu:append("\n")
|
||||
nomsu:add("\n")
|
||||
if tree[i - 1].type ~= "Comment" then
|
||||
needs_space[i] = (line_nomsu:is_multiline() and prev_line:is_multiline())
|
||||
if tree[i].type == "Comment" or needs_space[i] or needs_space[i - 1] then
|
||||
nomsu:append("\n")
|
||||
nomsu:add("\n")
|
||||
end
|
||||
end
|
||||
end
|
||||
nomsu:append(line_nomsu)
|
||||
nomsu:add(line_nomsu)
|
||||
prev_line = line_nomsu
|
||||
end
|
||||
return NomsuCode:from(tree.source, ":\n ", nomsu)
|
||||
@ -370,9 +370,9 @@ tree_to_nomsu = function(tree)
|
||||
bit = escape(bit)
|
||||
for j, line in ipairs(bit:lines()) do
|
||||
if j > 1 then
|
||||
nomsu:append("\n")
|
||||
nomsu:add("\n")
|
||||
elseif #line > 10 and nomsu:trailing_line_len() > max_line then
|
||||
nomsu:append("\\\n..")
|
||||
nomsu:add("\\\n..")
|
||||
end
|
||||
while #line > 0 do
|
||||
local space = max_line - nomsu:trailing_line_len()
|
||||
@ -385,16 +385,16 @@ tree_to_nomsu = function(tree)
|
||||
end
|
||||
local bite
|
||||
bite, line = sub(line, 1, split), sub(line, split + 1, -1)
|
||||
nomsu:append(bite)
|
||||
nomsu:add(bite)
|
||||
if #line > 0 then
|
||||
nomsu:append("\\\n..")
|
||||
nomsu:add("\\\n..")
|
||||
end
|
||||
end
|
||||
end
|
||||
elseif bit.type == "Text" then
|
||||
add_text(bit)
|
||||
else
|
||||
nomsu:append("\\")
|
||||
nomsu:add("\\")
|
||||
local interp_nomsu = recurse(bit)
|
||||
if not (interp_nomsu:is_multiline()) then
|
||||
if bit.type == "Var" then
|
||||
@ -405,9 +405,9 @@ tree_to_nomsu = function(tree)
|
||||
interp_nomsu:parenthesize()
|
||||
end
|
||||
end
|
||||
nomsu:append(interp_nomsu)
|
||||
nomsu:add(interp_nomsu)
|
||||
if interp_nomsu:is_multiline() then
|
||||
nomsu:append("\n..")
|
||||
nomsu:add("\n..")
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -416,7 +416,7 @@ tree_to_nomsu = function(tree)
|
||||
return NomsuCode:from(tree.source, '"\\\n ..', nomsu, '"')
|
||||
elseif "List" == _exp_0 or "Dict" == _exp_0 then
|
||||
if #tree == 0 then
|
||||
nomsu:append(tree.type == "List" and "[]" or "{}")
|
||||
nomsu:add(tree.type == "List" and "[]" or "{}")
|
||||
return nomsu
|
||||
end
|
||||
local sep = ''
|
||||
@ -428,8 +428,8 @@ tree_to_nomsu = function(tree)
|
||||
if item.type == 'Comment' then
|
||||
item_nomsu = tree_to_nomsu(item)
|
||||
end
|
||||
nomsu:append(sep)
|
||||
nomsu:append(item_nomsu)
|
||||
nomsu:add(sep)
|
||||
nomsu:add(item_nomsu)
|
||||
if item_nomsu:is_multiline() or item.type == 'Comment' or nomsu:trailing_line_len() + #tostring(item_nomsu) >= MAX_LINE then
|
||||
sep = '\n'
|
||||
else
|
||||
@ -456,11 +456,11 @@ tree_to_nomsu = function(tree)
|
||||
if (value.type == "Block" or value.type == "EscapedNomsu") and not value_nomsu:is_multiline() then
|
||||
value_nomsu:parenthesize()
|
||||
end
|
||||
nomsu:append(": ", value_nomsu)
|
||||
nomsu:add(": ", value_nomsu)
|
||||
end
|
||||
return nomsu
|
||||
elseif "Comment" == _exp_0 then
|
||||
nomsu:append("#", (tree[1]:gsub("\n", "\n ")))
|
||||
nomsu:add("#", (tree[1]:gsub("\n", "\n ")))
|
||||
return nomsu
|
||||
elseif "IndexChain" == _exp_0 or "Number" == _exp_0 or "Var" == _exp_0 or "Comment" == _exp_0 or "Error" == _exp_0 then
|
||||
return tree_to_inline_nomsu(tree)
|
||||
|
||||
@ -37,29 +37,29 @@ tree_to_inline_nomsu = (tree)->
|
||||
inline_target = tree_to_inline_nomsu(tree.target)
|
||||
if tree.target.type == "Action"
|
||||
inline_target\parenthesize!
|
||||
nomsu\append inline_target, "::"
|
||||
nomsu\add inline_target, "::"
|
||||
|
||||
for i,bit in ipairs tree
|
||||
if type(bit) == "string"
|
||||
clump_words = if type(tree[i-1]) == 'string'
|
||||
is_operator(bit) != is_operator(tree[i-1])
|
||||
else bit == "'"
|
||||
nomsu\append " " if i > 1 and not clump_words
|
||||
nomsu\append bit
|
||||
nomsu\add " " if i > 1 and not clump_words
|
||||
nomsu\add bit
|
||||
else
|
||||
arg_nomsu = tree_to_inline_nomsu(bit)
|
||||
if bit.type == "Block"
|
||||
if i > 1 and i < #tree
|
||||
nomsu\append " "
|
||||
nomsu\add " "
|
||||
unless i == #tree
|
||||
arg_nomsu\parenthesize!
|
||||
else
|
||||
nomsu\append " " if i > 1
|
||||
nomsu\add " " if i > 1
|
||||
if bit.type == "Action"
|
||||
arg_nomsu\parenthesize!
|
||||
nomsu\append arg_nomsu
|
||||
nomsu\add arg_nomsu
|
||||
if #tree == 1 and type(tree[1]) != "string"
|
||||
nomsu\append "()"
|
||||
nomsu\add "()"
|
||||
return nomsu
|
||||
|
||||
when "EscapedNomsu"
|
||||
@ -71,8 +71,8 @@ tree_to_inline_nomsu = (tree)->
|
||||
when "Block"
|
||||
nomsu = NomsuCode\from(tree.source, ":")
|
||||
for i,line in ipairs tree
|
||||
nomsu\append(i == 1 and " " or "; ")
|
||||
nomsu\append tree_to_inline_nomsu(line)
|
||||
nomsu\add(i == 1 and " " or "; ")
|
||||
nomsu\add tree_to_inline_nomsu(line)
|
||||
nomsu\parenthesize! if #tree > 1
|
||||
return nomsu
|
||||
|
||||
@ -81,7 +81,7 @@ tree_to_inline_nomsu = (tree)->
|
||||
for i, bit in ipairs tree
|
||||
if type(bit) == 'string'
|
||||
escaped = inline_escape(bit)
|
||||
nomsu\append inline_escape(bit)
|
||||
nomsu\add inline_escape(bit)
|
||||
elseif bit.type == "Text"
|
||||
add_text(nomsu, bit)
|
||||
else
|
||||
@ -90,7 +90,7 @@ tree_to_inline_nomsu = (tree)->
|
||||
interp_nomsu\parenthesize!
|
||||
elseif bit.type == "Var" and type(tree[i+1]) == 'string' and not match(tree[i+1], "^[ \n\t,.:;#(){}[%]]")
|
||||
interp_nomsu\parenthesize!
|
||||
nomsu\append "\\", interp_nomsu
|
||||
nomsu\add "\\", interp_nomsu
|
||||
nomsu = NomsuCode\from(tree.source)
|
||||
add_text(nomsu, tree)
|
||||
return NomsuCode\from(tree.source, '"', nomsu, '"')
|
||||
@ -98,9 +98,9 @@ tree_to_inline_nomsu = (tree)->
|
||||
when "List", "Dict"
|
||||
nomsu = NomsuCode\from(tree.source, (tree.type == "List" and "[" or "{"))
|
||||
for i, item in ipairs tree
|
||||
nomsu\append ", " if i > 1
|
||||
nomsu\append tree_to_inline_nomsu(item)
|
||||
nomsu\append(tree.type == "List" and "]" or "}")
|
||||
nomsu\add ", " if i > 1
|
||||
nomsu\add tree_to_inline_nomsu(item)
|
||||
nomsu\add(tree.type == "List" and "]" or "}")
|
||||
return nomsu
|
||||
|
||||
when "DictEntry"
|
||||
@ -110,16 +110,16 @@ tree_to_inline_nomsu = (tree)->
|
||||
else tree_to_inline_nomsu(key)
|
||||
nomsu\parenthesize! if key.type == "Action" or key.type == "Block"
|
||||
if value
|
||||
nomsu\append ": "
|
||||
nomsu\add ": "
|
||||
value_nomsu = tree_to_inline_nomsu(value)
|
||||
value_nomsu\parenthesize! if value.type == "Block"
|
||||
nomsu\append value_nomsu
|
||||
nomsu\add value_nomsu
|
||||
return nomsu
|
||||
|
||||
when "IndexChain"
|
||||
nomsu = NomsuCode\from(tree.source)
|
||||
for i, bit in ipairs tree
|
||||
nomsu\append "." if i > 1
|
||||
nomsu\add "." if i > 1
|
||||
local bit_nomsu
|
||||
bit_nomsu = if i > 1 and bit.type == "Text" and #bit == 1 and type(bit[1]) == 'string' and is_identifier(bit[1])
|
||||
bit[1]
|
||||
@ -127,7 +127,7 @@ tree_to_inline_nomsu = (tree)->
|
||||
assert bit.type != "Block"
|
||||
if bit.type == "Action" or bit.type == "IndexChain" or (bit.type == "Number" and i < #tree)
|
||||
bit_nomsu\parenthesize!
|
||||
nomsu\append bit_nomsu
|
||||
nomsu\add bit_nomsu
|
||||
return nomsu
|
||||
|
||||
when "Number"
|
||||
@ -185,16 +185,16 @@ tree_to_nomsu = (tree)->
|
||||
switch tree.type
|
||||
when "FileChunks"
|
||||
if tree.shebang
|
||||
nomsu\append tree.shebang
|
||||
nomsu\add tree.shebang
|
||||
|
||||
for chunk_no, chunk in ipairs tree
|
||||
nomsu\append "\n\n#{("~")\rep(80)}\n\n" if chunk_no > 1
|
||||
nomsu\add "\n\n#{("~")\rep(80)}\n\n" if chunk_no > 1
|
||||
if chunk.type == "Block"
|
||||
nomsu\append NomsuCode\from(chunk.source, table.unpack(tree_to_nomsu(chunk).bits, 2))
|
||||
nomsu\add NomsuCode\from(chunk.source, table.unpack(tree_to_nomsu(chunk).bits, 2))
|
||||
else
|
||||
nomsu\append tree_to_nomsu(chunk)
|
||||
nomsu\add tree_to_nomsu(chunk)
|
||||
|
||||
nomsu\append('\n') unless nomsu\match("\n$")
|
||||
nomsu\add('\n') unless nomsu\match("\n$")
|
||||
return nomsu
|
||||
|
||||
when "Action"
|
||||
@ -203,8 +203,8 @@ tree_to_nomsu = (tree)->
|
||||
target_nomsu = recurse(tree.target)
|
||||
if tree.target.type == "Block" and not target_nomsu\is_multiline!
|
||||
target_nomsu\parenthesize!
|
||||
nomsu\append target_nomsu
|
||||
nomsu\append(target_nomsu\is_multiline! and "\n..::" or "::")
|
||||
nomsu\add target_nomsu
|
||||
nomsu\add(target_nomsu\is_multiline! and "\n..::" or "::")
|
||||
|
||||
word_buffer = {}
|
||||
for i,bit in ipairs tree
|
||||
@ -221,7 +221,7 @@ tree_to_nomsu = (tree)->
|
||||
next_space = " \\\n.."
|
||||
elseif word_buffer[1] == "'"
|
||||
next_space = ""
|
||||
nomsu\append next_space, words
|
||||
nomsu\add next_space, words
|
||||
word_buffer = {}
|
||||
next_space = " "
|
||||
|
||||
@ -240,9 +240,9 @@ tree_to_nomsu = (tree)->
|
||||
else
|
||||
next_space = " \\\n.."
|
||||
unless next_space == " " and bit.type == "Block"
|
||||
nomsu\append next_space
|
||||
nomsu\add next_space
|
||||
|
||||
nomsu\append bit_nomsu
|
||||
nomsu\add bit_nomsu
|
||||
next_space = (bit_nomsu\is_multiline! or bit.type == 'Block') and "\n.." or " "
|
||||
|
||||
if #word_buffer > 0
|
||||
@ -252,12 +252,12 @@ tree_to_nomsu = (tree)->
|
||||
next_space = " \\\n.."
|
||||
elseif word_buffer[1] == "'"
|
||||
next_space = ""
|
||||
nomsu\append next_space, words
|
||||
nomsu\add next_space, words
|
||||
next_space = " "
|
||||
|
||||
if #tree == 1 and type(tree[1]) != "string"
|
||||
if next_space == " " then next_space = ""
|
||||
nomsu\append next_space, "()"
|
||||
nomsu\add next_space, "()"
|
||||
|
||||
return nomsu
|
||||
|
||||
@ -272,14 +272,14 @@ tree_to_nomsu = (tree)->
|
||||
for i, line in ipairs tree
|
||||
line_nomsu = tree_to_nomsu(line)
|
||||
if i > 1
|
||||
nomsu\append "\n"
|
||||
nomsu\add "\n"
|
||||
-- Rule of thumb: add a blank line between two lines if both are
|
||||
-- multi-line non-comments, or if a comment comes after a non-comment.
|
||||
if tree[i-1].type != "Comment"
|
||||
needs_space[i] = (line_nomsu\is_multiline! and prev_line\is_multiline!)
|
||||
if tree[i].type == "Comment" or needs_space[i] or needs_space[i-1]
|
||||
nomsu\append "\n"
|
||||
nomsu\append line_nomsu
|
||||
nomsu\add "\n"
|
||||
nomsu\add line_nomsu
|
||||
prev_line = line_nomsu
|
||||
return NomsuCode\from(tree.source, ":\n ", nomsu)
|
||||
|
||||
@ -292,9 +292,9 @@ tree_to_nomsu = (tree)->
|
||||
bit = escape(bit)
|
||||
for j, line in ipairs bit\lines!
|
||||
if j > 1
|
||||
nomsu\append "\n"
|
||||
nomsu\add "\n"
|
||||
elseif #line > 10 and nomsu\trailing_line_len! > max_line
|
||||
nomsu\append "\\\n.."
|
||||
nomsu\add "\\\n.."
|
||||
|
||||
while #line > 0
|
||||
space = max_line - nomsu\trailing_line_len!
|
||||
@ -304,12 +304,12 @@ tree_to_nomsu = (tree)->
|
||||
if #line - split < 10
|
||||
split = #line
|
||||
bite, line = sub(line, 1, split), sub(line, split+1, -1)
|
||||
nomsu\append bite
|
||||
nomsu\append "\\\n.." if #line > 0
|
||||
nomsu\add bite
|
||||
nomsu\add "\\\n.." if #line > 0
|
||||
elseif bit.type == "Text"
|
||||
add_text(bit)
|
||||
else
|
||||
nomsu\append "\\"
|
||||
nomsu\add "\\"
|
||||
interp_nomsu = recurse(bit)
|
||||
unless interp_nomsu\is_multiline!
|
||||
if bit.type == "Var"
|
||||
@ -317,15 +317,15 @@ tree_to_nomsu = (tree)->
|
||||
interp_nomsu\parenthesize!
|
||||
elseif bit.type == "EscapedNomsu" or bit.type == "Block" or bit.type == "IndexChain"
|
||||
interp_nomsu\parenthesize!
|
||||
nomsu\append interp_nomsu
|
||||
nomsu\add interp_nomsu
|
||||
if interp_nomsu\is_multiline!
|
||||
nomsu\append "\n.."
|
||||
nomsu\add "\n.."
|
||||
add_text(tree)
|
||||
return NomsuCode\from(tree.source, '"\\\n ..', nomsu, '"')
|
||||
|
||||
when "List", "Dict"
|
||||
if #tree == 0
|
||||
nomsu\append(tree.type == "List" and "[]" or "{}")
|
||||
nomsu\add(tree.type == "List" and "[]" or "{}")
|
||||
return nomsu
|
||||
sep = ''
|
||||
for i, item in ipairs tree
|
||||
@ -334,8 +334,8 @@ tree_to_nomsu = (tree)->
|
||||
item_nomsu = recurse(item)
|
||||
if item.type == 'Comment'
|
||||
item_nomsu = tree_to_nomsu(item)
|
||||
nomsu\append sep
|
||||
nomsu\append item_nomsu
|
||||
nomsu\add sep
|
||||
nomsu\add item_nomsu
|
||||
if item_nomsu\is_multiline! or item.type == 'Comment' or nomsu\trailing_line_len! + #tostring(item_nomsu) >= MAX_LINE
|
||||
sep = '\n'
|
||||
else
|
||||
@ -355,11 +355,11 @@ tree_to_nomsu = (tree)->
|
||||
value_nomsu = tree_to_nomsu(value)
|
||||
if (value.type == "Block" or value.type == "EscapedNomsu") and not value_nomsu\is_multiline!
|
||||
value_nomsu\parenthesize!
|
||||
nomsu\append ": ", value_nomsu
|
||||
nomsu\add ": ", value_nomsu
|
||||
return nomsu
|
||||
|
||||
when "Comment"
|
||||
nomsu\append "#", (tree[1]\gsub("\n", "\n "))
|
||||
nomsu\add "#", (tree[1]\gsub("\n", "\n "))
|
||||
return nomsu
|
||||
|
||||
when "IndexChain", "Number", "Var", "Comment", "Error"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user