Re-autoformatted everything. The main changes are: no longer adding a
newline after 1-line indented code inside blocks, and forcing files to have a trailing newline. The trailing newline thing created a lot of spurious changes.
This commit is contained in:
Bruce Hill
parent
4fa9757fa2
commit
addac10a47
@ -13,4 +13,4 @@ upgrade action (%a *<- %b) to "2.3" as (%a *= %b)
|
||||
upgrade action (%a /<- %b) to "2.3" as (%a /= %b)
|
||||
upgrade action (%a ^<- %b) to "2.3" as (%a ^= %b)
|
||||
upgrade action (%a and<- %b) to "2.3" as (%a and= %b)
|
||||
upgrade action (%a or<- %b) to "2.3" as (%a or= %b)
|
||||
upgrade action (%a or<- %b) to "2.3" as (%a or= %b)
|
||||
|
||||
@ -10,30 +10,23 @@ upgrade %tree to "2.4" as:
|
||||
%new_lines = []
|
||||
%body = (..)
|
||||
(%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded]
|
||||
|
||||
for %line in %body:
|
||||
if:
|
||||
(not (%line is syntax tree)):
|
||||
compile error at %tree.source "WUT: %s"
|
||||
|
||||
(not (%line is "Action" syntax tree)):
|
||||
add %line to %new_lines
|
||||
|
||||
(%line.stub is "* %"):
|
||||
add %line.2 to %conditions
|
||||
|
||||
(%line.stub == "* else %"):
|
||||
add (\(else %block) with vars {block:%line.3}) to %new_lines
|
||||
|
||||
(%line.stub != "* % %"):
|
||||
add %line to %new_lines
|
||||
|
||||
else:
|
||||
add %line.2 to %conditions
|
||||
%action = %line.3
|
||||
unless (%action is "Block" syntax tree):
|
||||
%action = (=lua "Block(\%action.source, \%action)")
|
||||
|
||||
add %action to %conditions
|
||||
add (=lua "Action(\%conditions[1].source, unpack(\%conditions))") to %new_lines
|
||||
%conditions = []
|
||||
@ -46,31 +39,25 @@ upgrade %tree to "2.4" as:
|
||||
%new_lines = []
|
||||
%body = (..)
|
||||
(%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded]
|
||||
|
||||
for %line in %body:
|
||||
if:
|
||||
(not (%line is "Action" syntax tree)):
|
||||
add %line to %new_lines
|
||||
|
||||
(%line.stub is "* %"):
|
||||
add %line.2 to %values
|
||||
|
||||
(%line.stub == "* else %"):
|
||||
add (\(else %block) with vars {block:%line.3}) to %new_lines
|
||||
|
||||
(%line.stub != "* % %"):
|
||||
add %line to %new_lines
|
||||
|
||||
else:
|
||||
add %line.2 to %values
|
||||
%action = %line.3
|
||||
unless (%action is "Block" syntax tree):
|
||||
%action = (=lua "Block(\%action.source, \%action)")
|
||||
|
||||
add %action to %values
|
||||
add (=lua "Action(\%values[1].source, unpack(\%values))") to %new_lines
|
||||
%values = []
|
||||
|
||||
return (..)
|
||||
\(if %var is %body) with vars {..}
|
||||
var:%tree.2 upgraded, body:=lua "Block(\%tree[5].source, unpack(\%new_lines))"
|
||||
var:%tree.2 upgraded, body:=lua "Block(\%tree[5].source, unpack(\%new_lines))"
|
||||
|
||||
@ -6,4 +6,4 @@ upgrade action (for %1 where %2 matches %3 %4) to "2.5" as (..)
|
||||
for %1 in %2 matching %3 %4
|
||||
|
||||
upgrade action (%1 for %2 where %3 matches %4) to "2.5" as (..)
|
||||
%1 for %2 in %3 matching %4
|
||||
%1 for %2 in %3 matching %4
|
||||
|
||||
@ -8,11 +8,9 @@ upgrade %tree to "2" as:
|
||||
%true_body = (%tree.3 upgraded)
|
||||
unless (%true_body is "Block" syntax tree):
|
||||
%true_body = (=lua "Block(\%true_body.source, \%true_body)")
|
||||
|
||||
%false_body = (%tree.5 upgraded)
|
||||
unless (%false_body is "Block" syntax tree):
|
||||
%false_body = (=lua "Block(\%false_body.source, \%false_body)")
|
||||
|
||||
return (..)
|
||||
\(if %cond %true_body else %false_body) with vars {..}
|
||||
cond:%tree.2 upgraded, true_body:%true_body, false_body:%false_body
|
||||
@ -30,4 +28,4 @@ upgrade %tree to "2" as:
|
||||
%body = (last in %bits)
|
||||
%bits.(length of %bits) = (=lua "Block(\%body.source, \%body)")
|
||||
|
||||
return (=lua "Action(\%tree.source, unpack(\%bits))")
|
||||
return (=lua "Action(\%tree.source, unpack(\%bits))")
|
||||
|
||||
@ -10,7 +10,6 @@ action [upgrade to %version via %upgrade_fn]:
|
||||
action [upgrade action %stub to %version via %upgrade_fn]:
|
||||
unless %ACTION_UPGRADES.%version:
|
||||
%ACTION_UPGRADES.%version = []
|
||||
|
||||
%ACTION_UPGRADES.%version.%stub = %upgrade_fn
|
||||
|
||||
parse [upgrade %tree to %version as %body] as (..)
|
||||
@ -58,10 +57,8 @@ action [..]
|
||||
%versions = {}
|
||||
for %v = % in %UPGRADES:
|
||||
%versions.%v = (yes)
|
||||
|
||||
for %v = % in %ACTION_UPGRADES:
|
||||
%versions.%v = (yes)
|
||||
|
||||
%versions = ((keys in %versions) sorted by % -> (% as list))
|
||||
for %ver in %versions:
|
||||
if ((%ver as list) <= (%start_version as list)): do next %ver
|
||||
@ -94,4 +91,4 @@ action [use %path from version %version] (..)
|
||||
%file = (read file %filename)
|
||||
%tree = (parse %file from %filename)
|
||||
%tree = (upgrade %tree from %version)
|
||||
run tree %tree
|
||||
run tree %tree
|
||||
|
||||
@ -29,7 +29,6 @@ test:
|
||||
action [%item is in %list, %list contains %item, %list has %item]:
|
||||
for %key = %value in %list:
|
||||
if (%key is %item): return (yes)
|
||||
|
||||
return (no)
|
||||
|
||||
test:
|
||||
@ -41,7 +40,6 @@ action [..]
|
||||
..:
|
||||
for %key = %value in %list:
|
||||
if (%key is %item): return (no)
|
||||
|
||||
return (yes)
|
||||
|
||||
test:
|
||||
@ -94,7 +92,6 @@ parse [%expression for %item in %iterable] as (..)
|
||||
%comprehension = []
|
||||
for %item in %iterable:
|
||||
add %expression to %comprehension
|
||||
|
||||
return %comprehension
|
||||
|
||||
parse [..]
|
||||
@ -105,7 +102,6 @@ parse [..]
|
||||
%comprehension = []
|
||||
for %index in %start to %stop via %step:
|
||||
add %expression to %comprehension
|
||||
|
||||
return %comprehension
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
@ -127,10 +123,8 @@ parse [..]
|
||||
%comprehension = []
|
||||
for %key = %value in %iterable:
|
||||
add %expression to %comprehension
|
||||
|
||||
return %comprehension
|
||||
|
||||
|
||||
# Dict comprehensions
|
||||
test:
|
||||
assume (((% * %) = % for % in [1, 2, 3]) == {1:1, 4:2, 9:3})
|
||||
@ -141,7 +135,6 @@ parse [%key = %value for %item in %iterable, %key %value for %item in %iterable]
|
||||
%comprehension = {}
|
||||
for %item in %iterable:
|
||||
%comprehension.%key = %value
|
||||
|
||||
return %comprehension
|
||||
|
||||
test:
|
||||
@ -155,7 +148,6 @@ parse [..]
|
||||
%comprehension = {}
|
||||
for %src_key = %src_value in %iterable:
|
||||
%comprehension.%key = %value
|
||||
|
||||
return %comprehension
|
||||
|
||||
parse [..]
|
||||
@ -166,7 +158,6 @@ parse [..]
|
||||
%comprehension = {}
|
||||
for %item in %start to %stop via %step:
|
||||
%comprehension.%key = %value
|
||||
|
||||
return %comprehension
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
@ -186,7 +177,6 @@ action [%lists flattened]:
|
||||
%flat = []
|
||||
for %list in %lists:
|
||||
for %item in %list: add %item to %flat
|
||||
|
||||
return %flat
|
||||
|
||||
test:
|
||||
@ -222,7 +212,6 @@ compile [%dict with fallback %key -> %value] to (..)
|
||||
return value
|
||||
end})
|
||||
|
||||
|
||||
# Sorting
|
||||
test:
|
||||
%x = [3, 1, 2]
|
||||
@ -267,4 +256,4 @@ action [unique %items]:
|
||||
add % to %unique
|
||||
%seen.% = (yes)
|
||||
|
||||
return %unique
|
||||
return %unique
|
||||
|
||||
@ -76,7 +76,6 @@ compile [..]
|
||||
end
|
||||
end)())
|
||||
|
||||
|
||||
# GOTOs
|
||||
test:
|
||||
%i = 0
|
||||
@ -106,13 +105,13 @@ test:
|
||||
%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")
|
||||
@ -125,10 +124,8 @@ compile [repeat while %condition %body] to:
|
||||
|
||||
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 \(stop repeating)):
|
||||
%lua = (..)
|
||||
@ -142,7 +139,6 @@ 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
|
||||
@ -156,10 +152,8 @@ compile [repeat %n times %body] to:
|
||||
|
||||
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 \(stop repeating)):
|
||||
%lua = (..)
|
||||
@ -185,19 +179,21 @@ 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])
|
||||
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])
|
||||
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])
|
||||
|
||||
assume (%nums == [1, -2, 3, -2, 3, 4, 3, 4, 5])
|
||||
|
||||
# Numeric range for loops
|
||||
compile [..]
|
||||
@ -208,20 +204,17 @@ compile [..]
|
||||
# This uses Lua's approach of only allowing loop-scoped variables in a loop
|
||||
unless (%var.type is "Var"):
|
||||
compile error at %var.source "Loop expected variable, not: %s"
|
||||
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
|
||||
%step as lua expr
|
||||
.. do
|
||||
\(%body as lua statements)
|
||||
|
||||
|
||||
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 "\nend --numeric for-loop"
|
||||
if (%body has subtree (\(stop %v) with vars {v:%var})):
|
||||
%lua = (..)
|
||||
@ -239,7 +232,7 @@ 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]
|
||||
%a = [10, 20, 30, 40, 50]
|
||||
%b = []
|
||||
for %x in %a: add %x to %b
|
||||
assume (%a == %b)
|
||||
@ -248,7 +241,8 @@ test:
|
||||
if (%x == 10): do next %x
|
||||
if (%x == 50): stop %x
|
||||
add %x to %b
|
||||
assume (%b == [20,30,40])
|
||||
|
||||
assume (%b == [20, 30, 40])
|
||||
|
||||
# For-each loop (lua's "ipairs()")
|
||||
compile [for %var in %iterable %body] to:
|
||||
@ -256,7 +250,6 @@ compile [for %var in %iterable %body] to:
|
||||
# This uses Lua's approach of only allowing loop-scoped variables in a loop
|
||||
unless (%var.type is "Var"):
|
||||
compile error at %var.source "Loop expected variable, not: %s"
|
||||
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
|
||||
@ -264,10 +257,8 @@ compile [for %var in %iterable %body] to:
|
||||
|
||||
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 (\(stop %v) with vars {v:%var})):
|
||||
%lua = (..)
|
||||
@ -286,6 +277,7 @@ test:
|
||||
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()")
|
||||
@ -296,34 +288,27 @@ compile [..]
|
||||
# This uses Lua's approach of only allowing loop-scoped variables in a loop
|
||||
unless (%key.type is "Var"):
|
||||
compile error at %key.source "Loop expected variable, not: %s"
|
||||
|
||||
unless (%value.type is "Var"):
|
||||
compile error at %value.source "Loop expected variable, not: %s"
|
||||
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
|
||||
%iterable as lua expr
|
||||
..) do
|
||||
\(%body as lua statements)
|
||||
|
||||
|
||||
if (%body has subtree \(do next)):
|
||||
to %lua write "\n ::continue::"
|
||||
|
||||
if (%body has subtree (\(do next %v) with vars {v:%key})):
|
||||
to %lua write (Lua "\n\(compile as (===next %key ===))")
|
||||
|
||||
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 (\(stop %v) with vars {v:%key})):
|
||||
to %stop_labels write "\n\(compile as (===stop %key ===))"
|
||||
|
||||
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):
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
@ -337,11 +322,15 @@ 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"
|
||||
(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:
|
||||
@ -350,7 +339,6 @@ compile [if %body, when %body] to:
|
||||
%else_allowed = (yes)
|
||||
unless (%body.type is "Block"):
|
||||
compile error at %body.source "'if' expected a Block, but got: %s"
|
||||
|
||||
for %line in %body:
|
||||
unless (..)
|
||||
((%line.type is "Action") and ((length of %line) >= 2)) and (..)
|
||||
@ -364,7 +352,6 @@ compile [if %body, when %body] to:
|
||||
if ((%line.1 is "else") and ((length of %line) == 2)):
|
||||
unless %else_allowed:
|
||||
compile error at %line.source "Can't have two 'else' blocks"
|
||||
|
||||
unless ((length of "\%code") > 0):
|
||||
compile error at %line.source ".."
|
||||
Can't have an 'else' block without a preceeding condition
|
||||
@ -385,7 +372,6 @@ compile [if %body, when %body] to:
|
||||
|
||||
if (%i > 1):
|
||||
to %code write " or "
|
||||
|
||||
to %code write (%line.%i as lua expr)
|
||||
|
||||
to %code write ".."
|
||||
@ -396,16 +382,18 @@ compile [if %body, when %body] to:
|
||||
|
||||
if ((length of "\%code") == 0):
|
||||
compile error at %body.source "'if' block has an empty body"
|
||||
|
||||
to %code write "\nend --when"
|
||||
return %code
|
||||
|
||||
test:
|
||||
if 5 is:
|
||||
1 2 3: barf "bad switch statement"
|
||||
1 2 3:
|
||||
barf "bad switch statement"
|
||||
4 5: do nothing
|
||||
5 6: barf "bad switch statement"
|
||||
else: barf "bad switch statement"
|
||||
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:
|
||||
@ -414,7 +402,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
|
||||
%else_allowed = (yes)
|
||||
unless (%body.type is "Block"):
|
||||
compile error at %body.source "'if' expected a Block, but got: %s"
|
||||
|
||||
for %line in %body:
|
||||
unless (..)
|
||||
((%line.type is "Action") and ((length of %line) >= 2)) and (..)
|
||||
@ -428,7 +415,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
|
||||
if ((%line.1 is "else") and ((length of %line) == 2)):
|
||||
unless %else_allowed:
|
||||
compile error at %line.source "Can't have two 'else' blocks"
|
||||
|
||||
unless ((length of "\%code") > 0):
|
||||
compile error at %line.source ".."
|
||||
Can't have an 'else' block without a preceeding condition
|
||||
@ -449,7 +435,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
|
||||
|
||||
if (%i > 1):
|
||||
to %code write " or "
|
||||
|
||||
to %code write "branch_value == \(%line.%i as lua expr)"
|
||||
|
||||
to %code write ".."
|
||||
@ -460,7 +445,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
|
||||
|
||||
if ((length of "\%code") == 0):
|
||||
compile error at %body.source "'if % is % %' block has an empty body"
|
||||
|
||||
to %code write "\nend --when"
|
||||
return (..)
|
||||
Lua ".."
|
||||
@ -469,7 +453,6 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
|
||||
\%code
|
||||
end --if % is
|
||||
|
||||
|
||||
# Do/finally
|
||||
compile [do %action] to (..)
|
||||
Lua ".."
|
||||
@ -483,9 +466,9 @@ test:
|
||||
do:
|
||||
%d.x = "bad"
|
||||
barf
|
||||
..then always:
|
||||
%d.x = "good"
|
||||
..then always: %d.x = "good"
|
||||
..and if it barfs: do nothing
|
||||
|
||||
assume (%d.x == "good")
|
||||
|
||||
compile [do %action then always %final_action] to (..)
|
||||
@ -502,11 +485,10 @@ compile [do %action then always %final_action] to (..)
|
||||
end
|
||||
|
||||
test:
|
||||
assume ((result of: return 99) == 99)
|
||||
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 = []
|
||||
@ -514,7 +496,7 @@ test:
|
||||
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
|
||||
@ -522,7 +504,6 @@ 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))"
|
||||
|
||||
%lua = (..)
|
||||
Lua ".."
|
||||
do
|
||||
@ -530,17 +511,13 @@ compile [for %var in recursive %structure %body] to (..)
|
||||
while #stack\(%var as lua id) > 0 do
|
||||
\(%var as lua expr) = table.remove(stack\(%var as lua id), 1)
|
||||
\(%body as lua statements)
|
||||
|
||||
|
||||
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
|
||||
|
||||
@ -11,7 +11,7 @@ test:
|
||||
-> 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"
|
||||
|
||||
|
||||
@ -14,7 +14,6 @@ compile [compile error at %source %msg] to (..)
|
||||
compile [assume %condition] to:
|
||||
lua> ".."
|
||||
local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))
|
||||
|
||||
return (..)
|
||||
Lua ".."
|
||||
if not \(%condition as lua expr) then
|
||||
@ -37,7 +36,7 @@ test:
|
||||
%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
|
||||
|
||||
@ -20,4 +20,4 @@ compile [ask %prompt] to (..)
|
||||
return LuaCode.Value(tree.source, "(io.write(tostring(", \(..)
|
||||
%prompt as lua expr
|
||||
.., ")) and io.read())");
|
||||
end
|
||||
end
|
||||
|
||||
@ -10,7 +10,8 @@ use "core/collections.nom"
|
||||
|
||||
# Literals:
|
||||
test:
|
||||
assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf "math constants failed"
|
||||
assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf ".."
|
||||
math constants failed
|
||||
%nan = (NaN)
|
||||
assume (%nan != %nan) or barf "NaN failed"
|
||||
|
||||
@ -62,7 +63,6 @@ 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"
|
||||
@ -70,12 +70,10 @@ test:
|
||||
action [%n to the nearest %rounder] (..)
|
||||
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
|
||||
|
||||
|
||||
# Any/all/none
|
||||
compile [all of %items, all %items] to:
|
||||
unless (%items.type is "List"):
|
||||
return (Lua value "utils.all(\(%items as lua expr))")
|
||||
|
||||
%clauses = ((% as lua expr) for % in %items)
|
||||
return (Lua value "(\(%clauses joined with " and "))")
|
||||
|
||||
@ -83,7 +81,6 @@ parse [not all of %items, not all %items] as (not (all of %items))
|
||||
compile [any of %items, any %items] to:
|
||||
unless (%items.type is "List"):
|
||||
return (Lua value "utils.any(\(%items as lua expr))")
|
||||
|
||||
%clauses = ((% as lua expr) for % in %items)
|
||||
return (Lua value "(\(%clauses joined with " or "))")
|
||||
|
||||
@ -91,14 +88,12 @@ parse [none of %items, none %items] as (not (any of %items))
|
||||
compile [sum of %items, sum %items] to:
|
||||
unless (%items.type is "List"):
|
||||
return (Lua value "utils.sum(\(%items as lua expr))")
|
||||
|
||||
%clauses = ((% as lua expr) for % in %items)
|
||||
return (Lua value "(\(%clauses joined with " + "))")
|
||||
|
||||
compile [product of %items, product %items] to:
|
||||
unless (%items.type is "List"):
|
||||
return (Lua value "utils.product(\(%items as lua expr))")
|
||||
|
||||
%clauses = ((% as lua expr) for % in %items)
|
||||
return (Lua value "(\(%clauses joined with " * "))")
|
||||
|
||||
@ -133,7 +128,6 @@ parse [max of %items by %item = %value_expr] as (..)
|
||||
|
||||
return %best
|
||||
|
||||
|
||||
# Random functions
|
||||
action [seed random with %] (..)
|
||||
lua> ".."
|
||||
|
||||
@ -30,10 +30,13 @@ lua> ".."
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
test: compile [five] to (Lua value "5")
|
||||
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
|
||||
@ -43,6 +46,7 @@ test:
|
||||
compile [asdf] to:
|
||||
%tmp = ""
|
||||
return (Lua %tmp)
|
||||
|
||||
test:
|
||||
asdf
|
||||
assume (%tmp is (nil)) or barf "compile to is leaking variables"
|
||||
@ -81,18 +85,16 @@ compile [call %fn with %args] to (..)
|
||||
return lua
|
||||
|
||||
test:
|
||||
local action [foo %x]:
|
||||
return "outer"
|
||||
|
||||
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 (..)
|
||||
@ -137,7 +139,6 @@ 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:
|
||||
@ -150,7 +151,6 @@ test:
|
||||
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 ".."
|
||||
@ -270,10 +270,14 @@ compile [to %lua write %code joined by %glue] to (..)
|
||||
\(%lua as lua expr):concat_append(\(%code as lua expr), \(%glue as lua expr));
|
||||
|
||||
test:
|
||||
assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"")
|
||||
assume (..)
|
||||
(..)
|
||||
quote ".."
|
||||
one
|
||||
"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."
|
||||
|
||||
@ -284,9 +288,7 @@ 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(\(%text as lua expr))"
|
||||
|
||||
compile [parse %text] to (Lua value "nomsu:parse(\(%text as lua expr))")
|
||||
compile [parse %text from %filename] to (..)
|
||||
Lua value ".."
|
||||
nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..)
|
||||
@ -296,7 +298,8 @@ compile [parse %text from %filename] to (..)
|
||||
test:
|
||||
assume ((run "return (2 + 99)") == 101)
|
||||
external %passed = (no)
|
||||
run \: external %passed = (yes)
|
||||
run \:
|
||||
external %passed = (yes)
|
||||
assume %passed
|
||||
|
||||
compile [run %nomsu_code] to (..)
|
||||
@ -312,14 +315,12 @@ 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))"
|
||||
|
||||
|
||||
# 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.
|
||||
compile [return] to (Lua "do return; end")
|
||||
compile [return %return_value] to (..)
|
||||
Lua "do return \(%return_value as lua expr) end"
|
||||
|
||||
|
||||
# Literals
|
||||
compile [yes] to (Lua value "true")
|
||||
compile [no] to (Lua value "false")
|
||||
|
||||
@ -16,7 +16,6 @@ compile [%a is %b, %a == %b] to (..)
|
||||
compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to (..)
|
||||
Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
|
||||
|
||||
|
||||
# For strict identity checking, use (%x's id) is (%y's id)
|
||||
lua> ".."
|
||||
do
|
||||
@ -59,12 +58,10 @@ compile [%var = %value] to:
|
||||
end
|
||||
return lua
|
||||
|
||||
|
||||
# Simultaneous mutli-assignments like: x,y,z = 1,x,3;
|
||||
compile [set %assignments] to:
|
||||
assume (%assignments.type is "Dict") or barf ".."
|
||||
Expected a Dict for the assignments part of '<- %' statement, not \%assignments
|
||||
|
||||
lua> ".."
|
||||
local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
|
||||
for i, item in ipairs(\%assignments) do
|
||||
@ -107,7 +104,6 @@ compile [with external %externs %body] to:
|
||||
%body_lua = (%body as lua statements)
|
||||
lua> ".."
|
||||
\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))
|
||||
|
||||
return %body_lua
|
||||
|
||||
compile [with %assignments %body] to:
|
||||
@ -144,12 +140,10 @@ compile [with %assignments %body] to:
|
||||
\%lua
|
||||
end -- 'with' block
|
||||
|
||||
|
||||
# Math Operators
|
||||
compile [%x wrapped around %y, %x mod %y] to (..)
|
||||
Lua value "(\(%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)
|
||||
parse [%x < %y < %z] as (..)
|
||||
@ -176,7 +170,6 @@ parse [%x > %y >= %z] as (..)
|
||||
parse [%x >= %y >= %z] as (..)
|
||||
=lua "(function(x,y,z) return x >= y and y >= z; end)(\%x,\%y,\%z)"
|
||||
|
||||
|
||||
# TODO: optimize for common case where x,y,z are all either variables or number literals
|
||||
# Boolean Operators
|
||||
compile [%x and %y] to (Lua value "(\(%x as lua expr) and \(%y as lua expr))")
|
||||
@ -201,7 +194,6 @@ compile [%x RSHIFT %shift, %x >>> %shift] to (..)
|
||||
compile [%x ARSHIFT %shift, %x >> %shift] to (..)
|
||||
Lua value "(\(%x as lua expr) >> \(%shift as lua expr))"
|
||||
|
||||
|
||||
# TODO: implement OR, XOR, AND for multiple operands?
|
||||
# Unary operators
|
||||
compile [- %] to (Lua value "(- \(% as lua expr))")
|
||||
@ -209,7 +201,9 @@ compile [not %] to (Lua value "(not \(% as lua expr))")
|
||||
test:
|
||||
assume ((length of [1, 2, 3]) == 3)
|
||||
|
||||
compile [length of %list, len %list, || %list ||] to (Lua value "(#\(%list as lua expr))")
|
||||
compile [length of %list, len %list, || %list ||] to (..)
|
||||
Lua value "(#\(%list as lua expr))"
|
||||
|
||||
compile [%list is empty] to (Lua value "(#\(%list as lua expr) == 0)")
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
@ -20,10 +20,8 @@ compile [with local %locals %body, with local %locals do %body] to:
|
||||
|
||||
"List":
|
||||
declare locals ("\(% as lua)" for % in %locals) in %body_lua
|
||||
|
||||
"Var" "Action":
|
||||
declare locals ["\(%locals as lua)"] in %body_lua
|
||||
|
||||
else:
|
||||
compile error at %locals.source "Unexpected locals: %s"
|
||||
|
||||
|
||||
@ -54,9 +54,7 @@ compile [%text matches %pattern] to (..)
|
||||
(\(%text as lua expr):match(\(%pattern as lua expr)) and true or false)
|
||||
|
||||
compile [%text matching %pattern] to (..)
|
||||
Lua value ".."
|
||||
\(%text as lua expr):match(\(%pattern as lua expr))
|
||||
|
||||
Lua value "\(%text as lua expr):match(\(%pattern as lua expr))"
|
||||
|
||||
# Text literals
|
||||
lua> ".."
|
||||
|
||||
@ -41,7 +41,6 @@ say %one_two
|
||||
|
||||
The text will continue until the indentation ends, skipping trailing newlines.
|
||||
|
||||
|
||||
# How do I put values inside text? (AKA string formatting, string interpolation)
|
||||
say ".."
|
||||
Text can contain a backslash followed by a variable, list, dict, or parenthesized
|
||||
@ -100,52 +99,41 @@ if (1 > 10):
|
||||
..else:
|
||||
say "this will print"
|
||||
|
||||
|
||||
# There's no "elseif", so for longer conditionals, a "when" branch is the best option
|
||||
if:
|
||||
(3 > 6) (3 > 5) (3 > 4):
|
||||
say "this won't print"
|
||||
|
||||
(3 > 3):
|
||||
say "this won't print"
|
||||
|
||||
(3 > 2):
|
||||
say "this will print"
|
||||
|
||||
else:
|
||||
say "this is the default case"
|
||||
|
||||
|
||||
# How do I do a switch statement?
|
||||
if 3 is:
|
||||
0 1 2:
|
||||
say "this won't print"
|
||||
|
||||
3:
|
||||
say "this will print"
|
||||
|
||||
else:
|
||||
say "this won't print"
|
||||
|
||||
|
||||
# How do I loop over a list (a foreach loop)?
|
||||
%list = [1, 2, 3]
|
||||
for %x in %list:
|
||||
say "For %x loop #\%x"
|
||||
|
||||
|
||||
# How do I loop over a number range?
|
||||
# This is inclusive, so it will loop over 1,2, and 3
|
||||
for %i in 1 to 3:
|
||||
say "For %i in 1 to 3 loop #\%i"
|
||||
|
||||
|
||||
# This will print 0,2, and 4
|
||||
for %even in 0 to 5 by 2: say "Even #\%even"
|
||||
for %backwards in 3 to 1 by -1:
|
||||
say "Backwards #\%backwards"
|
||||
|
||||
|
||||
# How do I do a 'while' loop?
|
||||
%x = 1
|
||||
repeat while (%x <= 3):
|
||||
@ -157,7 +145,6 @@ repeat until (%x > 3):
|
||||
say "repeat until loop #\%x"
|
||||
%x += 1
|
||||
|
||||
|
||||
# How do I do an infinite loop?
|
||||
%x = 1
|
||||
repeat:
|
||||
@ -165,7 +152,6 @@ repeat:
|
||||
%x += 1
|
||||
if (%x > 3): stop repeating
|
||||
|
||||
|
||||
# How do I do a 'goto'?
|
||||
do:
|
||||
%x = 1
|
||||
@ -175,7 +161,6 @@ do:
|
||||
if (%x <= 3): go to %again
|
||||
say "finished going to"
|
||||
|
||||
|
||||
# How do I define a function/method/procedure?
|
||||
# In nomsu, they're called "action"s, and they can be declared like this:
|
||||
action [say both %first and also %second]:
|
||||
@ -184,7 +169,6 @@ action [say both %first and also %second]:
|
||||
# Function arguments are accessed just like variables
|
||||
say %second
|
||||
|
||||
|
||||
# Actions can use "return" to return a value early
|
||||
action [first fibonacci above %n]:
|
||||
%f1 = 0
|
||||
@ -277,7 +261,6 @@ compile [if %condition on opposite day %body] to (..)
|
||||
\(%body as lua statements)
|
||||
end
|
||||
|
||||
|
||||
# Constants can be defined as macros
|
||||
parse [TWENTY] as 20
|
||||
|
||||
@ -297,7 +280,6 @@ if (1 > (TWENTY)) on opposite day:
|
||||
say "Lua compiling macros work!"
|
||||
say "It looks like a keyword, but there's no magic here!"
|
||||
|
||||
|
||||
# How do I use an action as a value?
|
||||
# Well... it's always *possible* to fall back to Lua behavior for something like this:
|
||||
action [best of %items according to %key_fn]:
|
||||
|
||||
@ -22,4 +22,4 @@ for %name = %colornum in %colors:
|
||||
compile [\%name] to: Lua value (quote \(quote %escapecode))
|
||||
compile [\%name %text] to
|
||||
Lua value ".."
|
||||
(\\(quote \(quote %escapecode))..\\(%text as lua expr).."\\27[0m")
|
||||
(\\(quote \(quote %escapecode))..\\(%text as lua expr).."\\27[0m")
|
||||
|
||||
@ -25,4 +25,4 @@ action [hash %, sha1 %]:
|
||||
=lua ".."
|
||||
\%hash:gsub('.', function(c) return string.format('%02x', string.byte(c)) end)
|
||||
|
||||
parse [hash of file %filename] as (sha1 (=lua "io.open(\%filename):read('*a')"))
|
||||
parse [hash of file %filename] as (sha1 (=lua "io.open(\%filename):read('*a')"))
|
||||
|
||||
@ -11,7 +11,6 @@ compile [method %actions %body] to:
|
||||
declare locals in %lua
|
||||
for % in %actions:
|
||||
to %lua write "\nclass.\(% as lua id) = \(% as lua id)"
|
||||
|
||||
return (..)
|
||||
Lua ".."
|
||||
do -- Method: \(%actions.(1).stub)
|
||||
@ -58,4 +57,4 @@ compile [object %classname extends %parent %class_body] to (..)
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
parse [object %classname %class_body] as (..)
|
||||
object %classname extends (nil) %class_body
|
||||
object %classname extends (nil) %class_body
|
||||
|
||||
@ -38,7 +38,6 @@ compile [function %args %body, lambda %args %body] to:
|
||||
lua> "\%body:convert_to_statements('return ');"
|
||||
for % in %args.value:
|
||||
lua> "\%body:remove_free_vars(\%);"
|
||||
|
||||
to %lua write %body
|
||||
to %lua write "\nend)"
|
||||
return %lua
|
||||
|
||||
@ -1,3 +1,3 @@
|
||||
#!/usr/bin/env nomsu -V2.5.4.3
|
||||
# This file sets the current library version.
|
||||
lua> "NOMSU_LIB_VERSION = 3"
|
||||
lua> "NOMSU_LIB_VERSION = 3"
|
||||
|
||||
@ -35,4 +35,4 @@ assume (%x == [3, 2, 1])
|
||||
sort %x by % = %keys.%
|
||||
assume (%x == [2, 3, 1])
|
||||
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
|
||||
say "Collections test passed."
|
||||
say "Collections test passed."
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
#!/usr/bin/env nomsu -V2.5.4.3
|
||||
use "lib/consolecolor.nom"
|
||||
|
||||
say (bright (green "Color test passed."))
|
||||
say (bright (green "Color test passed."))
|
||||
|
||||
@ -9,10 +9,8 @@ action [test conditionals]:
|
||||
if (yes): %loc1 = (yes)
|
||||
if (no):
|
||||
barf "entered if 'no' conditional"
|
||||
|
||||
unless (yes):
|
||||
barf "entered unless 'yes' conditional"
|
||||
|
||||
if (yes): %loc2 = (yes)
|
||||
..else:
|
||||
barf "entered if 'yes' else conditional"
|
||||
@ -125,7 +123,6 @@ if:
|
||||
(no): barf "'when' fail"
|
||||
(no) (3 > 4):
|
||||
barf "'when' fail 2"
|
||||
|
||||
(yes) (barfer): do nothing
|
||||
(99 > 1):
|
||||
barf "Fell through incorrectly"
|
||||
@ -146,7 +143,6 @@ assume (not %leaked) or barf "'when' is leaking locals"
|
||||
if 4 is:
|
||||
1 2:
|
||||
barf "'when = ?' fail"
|
||||
|
||||
3 4 (barfer):
|
||||
%when_worked = (yes)
|
||||
|
||||
@ -177,4 +173,4 @@ for % in recursive %t:
|
||||
..else: add % to %flat
|
||||
|
||||
assume ((sorted %flat) == [1, 2, 3, 4, 5, 6])
|
||||
say "Control flow test passed."
|
||||
say "Control flow test passed."
|
||||
|
||||
@ -13,4 +13,4 @@ use "core"
|
||||
|
||||
for % in coroutine %co (add % to %nums)
|
||||
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
|
||||
say "Coroutines test passed."
|
||||
say "Coroutines test passed."
|
||||
|
||||
@ -13,4 +13,4 @@ try:
|
||||
..and if it barfs (do nothing)
|
||||
|
||||
assume (%x == 3) or barf "do/then always failed"
|
||||
say "Error handling test passed."
|
||||
say "Error handling test passed."
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
#!/usr/bin/env nomsu -V2.5.4.3
|
||||
use "core"
|
||||
|
||||
say "Inner directory 'use' test passed."
|
||||
say "Inner directory 'use' test passed."
|
||||
|
||||
@ -18,4 +18,4 @@ 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"
|
||||
assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1)
|
||||
assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4)
|
||||
say "Math test passed"
|
||||
say "Math test passed"
|
||||
|
||||
@ -60,7 +60,6 @@ swap %tmp and %tmp2
|
||||
assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".."
|
||||
'parse % as %' variable mangling failed.
|
||||
|
||||
|
||||
#
|
||||
remove action (foo %)
|
||||
try: foo 99
|
||||
@ -81,4 +80,4 @@ lua> %code
|
||||
assume (=lua "global_x") or barf "Running lua from a variable failed."
|
||||
%code = (Lua value "global_x")
|
||||
assume (=lua %code) or barf "Running lua from a variable failed."
|
||||
say "Metaprogramming test passed."
|
||||
say "Metaprogramming test passed."
|
||||
|
||||
@ -45,4 +45,4 @@ as (new Corgi {barks:1}):
|
||||
assume ((bark) == "Bark!") or barf "inheritance failed"
|
||||
assume ((woof) == "Bark!")
|
||||
|
||||
say "Object test passed."
|
||||
say "Object test passed."
|
||||
|
||||
@ -76,4 +76,4 @@ assume (%x == 2) or barf "+<- failed"
|
||||
assume (%x == 4) or barf "*<- failed"
|
||||
wrap %x around 3
|
||||
assume (%x == 1) or barf "wrap around failed"
|
||||
say "Operator test passed."
|
||||
say "Operator test passed."
|
||||
|
||||
@ -10,4 +10,4 @@ assume (%lines.3 == " Tests for the stuff defined in lib/os.nom")
|
||||
%n = 0
|
||||
for file %f in "core" (%n += 1)
|
||||
assume (%n > 0) or barf "Failed to walk the 'core' directory"
|
||||
say "OS test passed."
|
||||
say "OS test passed."
|
||||
|
||||
@ -13,4 +13,4 @@ with local [action (foo)]:
|
||||
assume ((foo) == "inner foo")
|
||||
|
||||
assume ((foo) == "outer foo")
|
||||
say "Scopes test passed."
|
||||
say "Scopes test passed."
|
||||
|
||||
@ -48,4 +48,4 @@ assume ("nogap" == "nogap")
|
||||
#
|
||||
block comment
|
||||
|
||||
say "Text test passed."
|
||||
say "Text test passed."
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#!/usr/bin/env nomsu -V2.4.4.3
|
||||
#!/usr/bin/env nomsu -V2.5.4.3
|
||||
use "core"
|
||||
use "lib/os.nom"
|
||||
|
||||
action [print tree %t at indent %indent]:
|
||||
if %t.type is:
|
||||
"Action":
|
||||
@ -8,12 +9,13 @@ action [print tree %t at indent %indent]:
|
||||
for %arg in %t:
|
||||
if (%arg is syntax tree):
|
||||
print tree %arg at indent "\%indent "
|
||||
|
||||
"Number":
|
||||
say "\(%indent)\(%t.1)"
|
||||
say "\%indent\(%t.1)"
|
||||
"Var":
|
||||
say "\(%indent)%\(%t.1)"
|
||||
else:
|
||||
say "\(%indent)\(%t.type):"
|
||||
say "\%indent\(%t.type):"
|
||||
for %arg in %t:
|
||||
if:
|
||||
(%arg is syntax tree):
|
||||
|
||||
@ -17,6 +17,7 @@ for %path in (command line args):
|
||||
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()"
|
||||
@ -25,7 +26,7 @@ for %path in (command line args):
|
||||
if %verbose:
|
||||
say " \(yellow (%.test with "\n" replaced by "\n "))"
|
||||
run %.test
|
||||
if %verbose:
|
||||
say (green "PASS")
|
||||
|
||||
if %verbose: say (green "PASS")
|
||||
..else:
|
||||
say "\r[\(green "PASS")"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user