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

In-progress (but working) overhaul of some elements including: function

Browse Source 
calls, lib/thing.nom API, multi-assignments, varargs, etc.
This commit is contained in:
Bruce Hill 2018-11-17 14:38:05 -08:00
parent 34a3dd22a4
commit 7f47d42040
40 changed files with 553 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
code_obj.lua
View File

@ -77,7 +77,6 @@ local Code
do do
local _class_0 local _class_0
local _base_0 = { local _base_0 = {
is_code = true,
text = function(self) text = function(self)
if self.__str == nil then if self.__str == nil then
local buff, indent = { }, 0 local buff, indent = { }, 0
@ -169,7 +168,7 @@ do
_continue_0 = true _continue_0 = true
break break
end end
if b.is_code then if type(b) ~= 'string' then
b.dirty = error b.dirty = error
end end
bits[#bits + 1] = b bits[#bits + 1] = b
@ -223,7 +222,7 @@ do
end end
end end
bits[#bits + 1] = b bits[#bits + 1] = b
if b.is_code then if type(b) ~= 'string' then
b.dirty = error b.dirty = error
end end
if not (type(b) == 'string') then if not (type(b) == 'string') then
@ -246,7 +245,7 @@ do
end end
for i = 1, n do for i = 1, n do
local b = select(i, ...) local b = select(i, ...)
if b.is_code then if type(b) ~= 'string' then
b.dirty = error b.dirty = error
end end
bits[i] = b bits[i] = b

11
code_obj.moon
View File

@ -42,7 +42,6 @@ class Source
return Source(@filename, @start+offset, @stop) return Source(@filename, @start+offset, @stop)
class Code class Code
is_code: true
new: (...)=> new: (...)=>
@bits = {} @bits = {}
@append(...) @append(...)
@ -101,9 +100,7 @@ class Code
assert(b, "code bit is nil") assert(b, "code bit is nil")
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 type(b) != 'string'
--if type(b) != 'string' and not (type(b) == 'table' and b.is_code)
-- b = b\as_lua!
bits[#bits+1] = b bits[#bits+1] = b
@dirty! @dirty!
@ -140,7 +137,7 @@ class Code
else else
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 type(b) != 'string'
unless type(b) == 'string' unless type(b) == 'string'
b = b\text! b = b\text!
line = match(b, "\n([^\n]*)$") line = match(b, "\n([^\n]*)$")
@ -157,9 +154,7 @@ class Code
bits[i] = bits[i-n] bits[i] = bits[i-n]
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 type(b) != 'string'
--if type(b) != 'string' and not (type(b) == 'table' and b.is_code)
-- b = b\as_lua!
bits[i] = b bits[i] = b
@dirty! @dirty!

2
compatibility/2.3.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.10.12.7 #!/usr/bin/env nomsu -V4.11
# #
This file defines upgrades from Nomsu <2.3 to Nomsu 2.3 This file defines upgrades from Nomsu <2.3 to Nomsu 2.3

4
compatibility/3.5.5.6.nom
View File

@ -7,7 +7,7 @@ use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action "traceback" to "3.5.5.6" via (..) upgrade action "traceback" to "3.5.5.6" via (..)
[%] -> (barf "'traceback' has been deprecated") -> (barf "'traceback' has been deprecated")
upgrade action "traceback 1" to "3.5.5.6" via (..) upgrade action "traceback 1" to "3.5.5.6" via (..)
[%] -> (barf "'traceback 1' has been deprecated") -> (barf "'traceback 1' has been deprecated")

2
compatibility/3.nom
View File

@ -10,4 +10,4 @@ upgrade action (method %spec %body) to "3" as (my action %spec %body)
upgrade action (me) to "3" as %me upgrade action (me) to "3" as %me
upgrade action (@) to "3" as %me upgrade action (@) to "3" as %me
upgrade action "as" to "3" via (..) upgrade action "as" to "3" via (..)
[] -> (barf "Object API has changed. Use (%obj::action ...) instead of (as %obj: action ...)") -> (barf "Object API has changed. Use (%obj::action ...) instead of (as %obj: action ...)")

38
compatibility/4.10.12.7.nom
View File

@ -44,24 +44,32 @@ upgrade action (% as lua statements) to "4.10.12.7" as (% as lua)
upgrade action (compile error at %pos %err hint %hint) to "4.10.12.7" as (..) upgrade action (compile error at %pos %err hint %hint) to "4.10.12.7" as (..)
compile error at %pos %err %hint compile error at %pos %err %hint
# In old code, it was okay to have imports at the top of the file in the same chunk,
but changes to the API now require imports to be in their own file chunk in order
for compilation to work properly.
upgrade %tree to "4.10.12.7" as: upgrade %tree to "4.10.12.7" as:
if (%tree.type == "FileChunks"): if (%tree.type == "FileChunks"):
%first_chunk = %tree.1 %first_chunk = %tree.1
%first_has_use = (no)
%i = 1 %i = 1
repeat while (%i < (size of %first_chunk)): %has_use = (no)
if %first_has_use: repeat while (%i <= (size of %first_chunk)):
if ((%first_chunk.%i.type != "Action") or (%first_chunk.%i.stub != "use")): if ((%first_chunk.%i.type == "Action") and (%first_chunk.%i.stub == "use")):
%chunk2 = (%SyntaxTree {type: "Block"}) %has_use = (yes)
for %j in %i to (size of %first_chunk.%i):
%chunk2.((size of %chunk2) + 1) = %first_chunk.%i.%j
for %j in %i to (size of %first_chunk.%i):
%first_chunk.%i.%j = (nil)
%table.insert %tree 2 %chunk2
return %tree
..else: ..else:
if ((%first_chunk.type == "Action") and (%first_chunk.stub == "use")): if %has_use: go to (insert chunk)
%first_has_use = (yes)
%i += 1 %i += 1
return
=== (insert chunk) ===
[%chunk1, %chunk2] = [..]
SyntaxTree {type: "Block", source: %first_chunk.source}
SyntaxTree {type: "Block", source: %first_chunk.source}
for %j in 1 to (%i - 1):
%chunk1.%j = %first_chunk.%j
for %j in %i to (size of %first_chunk):
%chunk2.(%j - %i + 1) = %first_chunk.%j
%new_tree = (SyntaxTree {source: %tree.source, type: "FileChunks", 1: %chunk1, 2: %chunk2})
for %i in 2 to (size of %tree):
%new_tree.(%i + 1) = %tree.%i
return %new_tree

24
compatibility/4.11.nom
View File

@ -1,12 +1,34 @@
#!/usr/bin/env nomsu -V4.11 #!/usr/bin/env nomsu -V4.11
# #
This file defines upgrades from Nomsu <4.11 to Nomsu 4.11 This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
(deleting (if all of ...), etc. shorthand) (overhaul of function literals, deleting (if all of ...), etc. shorthand)
use "compatibility/compatibility.nom" use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Overhaul of function literals:
upgrade action "call 1 with" to "4.11" via (..)
for (%tree %end_version):
%tree2 = {type: "Action", source: %tree.source, 1: %tree.2}
for %arg in %tree.4 at %i:
%tree2.(%i + 1) = %arg
return (SyntaxTree %tree2)
upgrade action (-> %yield_value) to "4.11" as (yield %yield_value)
# Replace set {%x:1, %y:2} with [%x, %y] = [1, 2]
upgrade action "set" to "4.11" via (..)
for (%tree %end_version):
[%lhs, %rhs] = [\[], \[]]
%lhs.source = %tree.(2).source
%rhs.source = %tree.(2).source
for %entry in %tree.2 at %i:
%lhs.%i = %entry.1
%rhs.%i = %entry.2
return (SyntaxTree {type: "Action", source: %tree.source, 1: %lhs, 2: "=", 3: %rhs})
# Deprecating shorthand functions:
upgrade action [if all of %items %body, if all of %items then %body] to "4.11" as (..) upgrade action [if all of %items %body, if all of %items then %body] to "4.11" as (..)
if (all of %items) %body if (all of %items) %body

8
compatibility/4.8.10.nom
View File

@ -6,7 +6,7 @@ use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action "local action" to "4.8.10" via (..) upgrade action "local action" to "4.8.10" via (..)
[%tree, %end_version] ->: for (%tree %end_version):
%spec = %tree.3 %spec = %tree.3
%body = %tree.4 %body = %tree.4
if %spec.type is: if %spec.type is:
@ -20,7 +20,7 @@ upgrade action "local action" to "4.8.10" via (..)
return \(%spec means %body) return \(%spec means %body)
upgrade action "action" to "4.8.10" via (..) upgrade action "action" to "4.8.10" via (..)
[%tree, %end_version] ->: for (%tree %end_version):
%spec = %tree.2 %spec = %tree.2
%body = %tree.3 %body = %tree.3
if %body: if %body:
@ -37,7 +37,7 @@ upgrade action "action" to "4.8.10" via (..)
return \(%spec's meaning) return \(%spec's meaning)
upgrade action "compile 1 to" to "4.8.10" via (..) upgrade action "compile 1 to" to "4.8.10" via (..)
[%tree, %end_version] ->: for (%tree %end_version):
%spec = %tree.2 %spec = %tree.2
%body = %tree.4 %body = %tree.4
if %spec.type is: if %spec.type is:
@ -51,7 +51,7 @@ upgrade action "compile 1 to" to "4.8.10" via (..)
return \(%spec compiles to %body) return \(%spec compiles to %body)
upgrade action "parse 1 as" to "4.8.10" via (..) upgrade action "parse 1 as" to "4.8.10" via (..)
[%tree, %end_version] ->: for (%tree %end_version):
%spec = %tree.2 %spec = %tree.2
%body = %tree.4 %body = %tree.4
if %spec.type is: if %spec.type is:

2
compatibility/4.9.nom
View File

@ -6,6 +6,6 @@ use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action "if" to "4.9" via (..) upgrade action "if" to "4.9" via (..)
[%tree, %end_version] ->: for (%tree %end_version):
if ((size of %tree) > 2): return %tree if ((size of %tree) > 2): return %tree
return \(when %tree.2) return \(when %tree.2)

4
compatibility/compatibility.nom
View File

@ -15,7 +15,7 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
%ACTION_UPGRADES.%version.%stub = %upgrade_fn %ACTION_UPGRADES.%version.%stub = %upgrade_fn
(upgrade %tree to %version as %body) parses as (..) (upgrade %tree to %version as %body) parses as (..)
upgrade to %version via ([%, %end_version] -> (% with %tree -> %body)) upgrade to %version via ((% %end_version) -> (% with %tree -> %body))
(upgrade action %actions to %version as %body) compiles to: (upgrade action %actions to %version as %body) compiles to:
if (%actions is "Action" syntax tree): if (%actions is "Action" syntax tree):
@ -91,7 +91,7 @@ externally [..]
for %k = %v in %tree: for %k = %v in %tree:
add %k = (%v upgraded from %start_version to %end_version) add %k = (%v upgraded from %start_version to %end_version)
set %with_upgraded_args's metatable to (%tree's metatable) set %with_upgraded_args's metatable to (%tree's metatable)
%tree = (call %UPGRADES.%ver with [%with_upgraded_args, %end_version]) %tree = (%UPGRADES.%ver %with_upgraded_args %end_version)
%tree.shebang = "#!/usr/bin/env nomsu -V\%end_version\n" %tree.shebang = "#!/usr/bin/env nomsu -V\%end_version\n"
return %tree return %tree

18
containers.lua
View File

@ -491,21 +491,21 @@ do
result[#result + 1] = tmp result[#result + 1] = tmp
end end
return List(result) return List(result)
end,
from_1_to = sub,
from = sub,
character = function(self, i)
return sub(self, i, i)
end end
} }
setmetatable(text_methods, { setmetatable(text_methods, {
__index = string2 __index = string2
}) })
setmetatable(string2, {
__index = error
})
getmetatable("").__methods = text_methods getmetatable("").__methods = text_methods
getmetatable("").__index = function(self, i) getmetatable("").__index = text_methods
if type(i) == 'number' then
return sub(self, i, i)
elseif type(i) == 'table' then
return sub(self, i[1], i[2])
else
return text_methods[i]
end
end
getmetatable("").__add = function(self, x) getmetatable("").__add = function(self, x)
return tostring(self) .. tostring(x) return tostring(self) .. tostring(x)
end end

11
containers.moon
View File

@ -196,16 +196,13 @@ do
i = tmp[1] i = tmp[1]
result[#result+1] = tmp result[#result+1] = tmp
return List(result) return List(result)
from_1_to: sub, from: sub,
character: (i)=> sub(@, i, i)
setmetatable(text_methods, {__index:string2}) setmetatable(text_methods, {__index:string2})
setmetatable(string2, {__index:error})
getmetatable("").__methods = text_methods getmetatable("").__methods = text_methods
getmetatable("").__index = (i)=> getmetatable("").__index = text_methods
-- Use [] for accessing text characters, or s[{3,4}] for s:sub(3,4)
if type(i) == 'number' then return sub(@, i, i)
elseif type(i) == 'table' then return sub(@, i[1], i[2])
else return text_methods[i]
getmetatable("").__add = (x)=> tostring(@)..tostring(x) getmetatable("").__add = (x)=> tostring(@)..tostring(x)
return {:List, :Dict} return {:List, :Dict}

2
core/collections.nom
View File

@ -72,7 +72,7 @@ test:
# Metatable stuff # Metatable stuff
test: test:
%t = {} %t = {}
set %t's metatable to {__tostring: [%] -> "XXX"} set %t's metatable to {__tostring: % -> "XXX"}
assume ("\%t" == "XXX") assume ("\%t" == "XXX")
(set %dict's metatable to %metatable) compiles to "\ (set %dict's metatable to %metatable) compiles to "\

2
core/control_flow.nom
View File

@ -506,7 +506,7 @@ test:
assume ((result of: return 99) == 99) assume ((result of: return 99) == 99)
# Inline thunk: # Inline thunk:
(result of %body) compiles to "\(what ([] -> %body) compiles to)()" (result of %body) compiles to "\(what (-> %body) compiles to)()"
test: test:
%t = [1, [2, [[3], 4], 5, [[[6]]]]] %t = [1, [2, [[3], 4], 5, [[[6]]]]]
%flat = [] %flat = []

33
core/coroutines.nom
View File

@ -3,29 +3,40 @@
This file defines the code that creates and manipulates coroutines This file defines the code that creates and manipulates coroutines
use "core/metaprogramming.nom" use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/control_flow.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
%nums = []
%co = (..) %co = (..)
coroutine: ->:
-> 4 yield 4
-> 5 yield 5
repeat 3 times: -> 6 repeat 3 times: yield 6
%nums = []
for % in coroutine %co: for % in coroutine %co:
%nums::add % %nums::add %
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed" assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
[coroutine %body, generator %body] all compile to "\
..(function()
\(%body as lua)
end)"
(-> %) compiles to "coroutine.yield(true, \((% as lua expr) if % else "nil"))" %d = {x:0}
%co2 = (..)
coroutine:
%d.x += 1
yield 1
%d.x += 1
yield
%d.x += 1
repeat while ((coroutine status of %co2) != "dead"):
resume %co2
assume %d.x == 3
(coroutine %body) parses as (coroutine from (-> %body))
(for % in coroutine %co %body) compiles to "\ (for % in coroutine %co %body) compiles to "\
..for _junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do ..for \(% as lua expr) in coroutine_wrap(\(%co as lua expr)) do
\(%body as lua) \(%body as lua)
end" end"

2
core/id.nom
View File

@ -16,7 +16,7 @@ use "core/control_flow.nom"
set %obj_by_id's metatable to {__mode: "v"} set %obj_by_id's metatable to {__mode: "v"}
%id_by_obj = {} %id_by_obj = {}
set %id_by_obj's metatable to {..} set %id_by_obj's metatable to {..}
__mode: "k", __index: [%self, %key] ->: __mode: "k", __index: for (%self %key):
if (%key == (nil)): if (%key == (nil)):
return %self.%nil_surrogate return %self.%nil_surrogate

8
core/math.nom
View File

@ -70,7 +70,7 @@ externally [all of %items, all %items] all mean:
return (no) return (no)
return (yes) return (yes)
[all of %items, all %items] all compile to: #[all of %items, all %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(all of %items) return \(all of %items)
@ -89,7 +89,7 @@ externally [any of %items, any %items] all mean:
return (yes) return (yes)
return (no) return (no)
[any of %items, any %items] all compile to: #[any of %items, any %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(any of %items) return \(any of %items)
@ -110,7 +110,7 @@ externally [sum of %items, sum %items] all mean:
%total += % %total += %
return %total return %total
[sum of %items, sum %items] all compile to: #[sum of %items, sum %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(sum of %items) return \(sum of %items)
@ -128,7 +128,7 @@ externally [product of %items, product %items] all mean:
%prod *= % %prod *= %
return %prod return %prod
[product of %items, product %items] all compile to: #[product of %items, product %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(product of %items) return \(product of %items)

111
core/metaprogramming.nom
View File

@ -3,7 +3,8 @@
This File contains actions for making actions and compile-time actions and some helper This File contains actions for making actions and compile-time actions and some helper
functions to make that easier. functions to make that easier.
lua> "NOMSU_CORE_VERSION = 10\nNOMSU_LIB_VERSION = 7" lua> "NOMSU_CORE_VERSION = 11"
lua> "NOMSU_LIB_VERSION = 8"
lua> "\ lua> "\
..do ..do
local mangle_index = 0 local mangle_index = 0
@ -21,23 +22,38 @@ lua> "\
lua> "\ lua> "\
..compile.action["1 ->"] = function(compile, \%args, \%body) ..compile.action["1 ->"] = function(compile, \%args, \%body)
local lua = LuaCode("(function(") if \%args and not \%body then \%args, \%body = {}, \%args end
if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args() end
local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and compile(a):text(\
..) or a end)
lua:concat_append(lua_args, ", ")
local body_lua = SyntaxTree:is_instance(\%body) and compile(\%body) or \%body local body_lua = SyntaxTree:is_instance(\%body) and compile(\%body) or \%body
if SyntaxTree:is_instance(\%body) and \%body.type ~= "Block" then body_lua:prepend("return ") end if SyntaxTree:is_instance(\%body) and \%body.type ~= "Block" then body_lua:prepend("return ") end
body_lua:remove_free_vars(lua_args) local lua = LuaCode("(function(")
if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args()
elseif SyntaxTree:is_instance(\%args) and \%args.type == "Var" then \%args = {\%args} end
for i, arg in ipairs(\%args) do
local arg_lua = SyntaxTree:is_instance(arg) and compile(arg):text() or arg
if arg_lua == "..." then
if i < #\%args then
compile_error_at(SyntaxTree:is_instance(arg) and arg or nil,
"Extra arguments must come last.", "Try removing any arguments after (*extra arguments*)")
end
elseif not arg_lua:is_lua_id() then
compile_error_at(SyntaxTree:is_instance(arg) and arg or nil,
"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)
body_lua:remove_free_vars({arg_lua})
end
body_lua:declare_locals() body_lua:declare_locals()
lua:append(")\\n ", body_lua, "\\nend)") lua:append(")\\n ", body_lua, "\\nend)")
return lua return lua
end" end
compile.action["->"] = compile.action["1 ->"]
compile.action["for"] = compile.action["1 ->"]"
lua> "\ lua> "\
..compile.action["what 1 compiles to"] = function(compile, \%action) ..compile.action["what 1 compiles to"] = function(compile, \%action)
local lua = LuaCode("compile.action[", \%action.stub:as_lua(), "](") local lua = LuaCode("compile.action[", \%action.stub:as_lua(), "](")
local lua_args = table.map(\%action:get_args(), function(a) return compile(a) end) local lua_args = table.map(\%action:get_args(), compile)
table.insert(lua_args, 1, "compile") table.insert(lua_args, 1, "compile")
lua:concat_append(lua_args, ", ") lua:concat_append(lua_args, ", ")
lua:append(")") lua:append(")")
@ -100,17 +116,6 @@ lua> "\
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(call %fn with %args) compiles to:
lua> "\
..local lua = LuaCode(compile(\%fn), "(")
if \%args.type == 'List' then
lua:concat_append(table.map(\%args, function(a) return compile(a) end), ", ")
else
lua:append('unpack(', compile(\%args), ')')
end
lua:append(")")
return lua"
test: test:
(foo %x) means "outer" (foo %x) means "outer"
with local [(foo %)'s meaning]: with local [(foo %)'s meaning]:
@ -124,27 +129,36 @@ test:
(%action means %body) compiles to: (%action means %body) compiles to:
lua> "\ lua> "\
..local fn_name = \%action.stub:as_lua_id() ..
local \%args = \%action:get_args() local lua = LuaCode()
local lua = LuaCode(fn_name, " = ", \(what (%args -> %body) compiles to)) local fn_name = \%action.stub:as_lua_id()
lua:add_free_vars({fn_name}) if \%action.target then lua:append(compile(\%action.target), ".")
else lua:add_free_vars({fn_name}) end
lua:append(fn_name, " = ", \(what (%action -> %body) compiles to), ";")
return lua" return lua"
(%actions all mean %body) compiles to: (%actions all mean %body) compiles to:
lua> "\ lua> "\
..local fn_name = \%actions[1].stub:as_lua_id() ..local fn_name = \%actions[1].stub:as_lua_id()
local target = \%actions[1].target and compile(\%actions[1].target) or nil
local \%args = List(\%actions[1]:get_args()) local \%args = List(\%actions[1]:get_args())
local lua = \(what (%actions.1 means %body) compiles to) local lua = \(what (%actions.1 means %body) compiles to)
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})
local \%alias_args = List(alias:get_args()) local \%alias_args = List(alias:get_args())
lua:append("\\n", alias_name, " = ") lua:append("\\n")
if \%args == \%alias_args then if alias.target then
lua:append(fn_name) lua:append(compile(alias.target), ".")
else else
lua:append(\(what (%alias_args -> %actions.1) compiles to)) lua:add_free_vars({alias_name})
end
lua:append(alias_name, " = ")
if \%args == \%alias_args then
if target then lua:append(target, ".") end
lua:append(fn_name, ";")
else
lua:append(\(what (%alias_args -> %actions.1) compiles to), ";")
end end
end end
return lua" return lua"
@ -182,11 +196,11 @@ test:
%y = %tmp %y = %tmp
test: test:
set {%1: 1, %2: 2} [%1, %2] = [1, 2]
swap %1 and %2 swap %1 and %2
assume ((%1 == 2) and (%2 == 1)) or barf "\ assume ((%1 == 2) and (%2 == 1)) or barf "\
..'parse % as %' failed on 'swap % and %'" ..'parse % as %' failed on 'swap % and %'"
set {%tmp: 1, %tmp2: 2} [%tmp, %tmp2] = [1, 2]
swap %tmp and %tmp2 swap %tmp and %tmp2
assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\ assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\
..'parse % as %' variable mangling failed." ..'parse % as %' variable mangling failed."
@ -239,9 +253,15 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[%action parses as %body] all parse as ([%action] all parse as %body) [%action parses as %body] all parse as ([%action] all parse as %body)
(%tree as lua expr) compiles to "compile(\(=lua "compile(\%tree, true)"), true)" #(%tree as lua expr) compiles to "compile(\(=lua "compile(\%tree, true)"), true)"
externally (%tree as lua expr) means:
lua> "\
..local tree_lua = compile(\%tree)
if \%tree.type == 'Block' then
tree_lua = LuaCode:from(\%tree.source, '(function()\n ', tree_lua, '\nend)()')
end
return tree_lua"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
externally [%var as lua identifier, %var as lua id] all mean: externally [%var as lua identifier, %var as lua id] all mean:
lua> "\ lua> "\
@ -256,7 +276,14 @@ externally [%var as lua identifier, %var as lua id] all mean:
else error("Unknown type: "..tostring(\%var)) else error("Unknown type: "..tostring(\%var))
end" end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test:
(num args (*extra arguments*)) means (select "#" (*extra arguments*))
assume (num args 1 2 3) == 3
(extra args (*extra arguments*)) means [*extra arguments*]
assume (extra args 1 2 3) == [1, 2, 3]
(third arg (*extra arguments*)) means (select 3 (*extra arguments*))
assume (third arg 5 6 7 8) == 7
(*extra arguments*) compiles to "..."
(% is syntax tree) compiles to "SyntaxTree:is_instance(\(% as lua expr))" (% is syntax tree) compiles to "SyntaxTree:is_instance(\(% as lua expr))"
externally (% is %kind syntax tree) means (..) externally (% is %kind syntax tree) means (..)
@ -288,7 +315,7 @@ externally (%tree with vars %replacements) means (..)
(%tree has subtree %match_tree) compiles to "\ (%tree has subtree %match_tree) compiles to "\
..(function() ..(function()
local match_tree = \(%match_tree as lua expr) local match_tree = \(%match_tree as lua expr)
for subtree in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do for subtree in coroutine_wrap(function() \(%tree as lua expr):map(yield) end) do
if subtree == match_tree then return true end if subtree == match_tree then return true end
end end
end)()" end)()"
@ -366,10 +393,20 @@ test:
[compile %block, compiled %block, %block compiled] all compile to "\ [compile %block, compiled %block, %block compiled] all compile to "\
..compile(\(%block as lua))" ..compile(\(%block as lua))"
test:
(foo) means: return 100 200 300
assume (select 2 (foo)) == 200
# Return statement is wrapped in a do..end block because Lua is unhappy if you # Return statement is wrapped in a do..end block because Lua is unhappy if you
put code after a return statement, unless you wrap it in a block. put code after a return statement, unless you wrap it in a block.
(return %return_value) compiles to "\ (return (*extra arguments*)) compiles to:
..do return \(=lua "\%return_value and \(%return_value as lua expr) or ''") end" 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, ...))))
end
lua:append(" end")
return lua"
# Literals # Literals
(yes) compiles to "true" (yes) compiles to "true"

124
core/operators.nom
View File

@ -24,57 +24,58 @@ test:
test: test:
%x = 10 %x = 10
assume (%x == 10) assume (%x == 10)
[%x, %y] = [10, 20]
assume ((%x == 10) and (%y == 20)) or barf "mutli-assignment failed."
[%x, %y] = [%y, %x]
assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed."
%vals = [4, 5]
[%x, %y] = (unpack %vals)
assume ((%x == 4) and (%y == 5)) or barf "unpacking failed"
# Variable assignment operator # Variable assignment operator
(%var = %value) compiles to: (%var = %value) compiles to:
lua> "\ lua> "\
..local \%var_lua = \(%var as lua expr) ..
local \%value_lua = \(%value as lua expr) local lua = LuaCode()
local lua = LuaCode(\%var_lua, ' = ', \%value_lua, ';') if \%var.type == "List" then
if \%var.type == 'Var' then for i, \%assignment in ipairs(\%var) do
lua:add_free_vars({compile(\%var):text()}) if i > 1 then lua:append(", ") end
local assignment_lua = \(%assignment as lua expr)
lua:append(assignment_lua)
if \%assignment.type == 'Var' then
lua:add_free_vars({assignment_lua:text()})
end
end
lua:append(' = ')
if \%value.type == "List" then
if #\%value ~= #\%var then
compile_error_at(\%value,
"This assignment has too "..(#\%value > #\%var and "many" or "few").." values.",
"Make sure it has the same number of values on the left and right hand side of the '=' operator.")
end
for i, \%val in ipairs(\%value) do
if i > 1 then lua:append(", ") end
local val_lua = \(%val as lua expr)
lua:append(val_lua)
end
lua:append(";")
else
lua:append(\(%value as lua expr), ';')
end
else
local var_lua = \(%var as lua expr)
lua:append(var_lua)
if \%var.type == 'Var' then
lua:add_free_vars({var_lua:text()})
end
lua:append(' = ', \(%value as lua expr), ';')
end end
return lua" return lua"
test:
set {%x: 10, %y: 20}
assume ((%x == 10) and (%y == 20)) or barf "mutli-assignment failed."
set {%x: %y, %y: %x}
assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed."
# Simultaneous mutli-assignments like: x,y,z = 1,x,3;
# TODO: deprecate?
(set %assignments) compiles to:
assume (%assignments.type is "Dict") or barf "\
..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
lua> "\
..local lhs, rhs = LuaCode(), LuaCode()
for i, item in ipairs(\%assignments) do
local \%target, \%value = item[1], item[2]
\%value = \%value:map(function(t)
if SyntaxTree:is_instance(t) and t.type == "Action" and t.stub == "?" then
return \%target
end
end)
local target_lua = \(%target as lua)
local value_lua = \(%value as lua)
if \%target.type == "Var" then
lhs:add_free_vars({target_lua:text()})
end
if i > 1 then
lhs:append(", ")
rhs:append(", ")
end
lhs:append(target_lua)
rhs:append(value_lua)
end
return LuaCode(lhs, " = ", rhs, ";")"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
set {%foozle: "outer", %y: "outer"} [%foozle, %y] = ["outer", "outer"]
externally (set global x local y) means: externally (set global x local y) means:
external %foozle = "inner" external %foozle = "inner"
%y = "inner" %y = "inner"
@ -82,7 +83,7 @@ test:
assume ((%foozle == "inner") and (%y == "outer")) or barf "external failed." assume ((%foozle == "inner") and (%y == "outer")) or barf "external failed."
(external %var = %value) compiles to "\(%var as lua) = \(%value as lua)" (external %var = %value) compiles to "\(%var as lua) = \(%value as lua)"
test: test:
set {%foozle: "outer", %y: "outer"} [%foozle, %y] = ["outer", "outer"]
externally (set global x local y) means: externally (set global x local y) means:
with external [%foozle]: with external [%foozle]:
%foozle = "inner" %foozle = "inner"
@ -97,7 +98,7 @@ test:
return %body_lua return %body_lua
test: test:
set {%x: 1, %y: 2} [%x, %y] = [1, 2]
with {%z: nil, %x: 999}: with {%z: nil, %x: 999}:
%z = 999 %z = 999
assume (%z == 999) or barf "'with' failed." assume (%z == 999) or barf "'with' failed."
@ -149,29 +150,14 @@ test:
assume (%calls == 1) or barf "\ assume (%calls == 1) or barf "\
..Three-way comparison evaluated middle value multiple times" ..Three-way comparison evaluated middle value multiple times"
(%x < %y < %z) parses as (..) (%x < %y < %z) parses as (((%a %b %c) -> ((%a < %b) and (%b < %c))) %x %y %z)
call ([%a, %b, %c] -> ((%a < %b) and (%b < %c))) with [%x, %y, %z] (%x <= %y < %z) parses as (((%a %b %c) -> ((%a <= %b) and (%b < %c))) %x %y %z)
(%x < %y <= %z) parses as (((%a %b %c) -> ((%a < %b) and (%b <= %c))) %x %y %z)
(%x <= %y < %z) parses as (..) (%x <= %y <= %z) parses as (((%a %b %c) -> ((%a <= %b) and (%b <= %c))) %x %y %z)
call ([%a, %b, %c] -> ((%a <= %b) and (%b < %c))) with [%x, %y, %z] (%x > %y > %z) parses as (((%a %b %c) -> ((%a > %b) and (%b > %c))) %x %y %z)
(%x >= %y > %z) parses as (((%a %b %c) -> ((%a >= %b) and (%b > %c))) %x %y %z)
(%x < %y <= %z) parses as (..) (%x > %y >= %z) parses as (((%a %b %c) -> ((%a > %b) and (%b >= %c))) %x %y %z)
call ([%a, %b, %c] -> ((%a < %b) and (%b <= %c))) with [%x, %y, %z] (%x >= %y >= %z) parses as (((%a %b %c) -> ((%a >= %b) and (%b >= %c))) %x %y %z)
(%x <= %y <= %z) parses as (..)
call ([%a, %b, %c] -> ((%a <= %b) and (%b <= %c))) with [%x, %y, %z]
(%x > %y > %z) parses as (..)
call ([%a, %b, %c] -> ((%a > %b) and (%b > %c))) with [%x, %y, %z]
(%x >= %y > %z) parses as (..)
call ([%a, %b, %c] -> ((%a >= %b) and (%b > %c))) with [%x, %y, %z]
(%x > %y >= %z) parses as (..)
call ([%a, %b, %c] -> ((%a > %b) and (%b >= %c))) with [%x, %y, %z]
(%x >= %y >= %z) parses as (..)
call ([%a, %b, %c] -> ((%a >= %b) and (%b >= %c))) with [%x, %y, %z]
# TODO: optimize for common case where x,y,z are all either variables or number literals # TODO: optimize for common case where x,y,z are all either variables or number literals
# Boolean Operators # Boolean Operators
@ -249,9 +235,9 @@ test:
assume (%x == 4) or barf "*= failed" assume (%x == 4) or barf "*= failed"
wrap %x around 3 wrap %x around 3
assume (%x == 1) or barf "wrap around failed" assume (%x == 1) or barf "wrap around failed"
(%var += %) parses as (%var = (%var + %)) (%var += %) parses as (%var = ((%var or 0) + %))
(%var -= %) parses as (%var = (%var - %)) (%var -= %) parses as (%var = ((%var or 0) - %))
(%var *= %) parses as (%var = (%var * %)) (%var *= %) parses as (%var = ((%var or 1) * %))
(%var /= %) parses as (%var = (%var / %)) (%var /= %) parses as (%var = (%var / %))
(%var ^= %) parses as (%var = (%var ^ %)) (%var ^= %) parses as (%var = (%var ^ %))
(%var and= %) parses as (%var = (%var and %)) (%var and= %) parses as (%var = (%var and %))

2
core/text.nom
View File

@ -63,4 +63,4 @@ externally (%num as hex) means:
for %name = %str in %escapes: for %name = %str in %escapes:
with {%lua: Lua (quote %str)}: with {%lua: Lua (quote %str)}:
%compile.action.%name = ([] -> %lua) %compile.action.%name = (-> %lua)

8
examples/how_do_i.nom
View File

@ -219,11 +219,11 @@ I think "chihuahuas" are worse than "corgis"
# The language only reserves []{}().,:;%#\ as special characters, so actions # The language only reserves []{}().,:;%#\ as special characters, so actions
can have really funky names! can have really funky names!
(>> %foo_bar $@&' --> % @&_~-^-~_~-^ %1 !) means: (>> %foo_bar $@&' -->< % @&_~-^-~_~-^ %1 !) means:
say %foo_bar say %foo_bar
say % say %
say %1 say %1
>> "wow" $@&' --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" ! >> "wow" $@&' -->< "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" !
# There's also full unicode support # There's also full unicode support
%こんにちは = "こんにちは" %こんにちは = "こんにちは"
@ -305,8 +305,8 @@ debug only:
%best_key = %key %best_key = %key
return %best return %best
# Function literals look like: [%x] -> (%x * %x) # Function literals look like: %x -> (%x * %x)
say (best of [2, -3, 4, -8] according to ([%x] -> (%x * %x))) say (best of [2, -3, 4, -8] according to (%x -> (%x * %x)))
# Or, you can use ((foo %)'s meaning) to access the function that gets called by (foo %) # Or, you can use ((foo %)'s meaning) to access the function that gets called by (foo %)
(%x squared) means (%x * %x) (%x squared) means (%x * %x)

37
importer.lua
View File

@ -1,15 +1,27 @@
local import_to_1_from local import_to_1_from
import_to_1_from = function(host, to_import) import_to_1_from = function(host, to_import, prefix)
if prefix == nil then
prefix = nil
end
do do
local host_mt = getmetatable(host) local host_mt = getmetatable(host)
if host_mt then if host_mt then
if host_mt.__import then if host_mt.__import then
host_mt.__import(host, to_import) host_mt.__import(host, to_import, prefix)
return return
end end
end end
end end
for k, v in pairs(to_import) do for k, v in pairs(to_import) do
if k == to_import then
k = host
end
if v == to_import then
v = host
end
if prefix and type(k) == 'string' then
k = prefix .. k
end
host[k] = v host[k] = v
end end
end end
@ -20,19 +32,30 @@ local Importer = setmetatable({
__index = function(self, key) __index = function(self, key)
return _imports[self][key] return _imports[self][key]
end, end,
__import = function(self, to_import) __import = function(self, to_import, prefix)
if prefix == nil then
prefix = nil
end
local imports = assert(_imports[self]) local imports = assert(_imports[self])
for k, v in pairs(to_import) do for k, v in pairs(to_import) do
local _continue_0 = false local _continue_0 = false
repeat repeat
if prefix and type(k) == 'string' then
k = prefix .. k
end
imports[k] = v imports[k] = v
if v == to_import then if v == to_import then
_continue_0 = true _continue_0 = true
break break
end end
local conflict = self[k] local conflict = self[k]
if type(conflict) == 'table' then do
import_to_1_from(conflict, v) local conflict_mt = getmetatable(host)
if conflict_mt then
if conflict_mt.__import then
conflict_mt.__import(conflict, v, prefix)
end
end
end end
_continue_0 = true _continue_0 = true
until true until true
@ -49,8 +72,8 @@ local Importer = setmetatable({
end end
}) })
local _1_forked local _1_forked
_1_forked = function(self) _1_forked = function(self, t)
local f = Importer({ }) local f = Importer(t or { })
_imports[f] = assert(_imports[self]) _imports[f] = assert(_imports[self])
import_to_1_from(f, self) import_to_1_from(f, self)
return f return f

26
importer.moon
View File

@ -1,22 +1,36 @@
-- This file defines Importer, which is a type of table that can import from other tables -- This file defines Importer, which is a type of table that can import from other tables
import_to_1_from = (host, to_import)-> import_to_1_from = (host, to_import, prefix=nil)->
if host_mt = getmetatable(host) if host_mt = getmetatable(host)
if host_mt.__import if host_mt.__import
host_mt.__import(host, to_import) host_mt.__import(host, to_import, prefix)
return return
for k,v in pairs(to_import) for k,v in pairs(to_import)
if k == to_import then k = host
if v == to_import then v = host
if prefix and type(k) == 'string'
--print "PREFIXING #{k} -> #{prefix..k}"
k = prefix..k
--print("IMPORTED (#{k})")
host[k] = v host[k] = v
_imports = setmetatable({}, {__mode:"k"}) _imports = setmetatable({}, {__mode:"k"})
Importer = setmetatable({ Importer = setmetatable({
__index: (key)=> _imports[@][key] __index: (key)=> _imports[@][key]
__import: (to_import)=> __import: (to_import, prefix=nil)=>
imports = assert _imports[@] imports = assert _imports[@]
for k,v in pairs(to_import) for k,v in pairs(to_import)
if prefix and type(k) == 'string'
k = prefix..k
--print("IMPORTED (#{k})")
imports[k] = v imports[k] = v
continue if v == to_import continue if v == to_import
conflict = @[k] conflict = @[k]
import_to_1_from(conflict, v) if type(conflict) == 'table' if conflict_mt = getmetatable(host)
if conflict_mt.__import
conflict_mt.__import(conflict, v, prefix)
--__newindex: (k,v)=>
-- print("DEFINED (#{k})")
-- rawset(@, k, v)
}, { }, {
__call: (t)=> __call: (t)=>
_imports[t] = {} _imports[t] = {}
@ -24,8 +38,8 @@ Importer = setmetatable({
return t return t
}) })
_1_forked = => _1_forked = (t)=>
f = Importer{} f = Importer(t or {})
_imports[f] = assert _imports[@] _imports[f] = assert _imports[@]
import_to_1_from(f, @) import_to_1_from(f, @)
return f return f

28
lib/base64.nom
View File

@ -4,12 +4,14 @@
https://tools.ietf.org/html/rfc4648 https://tools.ietf.org/html/rfc4648
%b64_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" %b64_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
%reverse_b64 = {: for %i in 1 to (size of %b64_str): add %b64_str.%i = (%i - 1)} %b64_chars = [: for % in 1 to (size of %b64_str): add (%b64_str::character %)]
%reverse_b64."=" = 0 %reverse_b64 = {: for %c in %b64_chars at %i: add %c = (%i - 1)}
%reverse_b64."=" = 64
set %reverse_b64's metatable to {__index: -> 0}
test: test:
%cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"] %cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"]
for %len = %encoded in %cases: for %len = %encoded in %cases:
%plain = "foobar".[1, %len - 1] %plain = ("foobar"::from 1 to (%len - 1))
assume (base64 %plain) == %encoded assume (base64 %plain) == %encoded
assume (base64 decode %encoded) == %plain assume (base64 decode %encoded) == %plain
@ -17,20 +19,20 @@ externally [base64 %str, base64 encode %str, %str base64] all mean:
%chars = [] %chars = []
for %i in 1 to (size of %str) via 3: for %i in 1 to (size of %str) via 3:
%bytes = [=lua "\%str:byte(\%i, \(%i + 2))"] %bytes = [=lua "\%str:byte(\%i, \(%i + 2))"]
%chars::add %b64_str.(((%bytes.1 & 252) >> 2) + 1) %chars::add %b64_chars.(((%bytes.1 & 252) >> 2) + 1)
if (size of %bytes) is: if (size of %bytes) is:
3: 3:
%chars::add %b64_str.(((%bytes.1 & 3) << 4) + ((%bytes.2 & 240) >> 4) + 1) %chars::add %b64_chars.(((%bytes.1 & 3) << 4) + ((%bytes.2 & 240) >> 4) + 1)
%chars::add %b64_str.(((%bytes.2 & 15) << 2) + ((%bytes.3 & 192) >> 6) + 1) %chars::add %b64_chars.(((%bytes.2 & 15) << 2) + ((%bytes.3 & 192) >> 6) + 1)
%chars::add %b64_str.((%bytes.3 & 63) + 1) %chars::add %b64_chars.((%bytes.3 & 63) + 1)
2: 2:
%chars::add %b64_str.(((%bytes.1 & 3) << 4) + ((%bytes.2 & 240) >> 4) + 1) %chars::add %b64_chars.(((%bytes.1 & 3) << 4) + ((%bytes.2 & 240) >> 4) + 1)
%chars::add %b64_str.(((%bytes.2 & 15) << 2) + 1) %chars::add %b64_chars.(((%bytes.2 & 15) << 2) + 1)
%chars::add "=" %chars::add "="
1: 1:
%chars::add %b64_str.(((%bytes.1 & 3) << 4) + 1) %chars::add %b64_chars.(((%bytes.1 & 3) << 4) + 1)
%chars::add "=" %chars::add "="
%chars::add "=" %chars::add "="
return (%chars::joined) return (%chars::joined)
@ -39,10 +41,10 @@ externally (chr %) means (=lua "string.char(\%)")
externally [decode base64 %str, %str base64 decoded, base64 decode %str] all mean: externally [decode base64 %str, %str base64 decoded, base64 decode %str] all mean:
%chars = [] %chars = []
for %i in 1 to (size of %str) via 4: for %i in 1 to (size of %str) via 4:
%indices = [: for % in %i to (%i + 3): add %reverse_b64.(%str.%)] %indices = [: for %j in %i to (%i + 3): add %reverse_b64.(%str::character %j)]
%chars::add (chr ((%indices.1 << 2) + ((%indices.2 & 48) >> 4))) %chars::add (chr ((%indices.1 << 2) + ((%indices.2 & 48) >> 4)))
if (%str.(%i + 2) == "="): stop if ((%str::character (%i + 2)) == "="): stop
%chars::add (chr (((%indices.2 & 15) << 4) + ((%indices.3 & 60) >> 2))) %chars::add (chr (((%indices.2 & 15) << 4) + ((%indices.3 & 60) >> 2)))
if (%str.(%i + 3) == "="): stop if ((%str::character (%i + 3)) == "="): stop
%chars::add (chr (((%indices.3 & 3) << 6) + %indices.4)) %chars::add (chr (((%indices.3 & 3) << 6) + %indices.4))
return (%chars::joined) return (%chars::joined)

2
lib/consolecolor.nom
View File

@ -19,7 +19,7 @@ for %name = %colornum in %colors:
#(=lua "COMPILE_ACTIONS").%name = (..) #(=lua "COMPILE_ACTIONS").%name = (..)
[%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'") [%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'")
%compile.action.%name = (..) %compile.action.%name = (..)
[%nomsu, %text] ->: for (%compile %text):
if %text: if %text:
return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')") return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
..else: ..else:

163
lib/things.nom
View File

@ -2,32 +2,28 @@
# #
A library for simple object oriented programming. A library for simple object oriented programming.
%globals.METAMETHOD_MAP = {..}
"as text": "__tostring", "clean up": "__gc", "+": "__add", "-": "__sub"
"*": "__mul", "/": "__div", negative: "__unm", "//": "__idiv", mod: "__mod"
"^": "__pow", "&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot"
"<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", "<=": "__le"
"set 1 =": "__newindex", size: "__len", iterate: "__ipairs", "iterate all": "__pairs"
test: test:
an (Empty) is a thing an (Empty) is a thing
a (Dog) is a thing: a (Dog) is a thing:
that can (set up) by: [%it, %its] = [Dog, Dog]
(%its::set up) means:
%its.barks or= 0 %its.barks or= 0
whose [bark, woof] all mean: [%its::bark, %its::woof] all mean:
%barks = [: for % in 1 to %its.barks: add "Bark!"] %barks = [: for % in 1 to %its.barks: add "Bark!"]
return (%barks::joined with " ") return (%barks::joined with " ")
that can (get pissed off) by: %its.barks += 1 (%it::gets pissed off) means:
%it.barks += 1
(Dog).genus = "Canus" (Dog).genus = "Canus"
%d = (a Dog with {barks: 2}) %d = (a Dog with {barks: 2})
assume "\%d" == "Dog {barks: 2}"
assume (type of %d) == "Dog" assume (type of %d) == "Dog"
assume (%d is a "Dog") assume (%d is a "Dog")
assume %d.barks == 2 assume %d.barks == 2
assume ((%d::bark) == "Bark! Bark!") assume ((%d::bark) == "Bark! Bark!")
assume ((%d::woof) == "Bark! Bark!") assume ((%d::woof) == "Bark! Bark!")
%d::get pissed off %d::gets pissed off
assume (%d.barks == 3) assume (%d.barks == 3)
assume ((%d::bark) == "Bark! Bark! Bark!") assume ((%d::bark) == "Bark! Bark! Bark!")
assume (%d.genus == "Canus") assume (%d.genus == "Canus")
@ -40,112 +36,101 @@ test:
assume ((%d::bark) == "Bark!") assume ((%d::bark) == "Bark!")
a (Corgi) is a thing: a (Corgi) is a thing:
that can [set up, get pissed off] like a (Dog) [%it, %its] = [Corgi, Corgi]
whose (sploot) means "splooted" %it [set up, gets pissed off] like a (Dog)
whose [bark, woof] all mean: (%it::as text) means "Dogloaf \({: for %k = %v in %it: add %k = %v })"
(%its::sploot) means "sploooot"
[%its::bark, %its::woof] all mean:
%barks = [: for % in 1 to %its.barks: add "Yip!"] %barks = [: for % in 1 to %its.barks: add "Yip!"]
return (%barks::joined with " ") return (%barks::joined with " ")
%corg = (a Corgi) %corg = (a Corgi)
assume (%corg.barks == 0) assume (%corg.barks == 0)
assume "\%corg" == "Dogloaf {barks: 0}"
with {%d: a Corgi with {barks: 1}}: with {%d: a Corgi with {barks: 1}}:
assume ((%d::sploot) == "splooted") or barf "subclass method failed" assume ((%d::sploot) == "sploooot") or barf "subclass method failed"
assume ((%d::bark) == "Yip!") or barf "inheritance failed" assume ((%d::bark) == "Yip!") or barf "inheritance failed"
assume ((%d::woof) == "Yip!") assume ((%d::woof) == "Yip!")
with {%d: a Dog with {barks: 2}}: with {%d: a Dog with {barks: 2}}:
assume ((%d::bark) == "Bark! Bark!") assume ((%d::bark) == "Bark! Bark!")
[..] a (Vec) is a thing with {x, y}:
that can %actions by %body, whose %actions means %body %its = (Vec)
whose %actions all mean %body (%its::+ %other) means (Vec {x: %its.x + %other.x, y: %its.y + %other.y})
..all compile to:
unless (%actions.type == "List"):
%actions = [%actions]
lua> "\
..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = List{\(\%its), unpack(\%actions[1]:get_args())}
local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to))
for i=2,#\%actions do
local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id()
local \%alias_args = List{\(\%its), unpack(alias:get_args())}
lua:append("\\nclass.", alias_name, " = ")
if \%alias_args == \%args then
lua:append("class.", fn_name)
else
lua:append("function(")
lua:concat_append(table.map(\%alias_args, function(a) return compile(a) end), ", ")
lua:append(")\\n return class.", fn_name, "(")
lua:concat_append(table.map(\%args, function(a) return compile(a) end), ", ")
lua:append(")\\nend")
end
end
return lua"
assume ((Vec {x: 1, y:2 }) + (Vec {x: 10, y: 10})) == (Vec {x: 11, y: 12})
assume (((Vec {x: 1, y:2 }) + (Vec {x: 10, y: 10})) != (Vec {x: 0, y: 0}))
[..] [..]
that can %actions like a %class, that can %actions like an %class %it can %actions like a %class, %it can %actions like an %class
that has %actions like a %class, that has %actions like an %class %it has %actions like a %class, %it has %actions like an %class
%it %actions like a %class, %it %actions like an %class
..all compile to: ..all compile to:
%lua = (Lua "") %lua = (Lua "")
%class_expr = (%class as lua expr) %class_expr = (%class as lua expr)
%lines = [] %lines = []
for %a in %actions: for %a in %actions:
%lines::add "class.\(%a.stub::as lua id) = \%class_expr.\(%a.stub::as lua id)" %lines::add "\(%it as lua expr).\(%a.stub::as lua id) = \%class_expr.\(%a.stub::as lua id)"
%lua::add %lines joined with "\n" %lua::add %lines joined with "\n"
return %lua return %lua
%METAMETHOD_MAP = {..}
"as text": "__tostring", "clean up": "__gc", "+": "__add", "-": "__sub"
"*": "__mul", "/": "__div", negative: "__unm", "//": "__idiv", mod: "__mod"
"^": "__pow", "&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot"
"<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", "<=": "__le"
"set 1 =": "__newindex", size: "__len", iterate: "__ipairs", "iterate all": "__pairs"
((% as text like a dict)'s meaning) = ({}'s metatable).__tostring
externally (..)
a class named %classname with %members ((initialize %it)'s meaning)
..means:
%class = {__type: %classname}
%class.__index = %class
%class.class = %class
%class.__tostring = (% -> "\(%.__type) \(% as text like a dict)")
%class.__eq = ({}'s metatable).__eq
%class.__len = ({}'s metatable).__len
if %members:
%class.__members = %members
%class.__newindex = (..)
for (%its %key = %value):
if %members.%key:
rawset %its %key %value
..else:
barf "Cannot set \%key, it's not one of the allowed member fields."
set %class's metatable to {..}
__tostring: (%class) -> %class.__type
__call: for (%class with %initial_values):
if (%initial_values == (nil)): return %class
set %initial_values's metatable to %class
if %initial_values.set_up: %initial_values::set up
return %initial_values
if ((initialize)'s meaning):
initialize %class
for %stub = %metamethod in %METAMETHOD_MAP:
if %class.(%stub::as lua id):
%class.%metamethod = %class.(%stub::as lua id)
return %class
[..] [..]
a %classname is a thing with %members %class_body a %classname is a thing with %members %class_body
an %classname is a thing with %members %class_body an %classname is a thing with %members %class_body
..all compile to: ..all compile to:
unless (%classname.type == "Action"): %class_id = (%classname.stub::as lua id)
compile error at %classname "\ if %class_body:
..Expected this to be an action, not a \%classname.type" %body_lua = (%class_body as lua)
%body_lua::remove free vars [%class_id]
for % in %classname: %body_lua::declare locals
unless (% is text):
compile error at % "Class names should not have arguments."
return (..) return (..)
Lua "\ Lua "\
..do ..\%class_id = a_class_named_1_with(\(quote %classname.stub), \(%members as lua)\(..)
local class = {name=\(quote %classname.stub)} (Lua ", function(\%class_id)\n \%body_lua\nend") if %class_body else ""
class.__type = class.name ..)
setmetatable(class, { a_\%class_id = function(initial_values) return \(%classname.stub::as lua id)(initial_values or {}) end
__tostring=function(cls) return cls.name end, an_\%class_id, a_\(%class_id)_with, an_\(%class_id)_with = \
__call=function(cls, inst) ..a_\%class_id, a_\%class_id, a_\%class_id"
inst = setmetatable(inst or {}, cls)
if inst.set_up then inst:set_up() end
return inst
end,
})
class.__members = \(%members as lua expr)
_ENV[("a "..class.name):as_lua_id()] = class
_ENV[("an "..class.name):as_lua_id()] = class
_ENV[("a "..class.name.." with"):as_lua_id()] = class
_ENV[("an "..class.name.." with"):as_lua_id()] = class
_ENV[class.name:as_lua_id()] = function() return class end
class.__index = class
class.class = class
local dict_tostring = getmetatable(Dict{}).__tostring
class.__tostring = function(inst)
return inst.name..dict_tostring(inst)
end
\((%class_body as lua) if %class_body else "")
for stub,metamethod in pairs(globals.METAMETHOD_MAP) do
class[metamethod] = class[stub:as_lua_id()]
end
if class.__members then
assert(select(2, next(class.__members)) == true)
getmetatable(class).__newindex = function(its, key, value)
if class.__members[key] then
rawset(its, key, value)
else error("Not a valid member: "..tostring(key)) end
end
end
end"
[a %classname is a thing %class_body, an %classname is a thing] all parse as (..) [a %classname is a thing %class_body, an %classname is a thing] all parse as (..)
a %classname is a thing with (nil) %class_body a %classname is a thing with (nil) %class_body

3
lib/version.nom
View File

@ -1,3 +0,0 @@
#!/usr/bin/env nomsu -V4.10.12.7
# This file sets the current library version.
lua> "NOMSU_LIB_VERSION = 7"

4
nomsu.4.peg
View File

@ -118,14 +118,14 @@ inline_action (Action):
( (inline_arg (ws* (inline_arg / word))+) ( (inline_arg (ws* (inline_arg / word))+)
/ (word (ws* (inline_arg / word))*)) / (word (ws* (inline_arg / word))*))
(ws* inline_block)? (ws* inline_block)?
inline_arg: inline_expression / inline_block inline_arg: inline_expression / inline_block / "(" ws* ")"
action (Action): action (Action):
!section_division !section_division
({:target: (expression / "(" inline_block ")" / indented_block) :} ({:target: (expression / "(" inline_block ")" / indented_block) :}
((ws* "\")? eol nl_nodent "..")? ws* "::" ((ws* "\")? eol nl_nodent "..")? ws*)? ((ws* "\")? eol nl_nodent "..")? ws* "::" ((ws* "\")? eol nl_nodent "..")? ws*)?
( (arg (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))+) ( (arg (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))+)
/ (word (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))*)) / (word (((ws* "\")? eol nl_nodent "..")? ws* (arg / word))*))
arg: expression / inline_block / indented_block arg: expression / inline_block / indented_block / "(" ws* ")"
word: !number { operator_char+ / ident_char+ } word: !number { operator_char+ / ident_char+ }

16
nomsu.lua
View File

@ -202,12 +202,12 @@ run = function()
for chunk_no, chunk in ipairs(tree) do for chunk_no, chunk in ipairs(tree) do
local lua = nomsu_environment.compile(chunk) local lua = nomsu_environment.compile(chunk)
lua:declare_locals() lua:declare_locals()
nomsu_environment.run_1_in(chunk, nomsu_environment) lua:prepend((chunk_no > 1) and '\n' or '', "-- File " .. tostring(filename) .. " chunk #" .. tostring(chunk_no) .. "\n")
output:write((chunk_no > 1) and '\n' or '', "-- File " .. tostring(filename) .. " chunk #" .. tostring(chunk_no) .. "\n")
output:write(tostring(lua), "\n")
if args.verbose then if args.verbose then
print(tostring(lua)) print(lua:text())
end end
nomsu_environment.run_1_in(chunk, nomsu_environment)
output:write(lua:text(), "\n")
end end
print(("Compiled %-25s -> %s"):format(filename, filename:gsub("%.nom$", ".lua"))) print(("Compiled %-25s -> %s"):format(filename, filename:gsub("%.nom$", ".lua")))
output:close() output:close()
@ -221,12 +221,12 @@ run = function()
tree tree
} }
end end
for _index_1 = 1, #tree do for chunk_no, chunk in ipairs(tree) do
local chunk = tree[_index_1]
local lua = nomsu_environment.compile(chunk) local lua = nomsu_environment.compile(chunk)
lua:declare_locals() lua:declare_locals()
nomsu_environment.run_1_in(chunk, nomsu_environment) lua:prepend((chunk_no > 1) and '\n' or '', "-- File " .. tostring(filename) .. " chunk #" .. tostring(chunk_no) .. "\n")
print(tostring(lua)) print(lua:text())
nomsu_environment.run_1_in(lua, nomsu_environment)
end end
else else
nomsu_environment.run_file_1_in(filename, nomsu_environment, 0) nomsu_environment.run_file_1_in(filename, nomsu_environment, 0)

13
nomsu.moon
View File

@ -131,10 +131,10 @@ run = ->
for chunk_no, chunk in ipairs tree for chunk_no, chunk in ipairs tree
lua = nomsu_environment.compile(chunk) lua = nomsu_environment.compile(chunk)
lua\declare_locals! lua\declare_locals!
lua\prepend((chunk_no > 1) and '\n' or '', "-- File #{filename} chunk ##{chunk_no}\n")
if args.verbose then print(lua\text!)
nomsu_environment.run_1_in(chunk, nomsu_environment) nomsu_environment.run_1_in(chunk, nomsu_environment)
output\write((chunk_no > 1) and '\n' or '', "-- File #{filename} chunk ##{chunk_no}\n") output\write(lua\text!, "\n")
output\write(tostring(lua), "\n")
if args.verbose then print(tostring(lua))
print ("Compiled %-25s -> %s")\format(filename, filename\gsub("%.nom$", ".lua")) print ("Compiled %-25s -> %s")\format(filename, filename\gsub("%.nom$", ".lua"))
output\close! output\close!
elseif args.verbose elseif args.verbose
@ -143,11 +143,12 @@ run = ->
code = NomsuCode\from(source, code) code = NomsuCode\from(source, code)
tree = nomsu_environment._1_parsed(code) tree = nomsu_environment._1_parsed(code)
tree = {tree} unless tree.type == 'FileChunks' tree = {tree} unless tree.type == 'FileChunks'
for chunk in *tree for chunk_no, chunk in ipairs tree
lua = nomsu_environment.compile(chunk) lua = nomsu_environment.compile(chunk)
lua\declare_locals! lua\declare_locals!
nomsu_environment.run_1_in(chunk, nomsu_environment) lua\prepend((chunk_no > 1) and '\n' or '', "-- File #{filename} chunk ##{chunk_no}\n")
print(tostring(lua)) print(lua\text!)
nomsu_environment.run_1_in(lua, nomsu_environment)
else else
-- Just run the file -- Just run the file
nomsu_environment.run_file_1_in(filename, nomsu_environment, 0) nomsu_environment.run_file_1_in(filename, nomsu_environment, 0)

83
nomsu_compiler.lua
View File

@ -29,6 +29,7 @@ do
local _obj_0 = require('importer') local _obj_0 = require('importer')
Importer, import_to_1_from, _1_forked = _obj_0.Importer, _obj_0.import_to_1_from, _obj_0._1_forked Importer, import_to_1_from, _1_forked = _obj_0.Importer, _obj_0.import_to_1_from, _obj_0._1_forked
end end
local Files = require("files")
table.map = function(t, fn) table.map = function(t, fn)
return setmetatable((function() return setmetatable((function()
local _accum_0 = { } local _accum_0 = { }
@ -42,18 +43,28 @@ table.map = function(t, fn)
end end
local pretty_error = require("pretty_errors") local pretty_error = require("pretty_errors")
local compile_error local compile_error
compile_error = function(tree, err_msg, hint) compile_error = function(source, err_msg, hint)
if hint == nil then if hint == nil then
hint = nil hint = nil
end end
local file
if SyntaxTree:is_instance(source) then
file = source:get_source_file()
source = source.source
elseif type(source) == 'string' then
source = Source:from_string(source)
end
if source and not file then
file = Files.read(source.filename)
end
local err_str = pretty_error({ local err_str = pretty_error({
title = "Compile error", title = "Compile error",
error = err_msg, error = err_msg,
hint = hint, hint = hint,
source = tree:get_source_file(), source = file,
start = tree.source.start, start = source.start,
stop = tree.source.stop, stop = source.stop,
filename = tree.source.filename filename = source.filename
}) })
return error(err_str, 0) return error(err_str, 0)
end end
@ -78,7 +89,7 @@ local compile = setmetatable({
if i > 1 then if i > 1 then
lua:append(", ") lua:append(", ")
end end
lua:append(compile(select(i, ...))) lua:append(compile((select(i, ...))))
end end
lua:append(")") lua:append(")")
return lua return lua
@ -138,6 +149,9 @@ local compile = setmetatable({
["use"] = function(compile, path) ["use"] = function(compile, path)
return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION)") return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION)")
end, end,
["use 1 with prefix"] = function(compile, path, prefix)
return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION, ", compile(prefix), ")")
end,
["tests"] = function(compile) ["tests"] = function(compile)
return LuaCode("TESTS") return LuaCode("TESTS")
end, end,
@ -165,18 +179,13 @@ local compile = setmetatable({
end end
}) })
}, { }, {
__import = function(self, other) __import = import_to_1_from,
import_to_1_from(self.action, other.action) __call = function(compile, tree)
end,
__call = function(compile, tree, force_value)
if force_value == nil then
force_value = false
end
local _exp_0 = tree.type local _exp_0 = tree.type
if "Action" == _exp_0 then if "Action" == _exp_0 then
local stub = tree.stub local stub = tree.stub
local compile_action = compile.action[stub] local compile_action = compile.action[stub]
if not compile_action and math_expression:match(stub) then if not compile_action and not tree.target and math_expression:match(stub) then
local lua = LuaCode:from(tree.source) local lua = LuaCode:from(tree.source)
for i, tok in ipairs(tree) do for i, tok in ipairs(tree) do
if type(tok) == 'string' then if type(tok) == 'string' then
@ -226,7 +235,7 @@ local compile = setmetatable({
if tree.target then if tree.target then
local target_lua = compile(tree.target) local target_lua = compile(tree.target)
local target_text = target_lua:text() local target_text = target_lua:text()
if target_text:match("^%(.*%)$") or target_text:match("^[_a-zA-Z][_a-zA-Z0-9.]*$") then 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:append(target_lua, ":")
else else
lua:append("(", target_lua, "):") lua:append("(", target_lua, "):")
@ -241,7 +250,10 @@ local compile = setmetatable({
_continue_0 = true _continue_0 = true
break break
end end
local arg_lua = compile(tok, true) local arg_lua = compile(tok)
if tok.type == "Block" then
arg_lua = LuaCode:from(tok.source, "(function()\n ", arg_lua, "\nend)()")
end
insert(args, arg_lua) insert(args, arg_lua)
_continue_0 = true _continue_0 = true
until true until true
@ -287,28 +299,14 @@ local compile = setmetatable({
lua:append("}") lua:append("}")
return lua return lua
elseif "Block" == _exp_0 then elseif "Block" == _exp_0 then
if not force_value then local lua = LuaCode:from(tree.source)
local lua = LuaCode:from(tree.source) for i, line in ipairs(tree) do
lua:concat_append((function() if i > 1 then
local _accum_0 = { } lua:append("\n")
local _len_0 = 1
for _index_0 = 1, #tree do
local line = tree[_index_0]
_accum_0[_len_0] = compile(line)
_len_0 = _len_0 + 1
end
return _accum_0
end)(), "\n")
return lua
else
local lua = LuaCode:from(tree.source)
lua:append("((function()")
for i, line in ipairs(tree) do
lua:append("\n ", compile(line))
end end
lua:append("\nend)())") lua:append(compile(line))
return lua
end end
return lua
elseif "Text" == _exp_0 then elseif "Text" == _exp_0 then
local lua = LuaCode:from(tree.source) local lua = LuaCode:from(tree.source)
local string_buffer = "" local string_buffer = ""
@ -352,7 +350,7 @@ local compile = setmetatable({
end end
return lua return lua
elseif "List" == _exp_0 or "Dict" == _exp_0 then elseif "List" == _exp_0 or "Dict" == _exp_0 then
local lua = LuaCode:from(tree.source, tostring(tree.type) .. "{") local lua = LuaCode:from(tree.source)
local i = 1 local i = 1
local sep = '' local sep = ''
while i <= #tree do while i <= #tree do
@ -371,7 +369,11 @@ local compile = setmetatable({
end end
i = i + 1 i = i + 1
end end
lua:append("}") if lua:is_multiline() then
lua = LuaCode:from(tree.source, tostring(tree.type) .. "{\n ", lua, "\n}")
else
lua = LuaCode:from(tree.source, tostring(tree.type) .. "{", lua, "}")
end
if i <= #tree then if i <= #tree then
lua = LuaCode:from(tree.source, "(function()\n local comprehension = ", lua) lua = LuaCode:from(tree.source, "(function()\n local comprehension = ", lua)
if tree.type == "List" then if tree.type == "List" then
@ -441,4 +443,7 @@ local compile = setmetatable({
end end
end end
}) })
return compile return {
compile = compile,
compile_error = compile_error
}

74
nomsu_compiler.moon
View File

@ -19,19 +19,26 @@ unpack or= table.unpack
{:LuaCode, :Source} = require "code_obj" {:LuaCode, :Source} = require "code_obj"
SyntaxTree = require "syntax_tree" SyntaxTree = require "syntax_tree"
{:Importer, :import_to_1_from, :_1_forked} = require 'importer' {:Importer, :import_to_1_from, :_1_forked} = require 'importer'
Files = require "files"
table.map = (t, fn)-> setmetatable([fn(v) for _,v in ipairs(t)], getmetatable(t)) table.map = (t, fn)-> setmetatable([fn(v) for _,v in ipairs(t)], getmetatable(t))
-- TODO:
-- Re-implement nomsu-to-lua comment translation?
-- TODO: de-duplicate this -- TODO: de-duplicate this
pretty_error = require("pretty_errors") pretty_error = require("pretty_errors")
compile_error = (tree, err_msg, hint=nil)-> compile_error = (source, err_msg, hint=nil)->
local file
if SyntaxTree\is_instance(source)
file = source\get_source_file!
source = source.source
elseif type(source) == 'string'
source = Source\from_string(source)
if source and not file
file = Files.read(source.filename)
err_str = pretty_error{ err_str = pretty_error{
title: "Compile error" title: "Compile error"
error:err_msg, hint:hint, source:tree\get_source_file! error:err_msg, hint:hint, source:file
start:tree.source.start, stop:tree.source.stop, filename:tree.source.filename start:source.start, stop:source.stop, filename:source.filename
} }
error(err_str, 0) error(err_str, 0)
{:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler" {:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler"
@ -53,7 +60,7 @@ compile = setmetatable({
lua\append "(" lua\append "("
for i=1,select('#',...) for i=1,select('#',...)
lua\append(", ") if i > 1 lua\append(", ") if i > 1
lua\append compile(select(i, ...)) lua\append compile((select(i, ...)))
lua\append ")" lua\append ")"
return lua return lua
@ -94,11 +101,10 @@ compile = setmetatable({
["= lua"]: (compile, code)-> compile.action["lua >"](compile, code) ["= lua"]: (compile, code)-> compile.action["lua >"](compile, code)
["use"]: (compile, path)-> ["use"]: (compile, path)-> LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION)")
--if path.type == 'Text' and #path == 1 and type(path[1]) == 'string'
-- unless import_to_1_from(compile, path[1]) ["use 1 with prefix"]: (compile, path, prefix)->
-- compile_error tree, "Could not find anything to import for #{path}" LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION, ", compile(prefix), ")")
return LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION)")
["tests"]: (compile)-> LuaCode("TESTS") ["tests"]: (compile)-> LuaCode("TESTS")
["test"]: (compile, body)-> ["test"]: (compile, body)->
@ -114,15 +120,13 @@ compile = setmetatable({
["nomsu environment"]: (compile)-> LuaCode("_ENV") ["nomsu environment"]: (compile)-> LuaCode("_ENV")
} }
}, { }, {
__import: (other)=> __import: import_to_1_from
import_to_1_from(@action, other.action) __call: (compile, tree)->
return
__call: (compile, tree, force_value=false)->
switch tree.type switch tree.type
when "Action" when "Action"
stub = tree.stub stub = tree.stub
compile_action = compile.action[stub] compile_action = compile.action[stub]
if not compile_action and math_expression\match(stub) if not compile_action and not tree.target and math_expression\match(stub)
lua = LuaCode\from(tree.source) lua = LuaCode\from(tree.source)
for i,tok in ipairs tree for i,tok in ipairs tree
if type(tok) == 'string' if type(tok) == 'string'
@ -155,7 +159,9 @@ compile = setmetatable({
if tree.target -- Method call if tree.target -- Method call
target_lua = compile tree.target target_lua = compile tree.target
target_text = target_lua\text! target_text = target_lua\text!
if target_text\match("^%(.*%)$") or target_text\match("^[_a-zA-Z][_a-zA-Z0-9.]*$") -- 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\append target_lua, ":"
else else
lua\append "(", target_lua, "):" lua\append "(", target_lua, "):"
@ -163,7 +169,9 @@ compile = setmetatable({
args = {} args = {}
for i, tok in ipairs tree for i, tok in ipairs tree
if type(tok) == "string" then continue if type(tok) == "string" then continue
arg_lua = compile(tok, true) arg_lua = compile(tok)
if tok.type == "Block"
arg_lua = LuaCode\from(tok.source, "(function()\n ", arg_lua, "\nend)()")
insert args, arg_lua insert args, arg_lua
lua\concat_append args, ", " lua\concat_append args, ", "
lua\append ")" lua\append ")"
@ -196,17 +204,11 @@ compile = setmetatable({
return lua return lua
when "Block" when "Block"
if not force_value lua = LuaCode\from(tree.source)
lua = LuaCode\from(tree.source) for i, line in ipairs tree
lua\concat_append([compile(line) for line in *tree], "\n") if i > 1 then lua\append "\n"
return lua lua\append compile(line)
else return lua
lua = LuaCode\from(tree.source)
lua\append("((function()")
for i, line in ipairs(tree)
lua\append "\n ", compile(line)
lua\append("\nend)())")
return lua
when "Text" when "Text"
lua = LuaCode\from(tree.source) lua = LuaCode\from(tree.source)
@ -234,7 +236,7 @@ compile = setmetatable({
return lua return lua
when "List", "Dict" when "List", "Dict"
lua = LuaCode\from tree.source, "#{tree.type}{" lua = LuaCode\from tree.source
i = 1 i = 1
sep = '' sep = ''
while i <= #tree while i <= #tree
@ -250,7 +252,12 @@ compile = setmetatable({
lua\append item_lua lua\append item_lua
sep = ', ' sep = ', '
i += 1 i += 1
lua\append "}"
if lua\is_multiline!
lua = LuaCode\from tree.source, "#{tree.type}{\n ", lua, "\n}"
else
lua = LuaCode\from tree.source, "#{tree.type}{", lua, "}"
-- List/dict comprehenstion -- List/dict comprehenstion
if i <= #tree if i <= #tree
lua = LuaCode\from tree.source, "(function()\n local comprehension = ", lua lua = LuaCode\from tree.source, "(function()\n local comprehension = ", lua
@ -269,6 +276,7 @@ compile = setmetatable({
lua\append "comprehension[#comprehension+1] = ", compile(tree[i]) lua\append "comprehension[#comprehension+1] = ", compile(tree[i])
i += 1 i += 1
lua\append "\n return comprehension\nend)()" lua\append "\n return comprehension\nend)()"
return lua return lua
when "DictEntry" when "DictEntry"
@ -329,4 +337,4 @@ compile = setmetatable({
}) })
return compile return {:compile, :compile_error}

10
nomsu_decompiler.lua
View File

@ -88,6 +88,9 @@ tree_to_inline_nomsu = function(tree)
nomsu:append(arg_nomsu) nomsu:append(arg_nomsu)
end end
end end
if #tree == 1 and type(tree[1]) ~= "string" then
nomsu:append("()")
end
return nomsu return nomsu
elseif "EscapedNomsu" == _exp_0 then elseif "EscapedNomsu" == _exp_0 then
local inner_nomsu = tree_to_inline_nomsu(tree[1]) local inner_nomsu = tree_to_inline_nomsu(tree[1])
@ -326,6 +329,13 @@ tree_to_nomsu = function(tree)
end end
end end
nomsu:append(next_space, words) nomsu:append(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, "()")
end end
return nomsu return nomsu
elseif "EscapedNomsu" == _exp_0 then elseif "EscapedNomsu" == _exp_0 then

7
nomsu_decompiler.moon
View File

@ -58,6 +58,8 @@ tree_to_inline_nomsu = (tree)->
if bit.type == "Action" if bit.type == "Action"
arg_nomsu\parenthesize! arg_nomsu\parenthesize!
nomsu\append arg_nomsu nomsu\append arg_nomsu
if #tree == 1 and type(tree[1]) != "string"
nomsu\append "()"
return nomsu return nomsu
when "EscapedNomsu" when "EscapedNomsu"
@ -251,6 +253,11 @@ tree_to_nomsu = (tree)->
elseif word_buffer[1] == "'" elseif word_buffer[1] == "'"
next_space = "" next_space = ""
nomsu\append next_space, words nomsu\append next_space, words
next_space = " "
if #tree == 1 and type(tree[1]) != "string"
if next_space == " " then next_space = ""
nomsu\append next_space, "()"
return nomsu return nomsu

54
nomsu_environment.lua
View File

@ -51,7 +51,11 @@ do
local _obj_0 = require("nomsu_decompiler") local _obj_0 = require("nomsu_decompiler")
tree_to_nomsu, tree_to_inline_nomsu = _obj_0.tree_to_nomsu, _obj_0.tree_to_inline_nomsu tree_to_nomsu, tree_to_inline_nomsu = _obj_0.tree_to_nomsu, _obj_0.tree_to_inline_nomsu
end end
local compile = require('nomsu_compiler') local compile, compile_error
do
local _obj_0 = require('nomsu_compiler')
compile, compile_error = _obj_0.compile, _obj_0.compile_error
end
local _currently_running_files = List({ }) local _currently_running_files = List({ })
local nomsu_environment = Importer({ local nomsu_environment = Importer({
NOMSU_COMPILER_VERSION = 12, NOMSU_COMPILER_VERSION = 12,
@ -59,10 +63,14 @@ local nomsu_environment = Importer({
next = next, next = next,
unpack = unpack or table.unpack, unpack = unpack or table.unpack,
setmetatable = setmetatable, setmetatable = setmetatable,
coroutine = coroutine,
rawequal = rawequal, rawequal = rawequal,
getmetatable = getmetatable, getmetatable = getmetatable,
pcall = pcall, pcall = pcall,
yield = coroutine.yield,
resume = coroutine.resume,
coroutine_status_of = coroutine.status,
coroutine_wrap = coroutine.wrap,
coroutine_from = coroutine.create,
error = error, error = error,
package = package, package = package,
os = os, os = os,
@ -115,6 +123,7 @@ local nomsu_environment = Importer({
_1_as_inline_nomsu = tree_to_inline_nomsu, _1_as_inline_nomsu = tree_to_inline_nomsu,
compile = compile, compile = compile,
_1_as_lua = compile, _1_as_lua = compile,
compile_error_at = compile_error,
_1_forked = _1_forked, _1_forked = _1_forked,
import_to_1_from = import_to_1_from, import_to_1_from = import_to_1_from,
_1_parsed = function(nomsu_code) _1_parsed = function(nomsu_code)
@ -131,10 +140,11 @@ local nomsu_environment = Importer({
if tree.shebang then if tree.shebang then
tree.version = tree.shebang:match("nomsu %-V[ ]*([%d.]*)") tree.version = tree.shebang:match("nomsu %-V[ ]*([%d.]*)")
end end
local errs = { }
local find_errors local find_errors
find_errors = function(t) find_errors = function(t)
if t.type == "Error" then if t.type == "Error" then
return coroutine.yield(t) errs[#errs + 1] = t
else else
for k, v in pairs(t) do for k, v in pairs(t) do
local _continue_0 = false local _continue_0 = false
@ -152,18 +162,7 @@ local nomsu_environment = Importer({
end end
end end
end end
local errs find_errors(tree)
do
local _accum_0 = { }
local _len_0 = 1
for err in coroutine.wrap(function()
return find_errors(tree)
end) do
_accum_0[_len_0] = err
_len_0 = _len_0 + 1
end
errs = _accum_0
end
local num_errs = #errs local num_errs = #errs
if num_errs > 0 then if num_errs > 0 then
local err_strings local err_strings
@ -278,12 +277,15 @@ local nomsu_environment = Importer({
end end
end, end,
FILE_CACHE = { }, FILE_CACHE = { },
run_file_1_in = function(path, environment, optimization) run_file_1_in = function(path, environment, optimization, prefix)
if prefix == nil then
prefix = nil
end
if not optimization then if not optimization then
optimization = environment.OPTIMIZATION optimization = environment.OPTIMIZATION
end end
if environment.FILE_CACHE[path] then if environment.FILE_CACHE[path] then
import_to_1_from(environment, environment.FILE_CACHE[path]) import_to_1_from(environment, environment.FILE_CACHE[path], prefix)
return return
end end
if _currently_running_files:has(path) then if _currently_running_files:has(path) then
@ -294,7 +296,6 @@ local nomsu_environment = Importer({
end end
_currently_running_files:add(path) _currently_running_files:add(path)
local mod = _1_forked(environment) local mod = _1_forked(environment)
mod._ENV = mod
for _, filename in Files.walk(path) do for _, filename in Files.walk(path) do
local _continue_0 = false local _continue_0 = false
repeat repeat
@ -318,24 +319,9 @@ local nomsu_environment = Importer({
break break
end end
end end
import_to_1_from(environment, mod) import_to_1_from(environment, mod, prefix)
environment.FILE_CACHE[path] = mod environment.FILE_CACHE[path] = mod
return _currently_running_files:remove() return _currently_running_files:remove()
end,
compile_error_at = function(tree, err_msg, hint)
if hint == nil then
hint = nil
end
local err_str = pretty_error({
title = "Compile error",
error = err_msg,
hint = hint,
source = tree:get_source_file(),
start = tree.source.start,
stop = tree.source.stop,
filename = tree.source.filename
})
return error(err_str, 0)
end end
}) })
nomsu_environment._ENV = nomsu_environment nomsu_environment._ENV = nomsu_environment

32
nomsu_environment.moon
View File

@ -31,12 +31,14 @@ for version=1,999
Parsers[version] = make_parser(peg_contents, make_tree) Parsers[version] = make_parser(peg_contents, make_tree)
{:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler" {:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler"
compile = require('nomsu_compiler') {:compile, :compile_error} = require('nomsu_compiler')
_currently_running_files = List{} -- Used to check for circular imports in run_file_1_in _currently_running_files = List{} -- Used to check for circular imports in run_file_1_in
nomsu_environment = Importer{ nomsu_environment = Importer{
NOMSU_COMPILER_VERSION: 12, NOMSU_SYNTAX_VERSION: max_parser_version NOMSU_COMPILER_VERSION: 12, NOMSU_SYNTAX_VERSION: max_parser_version
-- Lua stuff: -- Lua stuff:
:next, unpack: unpack or table.unpack, :setmetatable, :coroutine, :rawequal, :getmetatable, :pcall, :next, unpack: unpack or table.unpack, :setmetatable, :rawequal, :getmetatable, :pcall,
yield:coroutine.yield, resume:coroutine.resume, coroutine_status_of:coroutine.status,
coroutine_wrap:coroutine.wrap, coroutine_from: coroutine.create,
:error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module, :error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module,
say:print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen, say:print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen,
:table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load, :table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load,
@ -53,9 +55,9 @@ nomsu_environment = Importer{
SOURCE_MAP: Importer({}) SOURCE_MAP: Importer({})
-- Nomsu functions: -- Nomsu functions:
_1_as_nomsu:tree_to_nomsu, _1_as_inline_nomsu:tree_to_inline_nomsu _1_as_nomsu:tree_to_nomsu, _1_as_inline_nomsu:tree_to_inline_nomsu,
compile: compile, _1_as_lua: compile, compile: compile, _1_as_lua: compile, compile_error_at:compile_error,
:_1_forked, :import_to_1_from :_1_forked, :import_to_1_from,
_1_parsed: (nomsu_code)-> _1_parsed: (nomsu_code)->
if type(nomsu_code) == 'string' if type(nomsu_code) == 'string'
@ -69,14 +71,15 @@ nomsu_environment = Importer{
tree = parse(nomsu_code, source.filename) tree = parse(nomsu_code, source.filename)
if tree.shebang if tree.shebang
tree.version = tree.shebang\match("nomsu %-V[ ]*([%d.]*)") tree.version = tree.shebang\match("nomsu %-V[ ]*([%d.]*)")
errs = {}
find_errors = (t)-> find_errors = (t)->
if t.type == "Error" if t.type == "Error"
coroutine.yield t errs[#errs+1] = t
else else
for k,v in pairs(t) for k,v in pairs(t)
continue unless SyntaxTree\is_instance(v) continue unless SyntaxTree\is_instance(v)
find_errors(v) find_errors(v)
errs = [err for err in coroutine.wrap(-> find_errors(tree))] find_errors(tree)
num_errs = #errs num_errs = #errs
if num_errs > 0 if num_errs > 0
err_strings = [pretty_error{ err_strings = [pretty_error{
@ -152,11 +155,11 @@ nomsu_environment = Importer{
error("Attempt to run unknown thing: "..tostring(to_run)) error("Attempt to run unknown thing: "..tostring(to_run))
FILE_CACHE: {} FILE_CACHE: {}
run_file_1_in: (path, environment, optimization)-> run_file_1_in: (path, environment, optimization, prefix=nil)->
if not optimization if not optimization
optimization = environment.OPTIMIZATION optimization = environment.OPTIMIZATION
if environment.FILE_CACHE[path] if environment.FILE_CACHE[path]
import_to_1_from(environment, environment.FILE_CACHE[path]) import_to_1_from(environment, environment.FILE_CACHE[path], prefix)
return return
if _currently_running_files\has(path) if _currently_running_files\has(path)
i = _currently_running_files\index_of(path) i = _currently_running_files\index_of(path)
@ -165,7 +168,6 @@ nomsu_environment = Importer{
error("Circular import detected:\n "..circle\joined_with("\n..imports ")) error("Circular import detected:\n "..circle\joined_with("\n..imports "))
_currently_running_files\add path _currently_running_files\add path
mod = _1_forked(environment) mod = _1_forked(environment)
mod._ENV = mod
for _,filename in Files.walk(path) for _,filename in Files.walk(path)
continue unless filename == "stdin" or filename\match("%.nom$") continue unless filename == "stdin" or filename\match("%.nom$")
lua_filename = filename\gsub("%.nom$", ".lua") lua_filename = filename\gsub("%.nom$", ".lua")
@ -177,17 +179,9 @@ nomsu_environment = Importer{
file = Files.read(filename) file = Files.read(filename)
NomsuCode\from(Source(filename, 1, #file), file) NomsuCode\from(Source(filename, 1, #file), file)
environment.run_1_in(code, mod) environment.run_1_in(code, mod)
import_to_1_from(environment, mod) import_to_1_from(environment, mod, prefix)
environment.FILE_CACHE[path] = mod environment.FILE_CACHE[path] = mod
_currently_running_files\remove! _currently_running_files\remove!
compile_error_at: (tree, err_msg, hint=nil)->
err_str = pretty_error{
title: "Compile error"
error:err_msg, hint:hint, source:tree\get_source_file!
start:tree.source.start, stop:tree.source.stop, filename:tree.source.filename
}
error(err_str, 0)
} }
nomsu_environment._ENV = nomsu_environment nomsu_environment._ENV = nomsu_environment

13
syntax_tree.lua
View File

@ -147,16 +147,16 @@ do
end, end,
get_args = function(self) get_args = function(self)
assert(self.type == "Action", "Only actions have arguments") assert(self.type == "Action", "Only actions have arguments")
local _accum_0 = { } local args = {
local _len_0 = 1 self.target
}
for _index_0 = 1, #self do for _index_0 = 1, #self do
local tok = self[_index_0] local tok = self[_index_0]
if type(tok) ~= 'string' then if type(tok) ~= 'string' then
_accum_0[_len_0] = tok args[#args + 1] = tok
_len_0 = _len_0 + 1
end end
end end
return _accum_0 return args
end, end,
get_stub = function(self) get_stub = function(self)
local stub_bits = { } local stub_bits = { }
@ -198,7 +198,8 @@ do
local Files = require('files') local Files = require('files')
local f = Files.read(s.filename) local f = Files.read(s.filename)
return f return f
end end,
__mode = "k"
}) })
self.is_instance = function(self, t) self.is_instance = function(self, t)
return type(t) == 'table' and getmetatable(t) == self.__base return type(t) == 'table' and getmetatable(t) == self.__base

17
syntax_tree.moon
View File

@ -39,11 +39,13 @@ class SyntaxTree
table.insert(bits, "[ #{as_lua(k)}]=#{as_lua(v)}") table.insert(bits, "[ #{as_lua(k)}]=#{as_lua(v)}")
return "SyntaxTree{#{table.concat(bits, ", ")}}" return "SyntaxTree{#{table.concat(bits, ", ")}}"
@source_code_for_tree: setmetatable({}, {__index:(t)=> @source_code_for_tree: setmetatable({}, {
s = t.source __index:(t)=>
Files = require 'files' s = t.source
f = Files.read(s.filename) Files = require 'files'
return f f = Files.read(s.filename)
return f
__mode: "k"
}) })
get_source_file: => @@source_code_for_tree[@] get_source_file: => @@source_code_for_tree[@]
get_source_code: => @@source_code_for_tree[@]\sub(@source.start, @source.stop) get_source_code: => @@source_code_for_tree[@]\sub(@source.start, @source.stop)
@ -73,7 +75,10 @@ class SyntaxTree
get_args: => get_args: =>
assert(@type == "Action", "Only actions have arguments") assert(@type == "Action", "Only actions have arguments")
return [tok for tok in *@ when type(tok) != 'string'] args = {@target}
for tok in *@
if type(tok) != 'string' then args[#args+1] = tok
return args
get_stub: => get_stub: =>
stub_bits = {} stub_bits = {}

5
tools/autoformat.nom
View File

@ -16,8 +16,9 @@ if (%args.1 is "-i"):
%args::remove index 1 %args::remove index 1
for %path in %args: for %path in %args:
if (%path == "-"): %path = "stdin"
for file %filename in %path: for file %filename in %path:
unless (%filename::matches "%.nom$"): do next %filename unless ((%filename::matches "%.nom$") or (%filename == "stdin")): do next %filename
%contents = (read file %filename) %contents = (read file %filename)
%code = (NomsuCode from (Source %filename 1 (size of %contents)) %contents) %code = (NomsuCode from (Source %filename 1 (size of %contents)) %contents)
%tree = (%code parsed) %tree = (%code parsed)
@ -25,4 +26,4 @@ for %path in %args:
if %inplace: if %inplace:
write %formatted to file %filename write %formatted to file %filename
..else: ..else:
say %formatted say %formatted inline

2
tools/find_action.nom
View File

@ -11,7 +11,7 @@ use "lib/consolecolor.nom"
%stub = (command line args).1 %stub = (command line args).1
say "Looking for stub: \%stub..." say "Looking for stub: \%stub..."
%files = ((command line args).% for % in 2 to (size of (command line args))) %files = [: for % in 2 to (size of (command line args)): add (command line args).%]
for %path in %files: for %path in %files:
for file %filename in %path: for file %filename in %path:
unless (%filename::matches "%.nom$"): do next %filename unless (%filename::matches "%.nom$"): do next %filename