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

Lots of cleanups, including expanded use of (... compiles to "text

Browse Source 
literal") shorthand, deprecating Lua value, and more use of Lua "..."
with text interpolations.
This commit is contained in:
Bruce Hill 2018-11-09 14:36:15 -08:00
parent ba96cdfa07
commit 7d2b7199d8
22 changed files with 280 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
code_obj.lua
View File

@ -499,6 +499,7 @@ do
NomsuCode = _class_0
end
Code.__base.add_1_joined_with = assert(Code.__base.concat_append)
Code.__base.add = assert(Code.__base.append)
return {
Code = Code,
NomsuCode = NomsuCode,

1
code_obj.moon
View File

@ -255,5 +255,6 @@ class NomsuCode extends Code
__len: Code.__len
Code.__base.add_1_joined_with = assert Code.__base.concat_append
Code.__base.add = assert Code.__base.append
return {:Code, :NomsuCode, :LuaCode, :Source}

13
core/collections.nom
View File

@ -151,16 +151,15 @@ test:
%t = {}
set %t 's metatable to {__tostring:[%] -> "XXX"}
assume ("\%t" == "XXX")
(set %dict 's metatable to %metatable) compiles to (..)
Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
(set %dict 's metatable to %metatable) compiles to "\
..setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
[% 's metatable, % 'metatable] all compile to (..)
Lua value "getmetatable(\(% as lua expr))"
[% 's metatable, % 'metatable] all compile to "\
..getmetatable(\(% as lua expr))"
test:
assume (({} with fallback % -> (% + 1)).10 == 11)
(%dict with fallback %key -> %value) compiles to (..)
Lua value "\
(%dict with fallback %key -> %value) compiles to "\
..(function(d)
local mt = {}
for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
@ -182,7 +181,7 @@ test:
%keys = {1:999, 2:0, 3:50}
sort %x by % = %keys.%
assume (%x == [2, 3, 1])
(sort %items) compiles to (Lua "table.sort(\(%items as lua expr));")
(sort %items) compiles to "table.sort(\(%items as lua expr));"
[..]
sort %items by %item = %key_expr, sort %items by %item -> %key_expr
..all parse as (..)

163
core/control_flow.nom
View File

@ -12,19 +12,16 @@ use "core/errors.nom"
# No-Op
test: do nothing
(do nothing) compiles to (Lua "")
(do nothing) compiles to ""
# Conditionals
test:
if (no):
barf "conditional fail"
(if %condition %if_body) compiles to:
%lua = (Lua "if ")
%lua::append (%condition as lua expr)
%lua::append " then\n "
%lua::append (%if_body as lua statements)
%lua::append "\nend"
return %lua
(if %condition %if_body) compiles to "\
..if \(%condition as lua expr) then
\(%if_body as lua statements)
end"
test:
unless (yes):
@ -32,15 +29,12 @@ test:
(unless %condition %unless_body) parses as (if (not %condition) %unless_body)
[..]
if %condition %if_body else %else_body, unless %condition %else_body else %if_body
..all compile to:
%lua = (Lua "if ")
%lua::append (%condition as lua expr)
%lua::append " then\n "
%lua::append (%if_body as lua statements)
%lua::append "\nelse\n "
%lua::append (%else_body as lua statements)
%lua::append "\nend"
return %lua
..all compile to "\
..if \(%condition as lua expr) then
\(%if_body as lua statements)
else
\(%else_body as lua statements)
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -60,7 +54,7 @@ test:
equivalent of a conditional expression: (cond and if_true or if_false)
if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type):
return (..)
Lua value "\
Lua "\
..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
%when_false_expr as lua expr
..)"
@ -69,7 +63,7 @@ test:
doesn't have a proper ternary operator!)
To see why this is necessary consider: (random()<.5 and false or 99)
return (..)
Lua value "\
Lua "\
..((function()
if \(%condition as lua expr) then
return \(%when_true_expr as lua expr)
@ -91,14 +85,12 @@ test:
%i -= 1
unless (%i == 0): go to (Loop)
assume (%i == 0)
[=== %label ===, --- %label ---, *** %label ***] all compile to (..)
Lua "\
[=== %label ===, --- %label ---, *** %label ***] all compile to "\
..::label_\(..)
(%label.stub if (%label.type == "Action") else %label) as lua identifier
..::"
(go to %label) compiles to (..)
Lua "\
(go to %label) compiles to "\
..goto label_\(..)
(%label.stub if (%label.type == "Action") else %label) as lua identifier
.."
@ -114,10 +106,10 @@ test:
return (..)
Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
..else: return (Lua "goto continue")
[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to (..)
Lua "::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
[===next %var ===, ---next %var ---, ***next %var ***] all compile to (..)
Lua "::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\
..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
[===next %var ===, ---next %var ---, ***next %var ***] all compile to "\
..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
# While loops
test:
@ -139,8 +131,8 @@ test:
barf "Failed to 'do next repeat'"
assume (%x == 30)
(do next repeat) compiles to (Lua "goto continue_repeat")
(stop repeating) compiles to (Lua "goto stop_repeat")
(do next repeat) compiles to "goto continue_repeat"
(stop repeating) compiles to "goto stop_repeat"
(repeat while %condition %body) compiles to:
%lua = (..)
Lua "\
@ -155,8 +147,7 @@ test:
if (%body has subtree \(stop repeating)):
%inner_lua = %lua
%lua = (Lua "do -- scope of 'stop repeating' label\n ")
%lua::append %inner_lua
%lua::append "\
%lua::append %inner_lua "\
..
::stop_repeat::
end -- end of 'stop repeating' label scope"
@ -183,8 +174,7 @@ test:
if (%body has subtree \(stop repeating)):
%inner_lua = %lua
%lua = (Lua "do -- scope of 'stop repeating' label\n ")
%lua::append %inner_lua
%lua::append "\
%lua::append %inner_lua "\
..
::stop_repeat::
end -- end of 'stop repeating' label scope"
@ -226,20 +216,17 @@ test:
%step as lua expr
.. do"
%lua::append "\n "
%lua::append (%body as lua statements)
%lua::append "\n " (%body as lua statements)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n "
%lua::append (what (===next %var ===) compiles to)
%lua::append "\n " (what (===next %var ===) compiles to)
%lua::append "\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
%lua::append "\n "
%lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop"
@ -273,15 +260,13 @@ test:
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n "
%lua::append (what (===next %var ===) compiles to)
%lua::append "\n " (what (===next %var ===) compiles to)
%lua::append "\nend --foreach-loop"
if (%body has subtree \(stop %var)):
%inner_lua = %lua
%lua = (Lua "do -- scope for stopping for-loop\n ")
%lua::append %inner_lua
%lua::append "\n "
%lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop"
@ -296,15 +281,13 @@ test:
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):
%lua::append "\n "
%lua::append (what (===next %var ===) compiles to)
%lua::append "\n " (what (===next %var ===) compiles to)
%lua::append "\nend --foreach-loop"
if (%body has subtree \(stop %var)):
%inner_lua = %lua
%lua = (Lua "do -- scope for stopping for-loop\n ")
%lua::append %inner_lua
%lua::append "\n "
%lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop"
@ -335,34 +318,27 @@ test:
%iterable as lua expr
..) do"
%lua::append "\n "
%lua::append (%body as lua statements)
%lua::append "\n " (%body as lua statements)
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %key)):
%lua::append "\n "
%lua::append (what (===next %key ===) compiles to)
%lua::append "\n " (what (===next %key ===) compiles to)
if (%body has subtree \(do next %value)):
%lua::append "\n "
%lua::append (what (===next %value ===) compiles to)
%lua::append "\n " (what (===next %value ===) compiles to)
%lua::append "\nend --foreach-loop"
%stop_labels = (Lua "")
if (%body has subtree \(stop %key)):
%stop_labels::append "\n"
%stop_labels::append (what (===stop %key ===) compiles to)
%stop_labels::append "\n" (what (===stop %key ===) compiles to)
if (%body has subtree \(stop %value)):
%stop_labels::append "\n"
%stop_labels::append (what (===stop %value ===) compiles to)
%stop_labels::append "\n" (what (===stop %value ===) compiles to)
if ((size of "\%stop_labels") > 0):
%inner_lua = %lua
%lua = (Lua "do -- scope for stopping for % = % loop\n ")
%lua::append %inner_lua
%lua::append %stop_labels
%lua::append "\nend"
%lua::append %inner_lua %stop_labels "\nend"
return %lua
@ -411,19 +387,16 @@ test:
..need a conditional block around it. Otherwise, make sure the 'else' \
..block comes last."
%code::append "\nelse\n "
%code::append (%action as lua statements)
%code::append "\nelse\n " (%action as lua statements)
%else_allowed = (no)
..else:
%code::append %clause
%code::append " "
%code::append %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 "
%code::append (%action as lua statements)
%code::append " then\n " (%action as lua statements)
%clause = "\nelseif"
if ((size of "\%code") == 0):
@ -472,42 +445,34 @@ test:
..need a conditional block around it. Otherwise, make sure the 'else' \
..block comes last."
%code::append "\nelse\n "
%code::append (%action as lua statements)
%code::append "\nelse\n " (%action as lua statements)
%else_allowed = (no)
..else:
%code::append %clause
%code::append " "
%code::append %clause " "
for %i in 1 to ((size of %line) - 1):
if (%i > 1):
%code::append " or "
%code::append "\(mangle "branch value") == "
%code::append (%line.%i as lua expr)
%code::append "\(mangle "branch value") == " (%line.%i as lua expr)
%code::append " then\n "
%code::append (%action as lua statements)
%code::append " then\n " (%action as lua statements)
%clause = "\nelseif"
if ((size of "\%code") == 0):
compile error at %body "'if' block has an empty body."
..hint "This means nothing would happen, so the 'if' block should be deleted."
%code::append "\nend --when"
%lua = (..)
return (..)
Lua "\
..do --if % is...
local \(mangle "branch value") = "
%lua::append (%branch_value as lua expr)
%lua::append "\n "
%lua::append %code
%lua::append "\nend --if % is..."
return %lua
local \(mangle "branch value") = \(%branch_value as lua expr)
\%code
end -- if % is..."
# Do/finally
(do %action) compiles to:
%lua = (Lua "do\n ")
%lua::append (%action as lua statements)
%lua::append "\nend -- do"
return %lua
(do %action) compiles to "\
..do
\(%action as lua statements)
end -- do"
test:
%d = {}
@ -519,29 +484,24 @@ test:
assume (%d.x == "good")
(do %action then always %final_action) compiles to:
define mangler
%lua = (..)
return (..)
Lua "\
..do
local \(mangle "fell_through") = false
local \(mangle "ok"), \(mangle "ret") = pcall(function()"
%lua::append "\n "
%lua::append (%action as lua statements)
%lua::append "\
.. \(mangle "fell_through") = true
end)"
%lua::append "\n "
%lua::append (%final_action as lua statements)
%lua::append "\
.. if not \(mangle "ok") then error(ret, 0) end
local \(mangle "ok"), \(mangle "ret") = pcall(function()
\(%action as lua statements)
\(mangle "fell_through") = true
end)
\(%final_action as lua statements)
if not \(mangle "ok") then error(ret, 0) end
if not \(mangle "fell_through") then return ret end
end"
return %lua
test:
assume ((result of (: return 99)) == 99)
# Inline thunk:
(result of %body) compiles to (Lua value "\(what ([] -> %body) compiles to)()")
(result of %body) compiles to "\(what ([] -> %body) compiles to)()"
test:
%t = [1, [2, [[3], 4], 5, [[[6]]]]]
@ -564,9 +524,8 @@ test:
..do
local \(mangle "stack \(%var.1)") = List{\(%structure as lua expr)}
while #\(mangle "stack \(%var.1)") > 0 do
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)"
%lua::append "\n "
%lua::append (%body as lua statements)
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
if (%body has subtree \(do next %var)):

11
core/coroutines.nom
View File

@ -16,16 +16,13 @@ test:
for % in coroutine %co: %nums::add %
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
[coroutine %body, generator %body] all compile to (..)
Lua value "\
[coroutine %body, generator %body] all compile to "\
..(function()
\(%body as lua statements)
end)"
(->) compiles to (Lua value "coroutine.yield(true)")
(-> %) compiles to (Lua value "coroutine.yield(true, \(% as lua expr))")
(for % in coroutine %co %body) compiles to (..)
Lua "\
..for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
(-> %) compiles to "coroutine.yield(true, \((% as lua expr) if % else "nil"))"
(for % in coroutine %co %body) compiles to "\
..for _junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
\(%body as lua statements)
end"

16
core/errors.nom
View File

@ -6,11 +6,11 @@ use "core/metaprogramming.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(barf %msg) compiles to (Lua "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);")
(compile error at %tree %msg) compiles to (..)
Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
(compile error at %tree %msg hint %hint) compiles to (..)
Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr), \(%hint as lua expr))"
(barf %msg) compiles to "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);"
(compile error at %tree %msg) compiles to "\
..nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
(compile error at %tree %msg hint %hint) compiles to "\
..nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr), \(%hint as lua expr))"
(assume %condition) compiles to:
lua> "\
@ -36,8 +36,7 @@ use "core/metaprogramming.nom"
end
end"
(assume %condition or barf %message) compiles to (..)
Lua "\
(assume %condition or barf %message) compiles to "\
..if not \(%condition as lua expr) then
error(\(%message as lua expr), 0)
end"
@ -59,8 +58,7 @@ test:
[..]
try %action and if it succeeds %success or if it barfs %msg %fallback
try %action and if it barfs %msg %fallback or if it succeeds %success
..all compile to (..)
Lua "\
..all compile to "\
..do
local fell_through = false
local err, erred = nil, false

