Shifting further towards having inline tests. Also added a helper
function for directly extracting source lines from a Source or AST.
This commit is contained in:
Bruce Hill
parent
01d5f810ed
commit
dfd39f0b14
@ -43,6 +43,10 @@ compile [..]
|
||||
# Conditional expression (ternary operator)
|
||||
# Note: this uses a function instead of "(condition and if_expr or else_expr)"
|
||||
because that breaks if %if_expr is falsey, e.g. "x < 5 and false or 99"
|
||||
test:
|
||||
assume ((1 if (yes) else 2) == 1)
|
||||
assume ((1 if (no) else 2) == 2)
|
||||
|
||||
compile [..]
|
||||
%when_true_expr if %condition else %when_false_expr
|
||||
%when_true_expr if %condition otherwise %when_false_expr
|
||||
@ -74,31 +78,43 @@ compile [..]
|
||||
|
||||
|
||||
# GOTOs
|
||||
test:
|
||||
%i = 0
|
||||
=== %loop ===
|
||||
%i += 1
|
||||
unless (%i == 10): go to %loop
|
||||
assume (%i == 10)
|
||||
|
||||
compile [=== %label ===, --- %label ---, *** %label ***] to (..)
|
||||
Lua "::label_\(%label as lua identifier)::"
|
||||
|
||||
compile [go to %label] to (Lua "goto label_\(%label as lua identifier)")
|
||||
|
||||
# Basic loop control
|
||||
compile [do next] to (Lua "continue")
|
||||
compile [do next] to (Lua "goto continue")
|
||||
compile [stop] to (Lua "break")
|
||||
|
||||
# Helper function
|
||||
#TODO: do "using % compile %" instead so it's actually a helper function
|
||||
compile [%tree has subtree %subtree where %condition] to (..)
|
||||
Lua value ".."
|
||||
(function()
|
||||
for \(%subtree as lua expr) in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do
|
||||
if \(%condition as lua expr) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end)()
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
# While loops
|
||||
test:
|
||||
%x = 0
|
||||
repeat while (%x < 10): %x += 1
|
||||
assume (%x == 10)
|
||||
repeat while (%x < 20): stop
|
||||
repeat while (%x < 20): stop repeating
|
||||
assume (%x == 10)
|
||||
repeat while (%x < 20):
|
||||
%x += 1
|
||||
if (yes): do next
|
||||
barf "Failed to 'do next'"
|
||||
|
||||
assume (%x == 20)
|
||||
repeat while (%x < 30):
|
||||
%x += 1
|
||||
if (yes): do next repeat
|
||||
barf "Failed to 'do next repeat'"
|
||||
|
||||
assume (%x == 30)
|
||||
|
||||
compile [do next repeat] to (Lua "goto continue_repeat")
|
||||
compile [stop repeating] to (Lua "goto stop_repeat")
|
||||
compile [repeat while %condition %body] to:
|
||||
@ -107,15 +123,14 @@ compile [repeat while %condition %body] to:
|
||||
while \(%condition as lua expr) do
|
||||
\(%body as lua statements)
|
||||
|
||||
if (..)
|
||||
%body has subtree % where ((%.type == "Action") and (%.stub is "do next repeat"))
|
||||
..:
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (%body has subtree \(do next repeat)):
|
||||
to %lua write "\n ::continue_repeat::"
|
||||
|
||||
|
||||
to %lua write "\nend --while-loop"
|
||||
if (..)
|
||||
%body has subtree % where ((%.type == "Action") and (%.stub is "stop repeating"))
|
||||
..:
|
||||
if (%body has subtree \(stop repeating)):
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
do -- scope of "stop repeating" label
|
||||
@ -127,21 +142,26 @@ compile [repeat while %condition %body] to:
|
||||
|
||||
parse [repeat %body] as (repeat while (yes) %body)
|
||||
parse [repeat until %condition %body] as (repeat while (not %condition) %body)
|
||||
|
||||
test:
|
||||
%x = 0
|
||||
repeat 10 times: %x += 1
|
||||
assume (%x == 10)
|
||||
|
||||
compile [repeat %n times %body] to:
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
for i=1,\(%n as lua expr) do
|
||||
\(%body as lua statements)
|
||||
|
||||
if (..)
|
||||
%body has subtree % where ((%.type == "Action") and (%.stub is "do next repeat"))
|
||||
..:
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (%body has subtree \(do next repeat)):
|
||||
to %lua write "\n ::continue_repeat::"
|
||||
|
||||
to %lua write "\nend --numeric for-loop"
|
||||
if (..)
|
||||
%body has subtree % where ((%.type == "Action") and (%.stub is "stop repeating"))
|
||||
..:
|
||||
if (%body has subtree \(stop repeating)):
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
do -- scope of "stop repeating" label
|
||||
@ -151,7 +171,6 @@ compile [repeat %n times %body] to:
|
||||
|
||||
return %lua
|
||||
|
||||
|
||||
# For loop control flow
|
||||
compile [stop %var] to (Lua "goto stop_\(%var as lua identifier)")
|
||||
compile [do next %var] to (Lua "goto continue_\(%var as lua identifier)")
|
||||
@ -163,6 +182,23 @@ compile [===next %var ===, ---next %var ---, ***next %var ***] to (..)
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
test:
|
||||
%nums = []
|
||||
for %x in 1 to 5: add %x to %nums
|
||||
assume (%nums == [1,2,3,4,5])
|
||||
%nums = []
|
||||
for %x in 1 to 5 via 2: add %x to %nums
|
||||
assume (%nums == [1,3,5])
|
||||
%nums = []
|
||||
for %outer in 1 to 100:
|
||||
for %inner in %outer to (%outer + 2):
|
||||
if (%inner == 2):
|
||||
add -2 to %nums
|
||||
do next %inner
|
||||
add %inner to %nums
|
||||
if (%inner == 5): stop %outer
|
||||
assume (%nums == [1,-2,3,-2,3,4,3,4,5])
|
||||
|
||||
# Numeric range for loops
|
||||
compile [..]
|
||||
for %var in %start to %stop by %step %body
|
||||
@ -179,18 +215,15 @@ compile [..]
|
||||
%step as lua expr
|
||||
.. do
|
||||
\(%body as lua statements)
|
||||
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %var.1))
|
||||
..:
|
||||
if (%body has subtree (\(do next %v) with vars {v:%var})):
|
||||
to %lua write "\n \(compile as (===next %var ===))"
|
||||
|
||||
to %lua write "\nend --numeric for-loop"
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %var.1))
|
||||
..:
|
||||
if (%body has subtree (\(stop %v) with vars {v:%var})):
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
do -- scope for stopping for-loop
|
||||
@ -205,6 +238,17 @@ compile [..]
|
||||
parse [for %var in %start to %stop %body] as (..)
|
||||
for %var in %start to %stop via 1 %body
|
||||
|
||||
test:
|
||||
%a = [10,20,30,40,50]
|
||||
%b = []
|
||||
for %x in %a: add %x to %b
|
||||
assume (%a == %b)
|
||||
%b = []
|
||||
for %x in %a:
|
||||
if (%x == 10): do next %x
|
||||
if (%x == 50): stop %x
|
||||
add %x to %b
|
||||
assume (%b == [20,30,40])
|
||||
|
||||
# For-each loop (lua's "ipairs()")
|
||||
compile [for %var in %iterable %body] to:
|
||||
@ -218,17 +262,14 @@ compile [for %var in %iterable %body] to:
|
||||
for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
|
||||
\(%body as lua statements)
|
||||
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %var.1))
|
||||
..:
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (%body has subtree (\(do next %v) with vars {v:%var})):
|
||||
to %lua write (Lua "\n\(compile as (===next %var ===))")
|
||||
|
||||
to %lua write "\nend --foreach-loop"
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %var.1))
|
||||
..:
|
||||
if (%body has subtree (\(stop %v) with vars {v:%var})):
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
do -- scope for stopping for-loop
|
||||
@ -238,6 +279,14 @@ compile [for %var in %iterable %body] to:
|
||||
|
||||
return %lua
|
||||
|
||||
test:
|
||||
%d = {a:10, b:20, c:30, d:40, e:50}
|
||||
%result = []
|
||||
for %k = %v in %d:
|
||||
if (%k == "a"): do next %k
|
||||
if (%v == 20): do next %v
|
||||
add "\%k = \%v" to %result
|
||||
assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"])
|
||||
|
||||
# Dict iteration (lua's "pairs()")
|
||||
compile [..]
|
||||
@ -257,31 +306,22 @@ compile [..]
|
||||
%iterable as lua expr
|
||||
..) do
|
||||
\(%body as lua statements)
|
||||
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %key.1))
|
||||
..:
|
||||
if (%body has subtree (\(do next %v) with vars {v:%key})):
|
||||
to %lua write (Lua "\n\(compile as (===next %key ===))")
|
||||
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "do next %") and (%.(3).1 == %value.1))
|
||||
..:
|
||||
if (%body has subtree (\(do next %v) with vars {v:%value})):
|
||||
to %lua write (Lua "\n\(compile as (===next %value ===))")
|
||||
|
||||
to %lua write "\nend --foreach-loop"
|
||||
%stop_labels = (Lua "")
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %key.1))
|
||||
..:
|
||||
if (%body has subtree (\(stop %v) with vars {v:%key})):
|
||||
to %stop_labels write "\n\(compile as (===stop %key ===))"
|
||||
|
||||
if (..)
|
||||
%body has subtree % where (..)
|
||||
(%.type == "Action") and ((%.stub is "stop %") and (%.(2).1 == %value.1))
|
||||
..:
|
||||
if (%body has subtree (\(stop %v) with vars {v:%value})):
|
||||
to %stop_labels write "\n\(compile as (===stop %value ===))"
|
||||
|
||||
if ((length of "\%stop_labels") > 0):
|
||||
@ -295,6 +335,14 @@ compile [..]
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
test:
|
||||
if:
|
||||
(1 == 2) (100 < 0): barf "bad conditional"
|
||||
(1 == 0) (1 == 1) (%not_a_variable.x): do nothing
|
||||
(1 == 1): barf "bad conditional"
|
||||
(1 == 2): barf "bad conditional"
|
||||
else: barf "bad conditional"
|
||||
|
||||
# Multi-branch conditional (if..elseif..else)
|
||||
compile [if %body, when %body] to:
|
||||
%code = (Lua "")
|
||||
@ -352,6 +400,12 @@ compile [if %body, when %body] to:
|
||||
to %code write "\nend --when"
|
||||
return %code
|
||||
|
||||
test:
|
||||
if 5 is:
|
||||
1 2 3: barf "bad switch statement"
|
||||
4 5: do nothing
|
||||
5 6: barf "bad switch statement"
|
||||
else: barf "bad switch statement"
|
||||
|
||||
# Switch statement
|
||||
compile [if %branch_value is %body, when %branch_value is %body] to:
|
||||
@ -423,6 +477,17 @@ compile [do %action] to (..)
|
||||
\(%action as lua statements)
|
||||
end --do
|
||||
|
||||
test:
|
||||
%d = {}
|
||||
try:
|
||||
do:
|
||||
%d.x = "bad"
|
||||
barf
|
||||
..then always:
|
||||
%d.x = "good"
|
||||
..and if it barfs: do nothing
|
||||
assume (%d.x == "good")
|
||||
|
||||
compile [do %action then always %final_action] to (..)
|
||||
Lua ".."
|
||||
do
|
||||
@ -436,24 +501,46 @@ compile [do %action then always %final_action] to (..)
|
||||
if not fell_through then return ret end
|
||||
end
|
||||
|
||||
test:
|
||||
assume ((result of: return 99) == 99)
|
||||
|
||||
# Inline thunk:
|
||||
compile [result of %body] to (Lua value "(\(compile as ([] -> %body)))()")
|
||||
|
||||
test:
|
||||
%t = [1, [2, [[3], 4], 5, [[[6]]]]]
|
||||
%flat = []
|
||||
for % in recursive %t:
|
||||
if ((type of %) is "table"):
|
||||
for %2 in %: recurse % on %2
|
||||
..else: add % to %flat
|
||||
|
||||
assume ((sorted %flat) == [1, 2, 3, 4, 5, 6])
|
||||
|
||||
# Recurion control flow
|
||||
compile [for %var in recursive %structure %body] to (..)
|
||||
with local compile actions:
|
||||
compile [recurse %v on %x] to (..)
|
||||
Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))"
|
||||
|
||||
return (..)
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
do
|
||||
local stack\(%var as lua id) = list{\(%structure as lua expr)}
|
||||
while #stack\(%var as lua id) > 0 do
|
||||
\(%var as lua expr) = table.remove(stack\(%var as lua id), 1)
|
||||
\(%body as lua statements)
|
||||
\(compile as (===next %var ===))
|
||||
end
|
||||
\(compile as (===stop %var ===))
|
||||
end
|
||||
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (%body has subtree (\(do next %v) with vars {v:%var})):
|
||||
to %lua write "\n \(compile as (===next %var ===))"
|
||||
|
||||
to %lua write "\n end -- Recursive loop"
|
||||
if (%body has subtree (\(stop %v) with vars {v:%var})):
|
||||
to %lua write "\n \(compile as (===stop %var ===))"
|
||||
|
||||
to %lua write "\nend -- Recursive scope"
|
||||
|
||||
return %lua
|
||||
|
||||
@ -4,6 +4,17 @@
|
||||
|
||||
use "core/metaprogramming.nom"
|
||||
|
||||
test:
|
||||
%nums = []
|
||||
%co = (..)
|
||||
coroutine:
|
||||
-> 4
|
||||
-> 5
|
||||
repeat 3 times: -> 6
|
||||
|
||||
for % in coroutine %co: add % to %nums
|
||||
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
|
||||
|
||||
compile [coroutine %body, generator %body] to (..)
|
||||
Lua value ".."
|
||||
(function()
|
||||
@ -16,4 +27,4 @@ compile [for % in coroutine %co %body] to (..)
|
||||
Lua ".."
|
||||
for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
|
||||
\(%body as lua statements)
|
||||
end
|
||||
end
|
||||
|
||||
@ -27,6 +27,18 @@ compile [assume %condition or barf %message] to (..)
|
||||
error(\(%message as lua expr), 0)
|
||||
end
|
||||
|
||||
test:
|
||||
try (barf) and if it succeeds: barf "try failed."
|
||||
%worked = (no)
|
||||
try (barf) and if it barfs: %worked = (yes)
|
||||
assume %worked or barf "try/catch failed"
|
||||
%x = 1
|
||||
try:
|
||||
%x = 2
|
||||
do (barf) then always: %x = 3
|
||||
..and if it barfs: do nothing
|
||||
|
||||
assume (%x == 3) or barf "do/then always failed"
|
||||
|
||||
# Try/except
|
||||
compile [..]
|
||||
@ -75,4 +87,4 @@ parse [try %action and if it barfs %msg %fallback] as (..)
|
||||
try %action and if it succeeds (do nothing) or if it barfs %msg %fallback
|
||||
|
||||
parse [try %action and if it succeeds %success] as (..)
|
||||
try %action and if it succeeds %success or if it barfs (do nothing)
|
||||
try %action and if it succeeds %success or if it barfs (do nothing)
|
||||
|
||||
@ -9,6 +9,11 @@ use "core/control_flow.nom"
|
||||
use "core/collections.nom"
|
||||
|
||||
# Literals:
|
||||
test:
|
||||
assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf "math constants failed"
|
||||
%nan = (NaN)
|
||||
assume (%nan != %nan) or barf "NaN failed"
|
||||
|
||||
compile [infinity, inf] to (Lua value "math.huge")
|
||||
compile [not a number, NaN, nan] to (Lua value "(0/0)")
|
||||
compile [pi, Pi, PI] to (Lua value "math.pi")
|
||||
@ -17,7 +22,18 @@ compile [golden ratio] to (Lua value "((1+math.sqrt(5))/2)")
|
||||
compile [e] to (Lua value "math.exp(1)")
|
||||
|
||||
# Functions:
|
||||
test:
|
||||
assume (("5" as a number) == 5)
|
||||
|
||||
compile [% as a number, % as number] to (Lua value "tonumber(\(% as lua expr))")
|
||||
test:
|
||||
assume (..)
|
||||
all of [..]
|
||||
abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5
|
||||
arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
|
||||
hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
|
||||
..or barf "math functions failed"
|
||||
|
||||
compile [absolute value %, | % |, abs %] to (..)
|
||||
Lua value "math.abs(\(% as lua expr))"
|
||||
|
||||
@ -46,6 +62,11 @@ compile [log % base %base, log base %base of %] to (..)
|
||||
compile [floor %] to (Lua value "math.floor(\(% as lua expr))")
|
||||
compile [ceiling %, ceil %] to (Lua value "math.ceil(\(% as lua expr))")
|
||||
compile [round %, % rounded] to (Lua value "math.floor(\(% as lua expr) + .5)")
|
||||
|
||||
test:
|
||||
assume ((463 to the nearest 100) == 500) or barf "rounding failed"
|
||||
assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed"
|
||||
|
||||
action [%n to the nearest %rounder] (..)
|
||||
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
|
||||
|
||||
@ -88,6 +109,10 @@ compile [min of %items, smallest of %items, lowest of %items] to (..)
|
||||
compile [max of %items, biggest of %items, largest of %items, highest of %items] to
|
||||
..(Lua value "utils.max(\(%items as lua expr))")
|
||||
|
||||
test:
|
||||
assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1)
|
||||
assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4)
|
||||
|
||||
parse [min of %items by %item = %value_expr] as (..)
|
||||
result of:
|
||||
set {%best:nil, %best_key:nil}
|
||||
@ -126,4 +151,4 @@ compile [..]
|
||||
..to (Lua value "math.random(\(%low as lua expr), \(%high as lua expr))")
|
||||
|
||||
action [random choice from %elements, random choice %elements, random %elements] (..)
|
||||
=lua "\%elements[math.random(#\%elements)]"
|
||||
=lua "\%elements[math.random(#\%elements)]"
|
||||
|
||||
@ -30,6 +30,23 @@ lua> ".."
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
test: compile [five] to (Lua value "5")
|
||||
test:
|
||||
assume ((five) == 5) or barf "Compile to expression failed."
|
||||
compile [loc x] to (Lua "local _x = 99;")
|
||||
test:
|
||||
lua> "do"
|
||||
loc x
|
||||
assume (%x is 99) or barf "Compile to statements with locals failed."
|
||||
lua> "end"
|
||||
assume (%x is (nil)) or barf "Failed to properly localize a variable."
|
||||
compile [asdf] to:
|
||||
%tmp = ""
|
||||
return (Lua %tmp)
|
||||
test:
|
||||
asdf
|
||||
assume (%tmp is (nil)) or barf "compile to is leaking variables"
|
||||
|
||||
lua> ".."
|
||||
nomsu.COMPILE_ACTIONS["compile % to %"] = function(nomsu, tree, \%actions, \%body)
|
||||
local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(\
|
||||
@ -63,6 +80,21 @@ compile [call %fn with %args] to (..)
|
||||
lua:append(")")
|
||||
return lua
|
||||
|
||||
test:
|
||||
local action [foo %x]:
|
||||
return "outer"
|
||||
|
||||
with local [action (foo %)]:
|
||||
local action [foo %x]:
|
||||
%y = (%x + 1)
|
||||
return %y
|
||||
|
||||
assume ((foo 10) == 11) or barf "Action didn't work."
|
||||
assume (%y is (nil)) or barf "Action leaked a local into globals."
|
||||
parse [baz %] as (foo %)
|
||||
|
||||
assume ((foo 1) == "outer")
|
||||
|
||||
compile [local action %actions %body] to (..)
|
||||
lua> ".."
|
||||
local fn_name = "A"..string.as_lua_id(\%actions[1].stub)
|
||||
@ -87,13 +119,43 @@ compile [local action %actions %body] to (..)
|
||||
end
|
||||
return lua
|
||||
|
||||
test:
|
||||
action [baz1]: return "baz1"
|
||||
action [baz2] "baz2"
|
||||
|
||||
test:
|
||||
assume ((baz1) == "baz1")
|
||||
assume ((baz2) == "baz2")
|
||||
|
||||
compile [action %actions %body] to (..)
|
||||
lua> ".."
|
||||
local lua = \(compile as (local action %actions %body))
|
||||
lua:remove_free_vars(table.map(\%actions, function(a) return "A"..string.as_lua_id(a.stub) end))
|
||||
return lua
|
||||
|
||||
compile [action %action] to (Lua value "A\(%action.stub as lua id)")
|
||||
test:
|
||||
assume ((action (say %)) == (=lua "A_say_1"))
|
||||
|
||||
compile [action %action] to (Lua value (%action as lua id))
|
||||
|
||||
test:
|
||||
parse [swap %x and %y] as (..)
|
||||
do:
|
||||
%tmp = %x
|
||||
%x = %y
|
||||
%y = %tmp
|
||||
|
||||
test:
|
||||
set {%1:1, %2:2}
|
||||
swap %1 and %2
|
||||
assume ((%1 == 2) and (%2 == 1)) or barf ".."
|
||||
'parse % as %' failed on 'swap % and %'
|
||||
|
||||
set {%tmp:1, %tmp2:2}
|
||||
swap %tmp and %tmp2
|
||||
assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".."
|
||||
'parse % as %' variable mangling failed.
|
||||
|
||||
compile [parse %actions as %body] to (..)
|
||||
lua> ".."
|
||||
local replacements = {}
|
||||
@ -142,6 +204,10 @@ compile [%tree as lua return] to (..)
|
||||
compile [remove action %action] to (..)
|
||||
Lua "A\(=lua "string.as_lua_id(\(%action.stub))") = nil"
|
||||
|
||||
test:
|
||||
assume ("\(\(foo %x) as nomsu)" == "foo %x") or barf ".."
|
||||
action source code failed.
|
||||
|
||||
compile [%tree as nomsu] to (..)
|
||||
Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr))"
|
||||
|
||||
@ -175,6 +241,15 @@ action [%tree with vars %replacements] (..)
|
||||
end
|
||||
end)
|
||||
|
||||
compile [%tree has subtree %match_tree] to (..)
|
||||
Lua value ".."
|
||||
(function()
|
||||
local match_tree = \(%match_tree as lua expr)
|
||||
for subtree in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do
|
||||
if subtree == match_tree then return true end
|
||||
end
|
||||
end)()
|
||||
|
||||
compile [declare locals in %code] to (..)
|
||||
Lua value "\(%code as lua expr):declare_locals()"
|
||||
|
||||
@ -194,10 +269,23 @@ compile [to %lua write %code joined by %glue] to (..)
|
||||
Lua ".."
|
||||
\(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr));
|
||||
|
||||
test:
|
||||
assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"")
|
||||
|
||||
compile [quote %s] to (Lua value "repr(\(%s as lua expr))")
|
||||
|
||||
test:
|
||||
assume ((type of {}) == "table") or barf "type of failed."
|
||||
|
||||
compile [type of %obj] to (Lua value "type(\(%obj as lua expr))")
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
test:
|
||||
assume ((parse "foo %") == \(foo %))
|
||||
|
||||
compile [parse %text] to (..)
|
||||
Lua value "nomsu:parse(NomsuCode(\"\(%text.source)\", \(%text as lua expr)))"
|
||||
Lua value "nomsu:parse(\(%text as lua expr))"
|
||||
|
||||
compile [parse %text from %filename] to (..)
|
||||
Lua value ".."
|
||||
@ -205,12 +293,21 @@ compile [parse %text from %filename] to (..)
|
||||
%text as lua expr
|
||||
..))
|
||||
|
||||
test:
|
||||
assume ((run "return (2 + 99)") == 101)
|
||||
external %passed = (no)
|
||||
run \: external %passed = (yes)
|
||||
assume %passed
|
||||
|
||||
compile [run %nomsu_code] to (..)
|
||||
Lua value ".."
|
||||
nomsu:run(\(%nomsu_code as lua expr), \(..)
|
||||
=lua "repr(tostring(\(%nomsu_code.source)))"
|
||||
..)
|
||||
|
||||
test:
|
||||
assume ((\(5 + 5) as value) == 10) or barf "%tree as value failed."
|
||||
|
||||
action [run tree %tree, %tree as value] (lua> "return nomsu:run(\%tree)")
|
||||
compile [compile %block, compiled %block, %block compiled] to (..)
|
||||
Lua value "nomsu:compile(\(%block as lua))"
|
||||
@ -245,4 +342,4 @@ compile [with local compile actions %body] to (..)
|
||||
action [Nomsu version]:
|
||||
use "lib/version.nom"
|
||||
return ".."
|
||||
\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
|
||||
\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
|
||||
|
||||
@ -31,4 +31,4 @@ compile [with local %locals %body, with local %locals do %body] to:
|
||||
Lua ".."
|
||||
do
|
||||
\%body_lua
|
||||
end
|
||||
end
|
||||
|
||||
@ -45,3 +45,11 @@ action [..]
|
||||
|
||||
action [line number of %pos in %str] (=lua "Files.get_line_number(\%str, \%pos)")
|
||||
action [line %line_num in %str] (=lua "Files.get_line(\%str, \%line_num)")
|
||||
action [source lines of %tree]:
|
||||
%source = (%tree.source if (%tree is syntax tree) else %tree)
|
||||
%file = (read file %source.filename)
|
||||
return (..)
|
||||
(..)
|
||||
(line % in %file) for % in (line number of %source.start in %file) to (..)
|
||||
line number of %source.stop in %file
|
||||
..joined with "\n"
|
||||
|
||||
21
tools/find_action.nom
Executable file
21
tools/find_action.nom
Executable file
@ -0,0 +1,21 @@
|
||||
#!/usr/bin/env nomsu -V2.5.4.3
|
||||
use "core"
|
||||
use "lib/os.nom"
|
||||
use "lib/consolecolor.nom"
|
||||
|
||||
%stub = (command line args).1
|
||||
say "Looking for stub: \%stub (from \(command line args))"
|
||||
%files = ((command line args).% for % in 2 to (|| (command line args) ||))
|
||||
for %path in %files:
|
||||
for file %filename in %path:
|
||||
unless (%filename matches "%.nom$") (do next %filename)
|
||||
%file = (read file %filename)
|
||||
%tree = (parse %file from %filename)
|
||||
for %t in recursive %tree:
|
||||
if (%t is "Action" syntax tree) (..)
|
||||
if (%t.stub is %stub):
|
||||
%line_num = (line number of %t.source.start in %file)
|
||||
say (blue "\%filename:\%line_num:")
|
||||
say (yellow (source lines of %t))
|
||||
|
||||
if (%t is syntax tree) (for %sub in %t (recurse %t on %sub))
|
||||
27
tools/parse.nom
Executable file
27
tools/parse.nom
Executable file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/env nomsu -V2.4.4.3
|
||||
use "core"
|
||||
use "lib/os.nom"
|
||||
action [print tree %t at indent %indent]:
|
||||
if %t.type is:
|
||||
"Action":
|
||||
say "\(%indent)Action (\(%t.stub)):"
|
||||
for %arg in %t:
|
||||
if (%arg is syntax tree):
|
||||
print tree %arg at indent "\%indent "
|
||||
"Number":
|
||||
say "\(%indent)\(%t.1)"
|
||||
"Var":
|
||||
say "\(%indent)%\(%t.1)"
|
||||
else:
|
||||
say "\(%indent)\(%t.type):"
|
||||
for %arg in %t:
|
||||
if:
|
||||
(%arg is syntax tree):
|
||||
print tree %arg at indent "\%indent "
|
||||
else:
|
||||
say "\%indent \(quote %arg)"
|
||||
|
||||
for %path in (=lua "arg"):
|
||||
for file %filename in %path:
|
||||
unless (%filename matches "%.nom$"): do next %filename
|
||||
print tree (parse (read file %filename) from %filename) at indent ""
|
||||
31
tools/test.nom
Executable file
31
tools/test.nom
Executable file
@ -0,0 +1,31 @@
|
||||
#!/usr/bin/env nomsu -V2.5.4.3
|
||||
use "core"
|
||||
use "lib/os.nom"
|
||||
use "lib/consolecolor.nom"
|
||||
|
||||
%args = (command line args)
|
||||
if (%args.1 == "-v"):
|
||||
remove index 1 from %args
|
||||
%verbose = (yes)
|
||||
|
||||
%tests = ((=lua "Source:from_string(\%s)") = %t for %s = %t in (tests))
|
||||
for %path in (command line args):
|
||||
if (%path is "-i"): %inplace = (yes)
|
||||
for file %filename in %path:
|
||||
unless (%filename matches "%.nom$"): do next %filename
|
||||
%file_tests = []
|
||||
for %src = %test in %tests:
|
||||
if (%src.filename == %filename):
|
||||
add {test:%test, source:%src} to %file_tests
|
||||
unless (%file_tests is empty):
|
||||
sort %file_tests by % -> %.source
|
||||
lua> "io.write('[ .. ] ', \%filename); io.flush()"
|
||||
if %verbose: say ""
|
||||
for % in %file_tests:
|
||||
if %verbose:
|
||||
say " \(yellow (%.test with "\n" replaced by "\n "))"
|
||||
run %.test
|
||||
if %verbose:
|
||||
say (green "PASS")
|
||||
..else:
|
||||
say "\r[\(green "PASS")"
|
||||
Loading…
Reference in New Issue
Block a user