Bruce Hill
72d699fe86
- Added shebangs to generated code output
- SyntaxTree:map() -> SyntaxTree:with(), and corresponding changes to
metaprogramming API
- Added (return Lua 1) shorthand for (return (Lua 1))
- (1 and 2 and 3) compile rule mapping to -> (1 and (*extra arguments*))
- Don't scan for errors, just report them when compiling
- Syntax changes:
- Added prefix actions (e.g. #$foo)
- Operator chars now include utf8 chars
- Ditch "escaped nomsu" type (use (\ 1) compile action instead)
505 lines
16 KiB
Plaintext
505 lines
16 KiB
Plaintext
#!/usr/bin/env nomsu -V6.15.13.8
|
|
#
|
|
This file contains compile-time actions that define basic control flow structures
|
|
like "if" statements and loops.
|
|
|
|
use "core/metaprogramming"
|
|
use "core/operators"
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
# No-Op
|
|
test:
|
|
do nothing
|
|
(do nothing) compiles to ""
|
|
|
|
# Conditionals
|
|
test:
|
|
if (no):
|
|
fail "conditional fail"
|
|
|
|
(if $condition $if_body) compiles to ("
|
|
if \($condition as lua expr) then
|
|
\($if_body as lua)
|
|
end
|
|
")
|
|
|
|
test:
|
|
unless (yes):
|
|
fail "conditional fail"
|
|
|
|
(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 ("
|
|
if \($condition as lua expr) then
|
|
\($if_body as lua)
|
|
else
|
|
\($else_body as lua)
|
|
end
|
|
")
|
|
|
|
(else $) compiles to:
|
|
at (this tree) fail ("
|
|
Compile error: This 'else' is not connected to any 'if' or 'unless' condition.
|
|
Hint: You should probably have a ".." in front of the "else", to indicate \
|
|
..that it's attached to the previous condition.
|
|
")
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
# 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)
|
|
|
|
[
|
|
$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
|
|
] all compile 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, .List, .Dict, .Number}.($when_true_expr.type):
|
|
return Lua ("
|
|
(\($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 ("
|
|
((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)
|
|
--- (Loop) ---
|
|
$i -= 1
|
|
unless ($i == 0):
|
|
go to (Loop)
|
|
assume ($i == 0)
|
|
|
|
(--- $label ---) compiles to ("
|
|
::label_\(
|
|
($label.stub, as lua id) if ($label.type == "Action") else
|
|
$label as lua identifier
|
|
)::
|
|
")
|
|
|
|
(go to $label) compiles to ("
|
|
goto label_\(
|
|
($label.stub, as lua id) if ($label.type == "Action") else
|
|
$label as lua identifier
|
|
)
|
|
")
|
|
|
|
# Basic loop control
|
|
(stop $var) compiles to:
|
|
if $var:
|
|
return Lua "goto stop_\($var as lua identifier)"
|
|
..else:
|
|
return Lua "break"
|
|
|
|
(do next $var) compiles to:
|
|
if $var:
|
|
return Lua "goto continue_\($var as lua identifier)"
|
|
..else:
|
|
return Lua "goto continue"
|
|
|
|
(---stop $var ---) compiles to "::stop_\($var as lua identifier)::"
|
|
(---next $var ---) compiles to "::continue_\($var as lua identifier)::"
|
|
|
|
# While loops
|
|
test:
|
|
$x = 0
|
|
repeat while ($x < 10): $x += 1
|
|
assume ($x == 10)
|
|
repeat while ($x < 20): stop
|
|
assume ($x == 10)
|
|
repeat while ($x < 20):
|
|
$x += 1
|
|
if (yes):
|
|
do next
|
|
fail "Failed to 'do next'"
|
|
assume ($x == 20)
|
|
|
|
(repeat while $condition $body) compiles to:
|
|
$lua =
|
|
Lua ("
|
|
while \($condition as lua expr) do
|
|
\($body as lua)
|
|
")
|
|
|
|
if ($body has subtree \(do next)):
|
|
$lua, add "\n ::continue::"
|
|
|
|
$lua, add "\nend --while-loop"
|
|
return $lua
|
|
|
|
(repeat $body) parses as (repeat while (yes) $body)
|
|
(repeat until $condition $body) parses as (repeat while (not $condition) $body)
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
# For-each loop (lua's "ipairs()")
|
|
(for $var in $iterable at $i $body) compiles to:
|
|
# This uses Lua's approach of only allowing loop-scoped variables in a loop
|
|
if (($iterable.type == "Action") and (($iterable, get stub) == "1 to")):
|
|
[$start, $stop] = [$iterable.1, $iterable.3]
|
|
$loop =
|
|
Lua ("
|
|
local _start = \($start as lua expr)
|
|
for \($var as lua identifier)=_start,\($stop as lua expr) do
|
|
\($i as lua identifier) = \($var as lua identifier) - _start + 1
|
|
")
|
|
if (($iterable.type == "Action") and (($iterable, get stub) == "1 to 2 by")):
|
|
[$start, $stop, $step] = [$iterable.1, $iterable.3, $iterable.5]
|
|
$loop =
|
|
Lua ("
|
|
local _start, _step = \($start as lua expr), \($step as lua expr)
|
|
for \($var as lua identifier)=_start,\($stop as lua expr),_step do
|
|
\($i as lua identifier) = (\($var as lua identifier) - _start)/_step + 1
|
|
")
|
|
unless $loop:
|
|
$loop =
|
|
Lua ("
|
|
local _iterating = _1_as_list(\($iterable as lua expr))
|
|
for \($i as lua identifier)=1,#_iterating do
|
|
\($var as lua identifier) = _iterating[\($i as lua identifier)]
|
|
")
|
|
$lua =
|
|
Lua ("
|
|
do -- for-loop
|
|
\$loop
|
|
\;
|
|
")
|
|
$lua, add ($body as lua)
|
|
if ($body has subtree \(do next)):
|
|
$lua, add "\n ::continue::"
|
|
|
|
if ($body has subtree \(do next $var)):
|
|
$lua, add "\n " (\(---next $var ---) as lua)
|
|
|
|
$lua, add "\n end"
|
|
if ($body has subtree \(stop $var)):
|
|
$lua, add "\n " (\(---stop $var ---) as lua)
|
|
$lua, add "\nend -- for-loop"
|
|
return $lua
|
|
|
|
(for $var in $iterable $body) parses as
|
|
for $var in $iterable at (=lua "_i") $body
|
|
|
|
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
|
|
|
|
$result, add "\$k = \$v"
|
|
assume (($result sorted) == ["c = 30", "d = 40", "e = 50"])
|
|
|
|
# Numeric range for loops
|
|
test:
|
|
assume ([: for $ in (1 to 5): add $] == [1, 2, 3, 4, 5])
|
|
assume ([: for $ in (1 to 5 by 2): add $] == [1, 3, 5])
|
|
assume ([: for $ in (5 to 1): add $] == [])
|
|
$nums = []
|
|
for $outer in (1 to 100):
|
|
for $inner in ($outer to ($outer + 2)):
|
|
if ($inner == 2):
|
|
$nums, add -2
|
|
do next $inner
|
|
$nums, add $inner
|
|
if ($inner == 5):
|
|
stop $outer
|
|
assume ($nums == [1, -2, 3, -2, 3, 4, 3, 4, 5])
|
|
|
|
# These are shims, and should be phased out:
|
|
[
|
|
for $var in $start to $stop by $step $body
|
|
for $var in $start to $stop via $step $body
|
|
] all parse as (for $var in ($start to $stop by $step) $body)
|
|
|
|
(for $var in $start to $stop $body) parses as
|
|
for $var in ($start to $stop) $body
|
|
|
|
# repeat $n times is a shorthand:
|
|
test:
|
|
$x = 0
|
|
repeat 5 times:
|
|
$x += 1
|
|
assume $x == 5
|
|
|
|
(repeat $n times $body) parses as (for (=lua "_XXX_") in (1 to $n by 1) $body)
|
|
|
|
# Dict iteration (lua's "pairs()")
|
|
test:
|
|
$a = [10, 20, 30, 40, 50]
|
|
$b = []
|
|
for $x in $a:
|
|
$b, add $x
|
|
assume ($a == $b)
|
|
$b = []
|
|
for $x in $a:
|
|
if ($x == 10):
|
|
do next $x
|
|
|
|
if ($x == 50):
|
|
stop $x
|
|
|
|
$b, add $x
|
|
assume ($b == [20, 30, 40])
|
|
# Small memory footprint:
|
|
assume (1 to (1 << 31))
|
|
|
|
[for $key = $value in $iterable $body, for $key $value in $iterable $body]
|
|
..all compile to:
|
|
$lua =
|
|
Lua ("
|
|
for \($key as lua identifier),\($value as lua identifier) in pairs(\
|
|
..\($iterable as lua expr)) do
|
|
")
|
|
$lua, add "\n " ($body as lua)
|
|
if ($body has subtree \(do next)):
|
|
$lua, add "\n ::continue::"
|
|
|
|
if ($body has subtree \(do next $key)):
|
|
$lua, add "\n " (\(---next $key ---) as lua)
|
|
|
|
if ($body has subtree \(do next $value)):
|
|
$lua, add "\n " (\(---next $value ---) as lua)
|
|
|
|
$lua, add "\nend --foreach-loop"
|
|
$stop_labels = (Lua "")
|
|
if ($body has subtree \(stop $key)):
|
|
$stop_labels, add "\n" (\(---stop $key ---) as lua)
|
|
|
|
if ($body has subtree \(stop $value)):
|
|
$stop_labels, add "\n" (\(---stop $value ---) as lua)
|
|
|
|
if ((size of "\$stop_labels") > 0):
|
|
$inner_lua = $lua
|
|
$lua = (Lua "do -- scope for stopping for $ = $ loop\n ")
|
|
$lua, add $inner_lua $stop_labels "\nend"
|
|
|
|
return $lua
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
test:
|
|
when:
|
|
(1 == 2) (100 < 0):
|
|
fail "bad conditional"
|
|
(1 == 0) (1 == 1) $not_a_variable.x: do nothing
|
|
(1 == 1):
|
|
fail "bad conditional"
|
|
|
|
(1 == 2):
|
|
fail "bad conditional"
|
|
|
|
else:
|
|
fail "bad conditional"
|
|
|
|
# Multi-branch conditional (if..elseif..else)
|
|
(when $body) compiles to:
|
|
$code = (Lua "")
|
|
$clause = "if"
|
|
$else_allowed = (yes)
|
|
unless ($body.type == "Block"):
|
|
at $body fail ("
|
|
Compile error: 'if' expected a Block, but got a \($body.type).
|
|
Hint: Perhaps you forgot to put a ':' after 'if'?
|
|
")
|
|
|
|
for $line in $body:
|
|
unless
|
|
(($line.type == "Action") and ((size of $line) >= 2)) and
|
|
$line.(size of $line) is "Block" syntax tree
|
|
..:
|
|
at $line fail ("
|
|
Compile error: Invalid line for the body of an 'if' block.
|
|
Hint: Each line should contain one or more conditional expressions followed \
|
|
..by a block, or "else" followed by a block.
|
|
")
|
|
$action = $line.(size of $line)
|
|
if (($line.1 == "else") and ((size of $line) == 2)):
|
|
unless $else_allowed:
|
|
at $line fail ("
|
|
Compile error: You can't have two 'else' blocks.
|
|
Hint: Merge all of the 'else' blocks together.
|
|
")
|
|
|
|
unless ((size of "\$code") > 0):
|
|
at $line fail ("
|
|
Compile error: You can't have an 'else' block without a preceding condition.
|
|
Hint: If you want the code in this block to always execute, you don't need a \
|
|
..conditional block around it. Otherwise, make sure the 'else' block comes last.
|
|
")
|
|
|
|
$code, add "\nelse\n " ($action as lua)
|
|
$else_allowed = (no)
|
|
..else:
|
|
$code, add $clause " "
|
|
for $i in 1 to ((size of $line) - 1):
|
|
if ($i > 1):
|
|
$code, add " or "
|
|
$code, add ($line.$i as lua expr)
|
|
$code, add " then\n " ($action as lua)
|
|
$clause = "\nelseif"
|
|
|
|
if ((size of "\$code") == 0):
|
|
at $body fail ("
|
|
Compile error: 'if' block has an empty body.
|
|
Hint: This means nothing would happen, so the 'if' block should be deleted.
|
|
")
|
|
|
|
$code, add "\nend --when"
|
|
return $code
|
|
|
|
test:
|
|
if 5 is:
|
|
1 2 3:
|
|
fail "bad switch statement"
|
|
|
|
4 5:
|
|
do nothing
|
|
|
|
5 6:
|
|
fail "bad switch statement"
|
|
|
|
else:
|
|
fail "bad switch statement"
|
|
|
|
# Switch statement
|
|
[if $branch_value is $body, when $branch_value is $body] all compile to:
|
|
$code = (Lua "")
|
|
$clause = "if"
|
|
$else_allowed = (yes)
|
|
define mangler
|
|
unless ($body.type == "Block"):
|
|
at $body fail ("
|
|
Compile error: 'if' expected a Block, but got a \($body.type).
|
|
Hint: Perhaps you forgot to put a ':' after the 'is'?
|
|
")
|
|
|
|
for $line in $body:
|
|
unless
|
|
(($line.type == "Action") and ((size of $line) >= 2)) and
|
|
$line.(size of $line) is "Block" syntax tree
|
|
..:
|
|
at $line fail ("
|
|
Compile error: Invalid line for 'if' block.
|
|
Hint: Each line should contain expressions followed by a block, or "else" followed by a block.
|
|
")
|
|
$action = $line.(size of $line)
|
|
if (($line.1 == "else") and ((size of $line) == 2)):
|
|
unless $else_allowed:
|
|
at $line fail ("
|
|
Compile error: You can't have two 'else' blocks.
|
|
Hint: Merge all of the 'else' blocks together.
|
|
")
|
|
|
|
unless ((size of "\$code") > 0):
|
|
at $line fail ("
|
|
Compile error: You can't have an 'else' block without a preceding condition.
|
|
Hint: If you want the code in this block to always execute, you don't need \
|
|
..a conditional block around it. Otherwise, make sure the 'else' block comes last.
|
|
")
|
|
|
|
$code, add "\nelse\n " ($action as lua)
|
|
$else_allowed = (no)
|
|
..else:
|
|
$code, add $clause " "
|
|
for $i in 1 to ((size of $line) - 1):
|
|
if ($i > 1):
|
|
$code, add " or "
|
|
$code, add "\(mangle "branch value") == " ($line.$i as lua expr)
|
|
$code, add " then\n " ($action as lua)
|
|
$clause = "\nelseif"
|
|
|
|
if ((size of "\$code") == 0):
|
|
at $body fail ("
|
|
Compile error: 'if' block has an empty body.
|
|
Hint: This means nothing would happen, so the 'if' block should be deleted.
|
|
")
|
|
|
|
$code, add "\nend --when"
|
|
return Lua ("
|
|
do --if $ is...
|
|
local \(mangle "branch value") = \($branch_value as lua expr)
|
|
\$code
|
|
end -- if $ is...
|
|
")
|
|
|
|
# Do/finally
|
|
(do $action) compiles to ("
|
|
do
|
|
\($action as lua)
|
|
end -- do
|
|
")
|
|
|
|
test:
|
|
assume ((result of: return 99) == 99)
|
|
|
|
# Inline thunk:
|
|
(result of $body) compiles to "\(\(-> $body) as lua)()"
|
|
test:
|
|
$t = [1, [2, [[3], 4], 5, [[[6]]]]]
|
|
$flat = []
|
|
for $ in recursive $t:
|
|
if ((lua type of $) == "table"):
|
|
for $2 in $:
|
|
recurse $ on $2
|
|
..else:
|
|
$flat, add $
|
|
assume (sorted $flat) == [1, 2, 3, 4, 5, 6]
|
|
|
|
# Recurion control flow
|
|
(recurse $v on $x) compiles to
|
|
Lua "table.insert(_stack_\($v as lua expr), \($x as lua expr))"
|
|
|
|
(for $var in recursive $structure $body) compiles to:
|
|
$lua =
|
|
Lua ("
|
|
do
|
|
local _stack_\($var as lua expr) = a_List{\($structure as lua expr)}
|
|
while #_stack_\($var as lua expr) > 0 do
|
|
\($var as lua expr) = table.remove(_stack_\($var as lua expr), 1)
|
|
\($body as lua)
|
|
")
|
|
|
|
if ($body has subtree \(do next)):
|
|
$lua, add "\n ::continue::"
|
|
|
|
if ($body has subtree \(do next $var)):
|
|
$lua, add "\n \(\(---next $var ---) as lua)"
|
|
|
|
$lua, add "\n end -- Recursive loop"
|
|
if ($body has subtree \(stop $var)):
|
|
$lua, add "\n \(\(---stop $var ---) as lua)"
|
|
$lua, add "\nend -- Recursive scope"
|
|
return $lua
|