4
core/io.nom
View File

@ -17,9 +17,9 @@ use "core/metaprogramming.nom"
(ask %prompt) compiles to:
lua> "\
..if \%prompt.type == "Text" then
return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
return LuaCode(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
else
return LuaCode.Value(tree.source, "(io.write(tostring(", \(..)
return LuaCode(tree.source, "(io.write(tostring(", \(..)
%prompt as lua expr
.., ")) and io.read())");
end"

86
core/math.nom
View File

@ -16,18 +16,18 @@ test:
..math constants failed"
%nan = (NaN)
assume (%nan != %nan) or barf "NaN failed"
[infinity, inf] all compile to (Lua value "math.huge")
[not a number, NaN, nan] all compile to (Lua value "(0/0)")
[pi, Pi, PI] all compile to (Lua value "math.pi")
[tau, Tau, TAU] all compile to (Lua value "(2*math.pi)")
(golden ratio) compiles to (Lua value "((1+math.sqrt(5))/2)")
(e) compiles to (Lua value "math.exp(1)")
[infinity, inf] all compile to "math.huge"
[not a number, NaN, nan] all compile to "(0/0)"
[pi, Pi, PI] all compile to "math.pi"
[tau, Tau, TAU] all compile to "(2*math.pi)"
(golden ratio) compiles to "((1+math.sqrt(5))/2)"
(e) compiles to "math.exp(1)"
# Functions:
test:
assume (("5" as a number) == 5)
[% as a number, % as number] all compile to (..)
Lua value "tonumber(\(% as lua expr))"
((% as a number)'s meaning) = ((tonumber %)'s meaning)
((% as number)'s meaning) = ((tonumber %)'s meaning)
test:
assume (..)
@ -37,40 +37,40 @@ test:
hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
..or barf "math functions failed"
[absolute value %, | % |, abs %] all compile to (..)
Lua value "math.abs(\(% as lua expr))"
"math.abs(\(% as lua expr))"
[square root %, square root of %, √ %, sqrt %] all compile to (..)
Lua value "math.sqrt(\(% as lua expr))"
"math.sqrt(\(% as lua expr))"
[sine %, sin %] all compile to (Lua value "math.sin(\(% as lua expr))")
[cosine %, cos %] all compile to (Lua value "math.cos(\(% as lua expr))")
[tangent %, tan %] all compile to (Lua value "math.tan(\(% as lua expr))")
[arc sine %, asin %] all compile to (Lua value "math.asin(\(% as lua expr))")
[arc cosine %, acos %] all compile to (Lua value "math.acos(\(% as lua expr))")
[arc tangent %, atan %] all compile to (Lua value "math.atan(\(% as lua expr))")
[sine %, sin %] all compile to "math.sin(\(% as lua expr))"
[cosine %, cos %] all compile to "math.cos(\(% as lua expr))"
[tangent %, tan %] all compile to "math.tan(\(% as lua expr))"
[arc sine %, asin %] all compile to "math.asin(\(% as lua expr))"
[arc cosine %, acos %] all compile to "math.acos(\(% as lua expr))"
[arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))"
[arc tangent %y / %x, atan2 %y %x] all compile to (..)
Lua value "math.atan2(\(%y as lua expr), \(%x as lua expr))"
"math.atan2(\(%y as lua expr), \(%x as lua expr))"
[hyperbolic sine %, sinh %] all compile to (..)
Lua value "math.sinh(\(% as lua expr))"
"math.sinh(\(% as lua expr))"
[hyperbolic cosine %, cosh %] all compile to (..)
Lua value "math.cosh(\(% as lua expr))"
"math.cosh(\(% as lua expr))"
[hyperbolic tangent %, tanh %] all compile to (..)
Lua value "math.tanh(\(% as lua expr))"
"math.tanh(\(% as lua expr))"
[e^ %, exp %] all compile to (Lua value "math.exp(\(% as lua expr))")
[e^ %, exp %] all compile to "math.exp(\(% as lua expr))"
[natural log %, ln %, log %] all compile to (..)
Lua value "math.log(\(% as lua expr))"
"math.log(\(% as lua expr))"
[log % base %base, log base %base of %] all compile to (..)
Lua value "math.log(\(% as lua expr), \(%base as lua expr))"
"math.log(\(% as lua expr), \(%base as lua expr))"
(floor %) compiles to (Lua value "math.floor(\(% as lua expr))")
[ceiling %, ceil %] all compile to (Lua value "math.ceil(\(% as lua expr))")
(floor %) compiles to "math.floor(\(% as lua expr))"
[ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))"
[round %, % rounded] all compile to (..)
Lua value "math.floor(\(% as lua expr) + .5)"
"math.floor(\(% as lua expr) + .5)"
test:
assume ((463 to the nearest 100) == 500) or barf "rounding failed"
@ -86,8 +86,11 @@ externally [all of %items, all %items] all mean:
[all of %items, all %items] all compile to:
unless (%items.type is "List"):
return %tree
%clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " and "))")
if ((size of %items) == 0): return (Lua "true")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " and "
%lua::append ")"
return %lua
[not all of %items, not all %items] all parse as (not (all of %items))
externally [any of %items, any %items] all mean:
@ -97,8 +100,11 @@ externally [any of %items, any %items] all mean:
[any of %items, any %items] all compile to:
unless (%items.type is "List"):
return %tree
%clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " or "))")
if ((size of %items) == 0): return (Lua "false")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " or "
%lua::append ")"
return %lua
[none of %items, none %items] all parse as (not (any of %items))
# Sum/product
@ -109,8 +115,11 @@ externally [sum of %items, sum %items] all mean:
[sum of %items, sum %items] all compile to:
unless (%items.type is "List"):
return %tree
%clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " + "))")
if ((size of %items) == 0): return (Lua "0")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " + "
%lua::append ")"
return %lua
externally [product of %items, product %items] all mean:
%prod = 1
@ -119,8 +128,11 @@ externally [product of %items, product %items] all mean:
[product of %items, product %items] all compile to:
unless (%items.type is "List"):
return %tree
%clauses = (((% as lua expr)::text) for % in %items)
return (Lua value "(\(%clauses::joined with " * "))")
if ((size of %items) == 0): return (Lua "1")
%lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " * "
%lua::append ")"
return %lua
externally [avg of %items, average of %items] all mean (..)
(sum of %items) / (size of %items)
@ -212,12 +224,12 @@ externally (seed random with %) means:
for i=1,20 do math.random(); end"
(seed random) parses as (seed random with (=lua "os.time()"))
[random number, random, rand] all compile to (Lua value "math.random()")
[random number, random, rand] all compile to "math.random()"
[random int %n, random integer %n, randint %n] all compile to (..)
Lua value "math.random(\(%n as lua expr))"
"math.random(\(%n as lua expr))"
[random from %low to %high, random number from %low to %high, rand %low %high] all \
..compile to (Lua value "math.random(\(%low as lua expr), \(%high as lua expr))")
..compile to "math.random(\(%low as lua expr), \(%high as lua expr))"
externally [..]
random choice from %elements, random choice %elements, random %elements

