#!/usr/bin/env nomsu -V2.5.5.4
#
This file contains compile-time actions that define basic control flow structures
like "if" statements and loops.
use "core/metaprogramming.nom"
use "core/text.nom"
use "core/operators.nom"
use "core/errors.nom"
# No-Op
test: do nothing
compile [do nothing] to (Lua "")
# Conditionals
test:
if (no):
barf "conditional fail"
compile [if %condition %if_body] to (..)
Lua ".."
if \(%condition as lua expr) then
\(%if_body as lua statements)
end
test:
unless (yes):
barf "conditional fail"
parse [unless %condition %unless_body] as (if (not %condition) %unless_body)
compile [..]
if %condition %if_body else %else_body, unless %condition %else_body else %if_body
..to (..)
Lua ".."
if \(%condition as lua expr) then
\(%if_body as lua statements)
else
\(%else_body as lua statements)
end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# 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
%when_false_expr unless %condition else %when_true_expr
%when_false_expr unless %condition then %when_true_expr
..to (..)
# If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic
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 ".."
(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
%when_false_expr as lua expr
..)
..else:
# Otherwise, need to do an anonymous inline function (yuck, too bad lua
doesn't have a proper ternary operator!)
To see why this is necessary consider: (random()<.5 and false or 99)
return (..)
Lua value ".."
((function()
if \(%condition as lua expr) then
return \(%when_true_expr as lua expr)
else
return \(%when_false_expr as lua expr)
end
end)())
# 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 "goto continue")
compile [stop] to (Lua "break")
# 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:
%lua = (..)
Lua ".."
while \(%condition 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 repeat)):
to %lua write "\n ::continue_repeat::"
to %lua write "\nend --while-loop"
if (%body has subtree \(stop repeating)):
%lua = (..)
Lua ".."
do -- scope of "stop repeating" label
\%lua
::stop_repeat::
end -- end of "stop repeating" label scope
return %lua
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 \(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 = (..)
Lua ".."
do -- scope of "stop repeating" label
\%lua
::stop_repeat::
end -- end of "stop repeating" label scope
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)")
compile [===stop %var ===, ---stop %var ---, ***stop %var ***] to (..)
Lua "::stop_\(%var as lua identifier)::"
compile [===next %var ===, ---next %var ---, ***next %var ***] to (..)
Lua "::continue_\(%var as lua identifier)::"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
for %var in %start to %stop via %step %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 \(%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 = (..)
Lua ".."
do -- scope for stopping for-loop
\%lua
\(compile as (===stop %var ===))
end -- end of scope for stopping for-loop
return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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:
# 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
\(%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 (Lua "\n\(compile as (===next %var ===))")
to %lua write "\nend --foreach-loop"
if (%body has subtree (\(stop %v) with vars {v:%var})):
%lua = (..)
Lua ".."
do -- scope for stopping for-loop
\%lua
\(compile as (===stop %var ===))
end -- end of scope for stopping for-loop
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 [..]
for %key = %value in %iterable %body, for %key %value in %iterable %body
..to:
# 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 ".."
do -- scope for stopping for % = % loop
\%lua\%stop_labels
end
return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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 "")
%clause = "if"
%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 (..)
%line.(length of %line) is "Block" syntax tree
..:
compile error at %line.source ".."
Invalid line for 'if', each line should contain conditional expressions followed by a block, or "else" followed by a block:
%s
%action = %line.(length of %line)
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
to %code write ".."
else
\(%action as lua statements)
%else_allowed = (no)
..else:
to %code write "\%clause "
for %i in 1 to ((length of %line) - 1):
unless (%line.%i is syntax tree):
compile error at %line.source ".."
Invalid condition for 'if' statement:
%s
if (%i > 1):
to %code write " or "
to %code write (%line.%i as lua expr)
to %code write ".."
then
\(%action as lua statements)
%clause = "\nelseif"
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"
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:
%code = (Lua "")
%clause = "if"
%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 (..)
%line.(length of %line) is "Block" syntax tree
..:
compile error at %line.source ".."
Invalid line for 'if % is % %', each line should contain expressions followed by a block, or "else" followed by a block:
%s
%action = %line.(length of %line)
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
to %code write ".."
else
\(%action as lua statements)
%else_allowed = (no)
..else:
to %code write "\%clause "
for %i in 1 to ((length of %line) - 1):
unless (%line.%i is syntax tree):
compile error at %line.source ".."
Invalid condition for 'if' statement:
%s
if (%i > 1):
to %code write " or "
to %code write "branch_value == \(%line.%i as lua expr)"
to %code write ".."
then
\(%action as lua statements)
%clause = "\nelseif"
if ((length of "\%code") == 0):
compile error at %body.source "'if % is % %' block has an empty body"
to %code write "\nend --when"
return (..)
Lua ".."
do --if % is
local branch_value = \(%branch_value as lua expr)
\%code
end --if % is
# Do/finally
compile [do %action] to (..)
Lua ".."
do
\(%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
local fell_through = false
local ok, ret = pcall(function()
\(%action as lua statements)
fell_through = true
end)
\(%final_action as lua statements)
if not ok then error(ret, 0) end
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))"
%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)
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