5
core/metaprogramming.nom
View File

@ -71,9 +71,8 @@ lua> "\
if \%body.type == "Text" then
\%body = SyntaxTree{source=\%body.source, type="Action", "Lua", \%body}
end
local lua = LuaCode(tree.source, "compile.action[", \%action.stub:as_lua(),
return LuaCode(tree.source, "compile.action[", \%action.stub:as_lua(),
"] = ", \(what (%args -> %body) compiles to))
return lua
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -332,7 +331,7 @@ test:
..one
"two""
..== "\"one\\n\\\"two\\\"\""
(quote %s) compiles to (Lua "tostring(\(%s as lua expr)):as_lua()")
(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
test:
assume (lua type of {}) == "table"

74
core/operators.nom
View File

@ -11,15 +11,14 @@ test:
assume (all [1 < 2, 2 > 1, 1 <= 2, 2 >= 1, 1 == 1, 1 != 2])
# Comparison Operators
(%x < %y) compiles to (Lua value "(\(%x as lua expr) < \(%y as lua expr))")
(%x > %y) compiles to (Lua value "(\(%x as lua expr) > \(%y as lua expr))")
(%x <= %y) compiles to (Lua value "(\(%x as lua expr) <= \(%y as lua expr))")
(%x >= %y) compiles to (Lua value "(\(%x as lua expr) >= \(%y as lua expr))")
[%a is %b, %a == %b] all compile to (..)
Lua value "(\(%a as lua expr) == \(%b as lua expr))"
(%x < %y) compiles to "(\(%x as lua expr) < \(%y as lua expr))"
(%x > %y) compiles to "(\(%x as lua expr) > \(%y as lua expr))"
(%x <= %y) compiles to "(\(%x as lua expr) <= \(%y as lua expr))"
(%x >= %y) compiles to "(\(%x as lua expr) >= \(%y as lua expr))"
[%a is %b, %a == %b] all compile to "(\(%a as lua expr) == \(%b as lua expr))"
[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to (..)
Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to "\
..(\(%a as lua expr) ~= \(%b as lua expr))"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -45,6 +44,7 @@ test:
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"
@ -143,7 +143,7 @@ test:
test:
assume ((5 wrapped around 2) == 1) or barf "mod not working"
[%x wrapped around %y, %x mod %y] all compile to (..)
Lua value "((\(%x as lua expr)) % (\(%y as lua expr)))"
"((\(%x as lua expr)) % (\(%y as lua expr)))"
# 3-part chained comparisons
# (uses a lambda to avoid re-evaluating middle value, while still being an expression)
@ -187,8 +187,8 @@ test:
assume (((no) and (barfer)) == (no))
assume ((no) or (yes))
assume ((yes) or (barfer))
(%x and %y) compiles to (Lua value "(\(%x as lua expr) and \(%y as lua expr))")
(%x or %y) compiles to (Lua value "(\(%x as lua expr) or \(%y as lua expr))")
(%x and %y) compiles to "(\(%x as lua expr) and \(%y as lua expr))"
(%x or %y) compiles to "(\(%x as lua expr) or \(%y as lua expr))"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -204,49 +204,39 @@ test:
# Lua 5.3 introduced bit operators like | and &. Use them when possible, otherwise
fall back to bit.bor(), bit.band(), etc.
%use_bitops = ((is jit) or ((Lua version) == "Lua 5.2"))
[NOT %, ~ %] all compile to (..)
Lua value (..)
(%use_bitops and "bit.bnot(\(% as lua expr))") or "~(\(% as lua expr))"
[%a OR %b, %a | %b] all compile to (..)
Lua value (..)
(%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or "\
..(\(%a as lua expr) | \(%b as lua expr))"
[%a XOR %b, %a ~ %b] all compile to (..)
Lua value (..)
(%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or "\
..(\(%a as lua expr) ~ \(%b as lua expr))"
[%a AND %b, %a & %b] all compile to (..)
Lua value (..)
(%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or "\
..(\(%a as lua expr) & \(%b as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to (..)
Lua value (..)
(%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or "\
lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then"
[NOT %, ~ %] all compile to "bit.bnot(\(% as lua expr))"
[%x OR %y, %x | %y] all compile to "bit.bor(\(%x as lua expr), \(%y as lua expr))"
[%x XOR %y, %x ~ %y] all compile to "bit.bxor(\(%x as lua expr), \(%y as lua expr))"
[%x AND %y, %x & %y] all compile to "bit.band(\(%x as lua expr), \(%y as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to "\
..bit.lshift(\(%x as lua expr), \(%shift as lua expr))"
[%x RSHIFT %shift, %x >> %shift] all compile to "\
..bit.rshift(\(%x as lua expr), \(%shift as lua expr))"
lua> "else"
[NOT %, ~ %] all compile to "~(\(% as lua expr))"
[%x OR %y, %x | %y] all compile to "(\(%x as lua expr) | \(%y as lua expr))"
[%x XOR %y, %x ~ %y] all compile to "(\(%x as lua expr) ~ \(%y as lua expr))"
[%x AND %y, %x & %y] all compile to "(\(%x as lua expr) & \(%y as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to "\
..(\(%x as lua expr) << \(%shift as lua expr))"
[%x RSHIFT %shift, %x >> %shift] all compile to (..)
Lua value (..)
(%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or "\
[%x RSHIFT %shift, %x >> %shift] all compile to "\
..(\(%x as lua expr) >> \(%shift as lua expr))"
lua> "end"
# Unary operators
test:
assume ((- 5) == -5)
assume ((not (yes)) == (no))
(- %) compiles to (Lua value "(- \(% as lua expr))")
(not %) compiles to (Lua value "(not \(% as lua expr))")
(- %) compiles to "(- \(% as lua expr))"
(not %) compiles to "(not \(% as lua expr))"
test:
assume ((size of [1, 2, 3]) == 3)
[size of %list, size of %list, size of %list, size of %list] all compile to (..)
Lua value "(#\(%list as lua expr))"
"(#\(%list as lua expr))"
(%list is empty) compiles to (Lua value "(#\(%list as lua expr) == 0)")
(%list is empty) compiles to "(#\(%list as lua expr) == 0)"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

12
core/text.nom
View File

@ -29,16 +29,18 @@ test:
%こんにちは = "こんにちは"
(% と言う) とは "\(%)世界"
assume (%こんにちは と言う) == "こんにちは世界"
(%expr for %match in %text matching %patt) compiles to (..)
Lua value "\
(%expr for %match in %text matching %patt) compiles to:
define mangler
return (..)
Lua "\
..(function()
local ret = _List{}
local \(mangle "comprehension") = _List{}
for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
%patt as lua expr
..) do
ret[#ret+1] = \(%expr as lua statements)
\(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua statements)
end
return ret
return \(mangle "comprehension")
end)()"
test:

2
files.lua
View File

@ -256,7 +256,7 @@ Files.get_line = function(str, line_no)
if not (stop) then
return
end
return str:sub(start, stop - 2)
return (str:sub(start, stop - 2))
end
local get_lines = re.compile([[ lines <- {| line (%nl line)* |}
line <- {[^%nl]*}

2
files.moon
View File

@ -152,7 +152,7 @@ Files.get_line = (str, line_no)->
return unless start
stop = line_starts[line_no+1]
return unless stop
return str\sub(start, stop - 2)
return (str\sub(start, stop - 2))
get_lines = re.compile([[
lines <- {| line (%nl line)* |}

6
lib/consolecolor.nom
View File

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

6
lib/os.nom
View File

@ -21,16 +21,14 @@ externally (read file %filename) means (=lua "Files.read(\%filename)")
test:
for file %f in "core": do nothing
(for file %f in %path %body) compiles to (..)
Lua "\
(for file %f in %path %body) compiles to "\
..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
\(%body as lua statements)
\(what (===next %f ===) compiles to)
end
\(what (===stop %f ===) compiles to)"
(%expr for file %f in %path) compiles to (..)
Lua value "\
(%expr for file %f in %path) compiles to "\
..(function()
local ret = List{}
for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do

2
lib/version.nom
View File

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

22
nomsu_compiler.lua
View File

@ -50,13 +50,18 @@ compile_error = function(tree, err_msg, hint)
title = "Compile error",
error = err_msg,
hint = hint,
source = tree:get_source_code(),
source = tree:get_source_file(),
start = tree.source.start,
stop = tree.source.stop,
filename = tree.source.filename
})
return error(err_str, 0)
end
local tree_to_nomsu, tree_to_inline_nomsu
do
local _obj_0 = require("nomsu_decompiler")
tree_to_nomsu, tree_to_inline_nomsu = _obj_0.tree_to_nomsu, _obj_0.tree_to_inline_nomsu
end
local math_expression = re.compile([[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]])
local compile_math_expression
compile_math_expression = function(compile, tree, ...)
@ -125,9 +130,6 @@ local compile = setmetatable({
end
return operate_on_text(code)
end,
["Lua value"] = function(compile, tree, code)
return compile.action["Lua"](compile, tree, code)
end,
["lua >"] = function(compile, tree, code)
if code.type ~= "Text" then
return tree
@ -159,7 +161,17 @@ local compile = setmetatable({
return LuaCode(tree.source, "TESTS")
end,
["test"] = function(compile, tree, body)
return LuaCode(tree.source, "TESTS[" .. tostring(tostring(tree.source):as_lua()) .. "] = ", body:as_lua())
if not (body.type == 'Block') then
compile_error(tree, "This should be a Block")
end
local test_nomsu = body:get_source_code():match(":[ ]*(.*)")
do
local indent = test_nomsu:match("\n([ ]*)")
if indent then
test_nomsu = test_nomsu:gsub("\n" .. indent, "\n")
end
end
return LuaCode(tree.source, "TESTS[" .. tostring(tostring(tree.source):as_lua()) .. "] = ", test_nomsu:as_lua())
end,
["is jit"] = function(compile, tree, code)
return LuaCode(tree.source, "jit")

15
nomsu_compiler.moon
View File

@ -30,11 +30,11 @@ pretty_error = require("pretty_errors")
compile_error = (tree, err_msg, hint=nil)->
err_str = pretty_error{
title: "Compile error"
error:err_msg, hint:hint, source:tree\get_source_code!
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)
{:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler"
-- This is a bit of a hack, but this code handles arbitrarily complex
-- math expressions like 2*x + 3^2 without having to define a single
@ -88,9 +88,6 @@ compile = setmetatable({
return lua
return operate_on_text code
-- TODO: remove shim
["Lua value"]: (compile, tree, code)-> compile.action["Lua"](compile, tree, code)
["lua >"]: (compile, tree, code)->
if code.type != "Text"
return tree
@ -116,8 +113,12 @@ compile = setmetatable({
["tests"]: (compile, tree)-> LuaCode(tree.source, "TESTS")
["test"]: (compile, tree, body)->
-- TODO: maybe go back to storing nomsu code instead of syntax tree
LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", body\as_lua!
unless body.type == 'Block'
compile_error(tree, "This should be a Block")
test_nomsu = body\get_source_code!\match(":[ ]*(.*)")
if indent = test_nomsu\match("\n([ ]*)")
test_nomsu = test_nomsu\gsub("\n"..indent, "\n")
LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", test_nomsu\as_lua!
["is jit"]: (compile, tree, code)-> LuaCode(tree.source, "jit")
["Lua version"]: (compile, tree, code)-> LuaCode(tree.source, "_VERSION")

4
nomsu_environment.lua
View File

@ -164,7 +164,7 @@ local nomsu_environment = Importer({
title = "Parse error",
error = e.error,
hint = e.hint,
source = e:get_source_code(),
source = e:get_source_file(),
start = e.source.start,
stop = e.source.stop,
filename = e.source.filename
@ -312,7 +312,7 @@ local nomsu_environment = Importer({
title = "Compile error",
error = err_msg,
hint = hint,
source = tree:get_source_code(),
source = tree:get_source_file(),
start = tree.source.start,
stop = tree.source.stop,
filename = tree.source.filename

4
nomsu_environment.moon
View File

@ -75,7 +75,7 @@ nomsu_environment = Importer{
if num_errs > 0
err_strings = [pretty_error{
title:"Parse error"
error:e.error, hint:e.hint, source:e\get_source_code!
error:e.error, hint:e.hint, source:e\get_source_file!
start:e.source.start, stop:e.source.stop, filename:e.source.filename
} for i, e in ipairs(errs) when i <= 3]
if num_errs > #err_strings
@ -170,7 +170,7 @@ nomsu_environment = Importer{
compile_error_at: (tree, err_msg, hint=nil)->
err_str = pretty_error{
title: "Compile error"
error:err_msg, hint:hint, source:tree\get_source_code!
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)

5
syntax_tree.lua
View File

@ -83,9 +83,12 @@ do
end
return "SyntaxTree{" .. tostring(table.concat(bits, ", ")) .. "}"
end,
get_source_code = function(self)
get_source_file = function(self)
return self.__class.source_code_for_tree[self]
end,
get_source_code = function(self)
return self.__class.source_code_for_tree[self]:sub(self.source.start, self.source.stop)
end,
map = function(self, fn)
local replacement = fn(self)
if replacement == false then

3
syntax_tree.moon
View File

@ -45,7 +45,8 @@ class SyntaxTree
f = Files.read(s.filename)
return f
})
get_source_code: => @@source_code_for_tree[@]
get_source_file: => @@source_code_for_tree[@]
get_source_code: => @@source_code_for_tree[@]\sub(@source.start, @source.stop)
map: (fn)=>
replacement = fn(@)
if replacement == false then return nil