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

Updating to v6.15, which includes "external (...)" instead of separate

Browse Source 
'externally' versions of stuff, and some auto-formatting.
This commit is contained in:
Bruce Hill 2019-01-15 15:53:31 -08:00
parent ef70abe4b7
commit bf37295fae
57 changed files with 838 additions and 845 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/how_do_i.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# How do I... # How do I...
# Write a comment? Put a # and go till the end of the line # Write a comment? Put a # and go till the end of the line
# How do I write a multi-line comment? # How do I write a multi-line comment?
@ -247,7 +247,6 @@ say (2 + 3)
# If you need to keep going after an indented region, you can start the next line with ".." # If you need to keep going after an indented region, you can start the next line with ".."
say both "Very very very very long first argument that needs its own line" say both "Very very very very long first argument that needs its own line"
..and also "short second arg" ..and also "short second arg"
(my favorite number) means (21 + 2) (my favorite number) means (21 + 2)
# This can be nested: # This can be nested:
@ -330,6 +329,7 @@ say (best of [2, -3, 4, -8] according to $($ squared))
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
say (best of [2, -3, 4, -8] where $x has score ($x * $x)) say (best of [2, -3, 4, -8] where $x has score ($x * $x))
# The line above expands to: # The line above expands to:
say say
result of: result of:

1
ldt.lua
View File

@ -1 +0,0 @@
/Users/bruce/Sandbox/lua/ldt/ldt.lua

64
lib/base64/init.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines actions for encoding/decoding base 64, as specified in: This file defines actions for encoding/decoding base 64, as specified in:
https://tools.ietf.org/html/rfc4648 https://tools.ietf.org/html/rfc4648
@ -15,36 +15,36 @@ test:
assume (base64 $plain) == $encoded assume (base64 $plain) == $encoded
assume (base64 decode $encoded) == $plain assume (base64 decode $encoded) == $plain
externally [base64 $str, base64 encode $str, $str base64] all mean: external:
$chars = [] [base64 $str, base64 encode $str, $str base64] all mean:
for $i in 1 to (size of $str) via 3: $chars = []
$bytes = [=lua "\$str:byte(\$i, \($i + 2))"] for $i in 1 to (size of $str) via 3:
$chars, add $b64_chars.((($bytes.1 & 252) >> 2) + 1) $bytes = [=lua "\$str:byte(\$i, \($i + 2))"]
if (size of $bytes) is: $chars, add $b64_chars.((($bytes.1 & 252) >> 2) + 1)
3: if (size of $bytes) is:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1) 3:
$chars, add $b64_chars.((($bytes.2 & 15) << 2) + (($bytes.3 & 192) >> 6) + 1) $chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
$chars, add $b64_chars.(($bytes.3 & 63) + 1) $chars, add $b64_chars.((($bytes.2 & 15) << 2) + (($bytes.3 & 192) >> 6) + 1)
$chars, add $b64_chars.(($bytes.3 & 63) + 1)
2: 2:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1) $chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
$chars, add $b64_chars.((($bytes.2 & 15) << 2) + 1) $chars, add $b64_chars.((($bytes.2 & 15) << 2) + 1)
$chars, add "=" $chars, add "="
1: 1:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + 1) $chars, add $b64_chars.((($bytes.1 & 3) << 4) + 1)
$chars, add "=" $chars, add "="
$chars, add "=" $chars, add "="
return ($chars, joined) return ($chars, joined)
(chr $) means (=lua "string.char(\$)")
externally (chr $) means (=lua "string.char(\$)") [decode base64 $str, $str base64 decoded, base64 decode $str] all mean:
externally [decode base64 $str, $str base64 decoded, base64 decode $str] all mean: $chars = []
$chars = [] for $i in 1 to (size of $str) via 4:
for $i in 1 to (size of $str) via 4: $indices = [: for $j in $i to ($i + 3): add $reverse_b64.($str, character $j)]
$indices = [: for $j in $i to ($i + 3): add $reverse_b64.($str, character $j)] $chars, add (chr (($indices.1 << 2) + (($indices.2 & 48) >> 4)))
$chars, add (chr (($indices.1 << 2) + (($indices.2 & 48) >> 4))) if (($str, character ($i + 2)) == "="): stop
if (($str, character ($i + 2)) == "="): stop $chars, add (chr ((($indices.2 & 15) << 4) + (($indices.3 & 60) >> 2)))
$chars, add (chr ((($indices.2 & 15) << 4) + (($indices.3 & 60) >> 2))) if (($str, character ($i + 3)) == "="): stop
if (($str, character ($i + 3)) == "="): stop $chars, add (chr ((($indices.3 & 3) << 6) + $indices.4))
$chars, add (chr ((($indices.3 & 3) << 6) + $indices.4)) return ($chars, joined)
return ($chars, joined)

15
lib/commandline/init.nom
View File

@ -1,11 +1,12 @@
# #
A library defining some command line program functionality A library defining some command line program functionality
(command line program with $args $body) parses as: external:
externally (run with $args) means $body (command line program with $args $body) parses as:
if (this file was run directly): external ((run with $args) means $body)
run with (the command line arguments) if (this file was run directly):
run with (the command line arguments)
externally (usage $) means: (usage $) means:
say "Usage: \$" say "Usage: \$"
exit 1 exit 1

2
lib/compatibility/2.3.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <2.3 to Nomsu 2.3 This file defines upgrades from Nomsu <2.3 to Nomsu 2.3

2
lib/compatibility/2.4.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <2.4 to Nomsu 2.4 This file defines upgrades from Nomsu <2.4 to Nomsu 2.4

2
lib/compatibility/2.5.5.5.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5 This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5

2
lib/compatibility/2.5.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <2.5 to Nomsu 2.5 This file defines upgrades from Nomsu <2.5 to Nomsu 2.5

6
lib/compatibility/2.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu 1 to Nomsu 2 This file defines upgrades from Nomsu 1 to Nomsu 2
@ -24,8 +24,8 @@ upgrade $tree to "2" as:
$need_blocks = [ $need_blocks = [
"if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1", "repeat 1 times" "if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1", "repeat 1 times"
"repeat", "repeat until 1", "for 1 in 2 to 3 by", "for 1 in 2 to 3 via" "repeat", "repeat until 1", "for 1 in 2 to 3 by", "for 1 in 2 to 3 via"
"for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with", "result of" "for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with"
"when" "result of", "when"
] ]
for $n in $need_blocks: for $n in $need_blocks:

2
lib/compatibility/3.5.5.6.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6 This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6

5
lib/compatibility/3.6.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <3.6 to 3.6 This file defines upgrades from Nomsu <3.6 to 3.6
@ -7,7 +7,8 @@ use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action [ upgrade action [
append $item to $list, add $item to $list, to $list add $item, to $list append $item append $item to $list, add $item to $list, to $list add $item
to $list append $item
] to "3.6" as ($list, add $item) ] to "3.6" as ($list, add $item)
upgrade action [add $item to $list at index $i] to "3.6" as upgrade action [add $item to $list at index $i] to "3.6" as

2
lib/compatibility/3.7.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <3.7 to 3.7 This file defines upgrades from Nomsu <3.7 to 3.7

2
lib/compatibility/3.8.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <3.8 to 3.8 (Text method changes) This file defines upgrades from Nomsu <3.8 to 3.8 (Text method changes)

2
lib/compatibility/3.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <=2 to Nomsu 3 This file defines upgrades from Nomsu <=2 to Nomsu 3

4
lib/compatibility/4.10.12.7.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <4.10.12.7 to 4.10.12.7 This file defines upgrades from Nomsu <4.10.12.7 to 4.10.12.7
use "compatibility/compatibility" use "compatibility/compatibility"
@ -8,9 +8,7 @@ use "compatibility/compatibility"
upgrade action ($ as lua statements) to "4.10.12.7" as ($ as lua) upgrade action ($ as lua statements) to "4.10.12.7" as ($ as lua)
upgrade action ($ as lua return) to "4.10.12.7" as upgrade action ($ as lua return) to "4.10.12.7" as
=lua "\$.type == 'Block' and \($ as lua) or 'return '..\($ as lua expr)" =lua "\$.type == 'Block' and \($ as lua) or 'return '..\($ as lua expr)"
upgrade action (Lua value $) to "4.10.12.7" as (Lua $) upgrade action (Lua value $) to "4.10.12.7" as (Lua $)
upgrade action ($e for $ in $items) to "4.10.12.7" as [: for $ in $items: add $e] upgrade action ($e for $ in $items) to "4.10.12.7" as [: for $ in $items: add $e]
upgrade action ($e for $k = $v in $items) to "4.10.12.7" as upgrade action ($e for $k = $v in $items) to "4.10.12.7" as
[: for $k = $v in $items: add $e] [: for $k = $v in $items: add $e]

9
lib/compatibility/4.11.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <4.11 to Nomsu 4.11 This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
(overhaul of function literals, deleting (if all of ...), etc. shorthand) (overhaul of function literals, deleting (if all of ...), etc. shorthand)
@ -25,9 +25,7 @@ upgrade action "set" to "4.11" via
for $entry in $tree.2 at $i: for $entry in $tree.2 at $i:
$lhs.$i = $entry.1 $lhs.$i = $entry.1
$rhs.$i = $entry.2 $rhs.$i = $entry.2
return (SyntaxTree {.type = "Action", .source = $tree.source} $lhs "=" $rhs)
return
SyntaxTree {.type = "Action", .source = $tree.source} $lhs "=" $rhs
upgrade action "1 with 2 ~>" to "4.11" via upgrade action "1 with 2 ~>" to "4.11" via
for $tree: for $tree:
@ -93,5 +91,6 @@ upgrade action [
] to "4.11" as (if (not (any of $items)) $body else $else) ] to "4.11" as (if (not (any of $items)) $body else $else)
upgrade action [ upgrade action [
unless none of $items $body else $else, unless none of $items then $body else $else unless none of $items $body else $else
unless none of $items then $body else $else
] to "4.11" as (if (any of $items) $body else $else) ] to "4.11" as (if (any of $items) $body else $else)

2
lib/compatibility/4.12.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <4.11 to Nomsu 4.11 This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
(overhaul of function literals, deleting (if all of ...), etc. shorthand) (overhaul of function literals, deleting (if all of ...), etc. shorthand)

2
lib/compatibility/4.8.10.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means") This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means")
use "compatibility/compatibility" use "compatibility/compatibility"

2
lib/compatibility/4.9.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <4.9 to 4.9 This file defines upgrades from Nomsu <4.9 to 4.9
use "compatibility/compatibility" use "compatibility/compatibility"

14
lib/compatibility/5.13.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V5.13 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <5.13 to 5.13 This file defines upgrades from Nomsu <5.13 to 5.13
use "compatibility/compatibility" use "compatibility/compatibility"
@ -6,19 +6,15 @@ use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action (size of $) to "5.13" as (#$) upgrade action (size of $) to "5.13" as (#$)
upgrade action "with" to "5.13" via
upgrade action "with" to "5.13" via (..)
for $tree: for $tree:
$assignments = $tree.2 $assignments = $tree.2
$body = $tree.3 $body = $tree.3
if ($assignments.type != "Dict"): if ($assignments.type != "Dict"): return $tree
return $tree
$new_assignments = \[] $new_assignments = \[]
for $a in $assignments at $i: for $a in $assignments at $i:
when: when:
(($a.type == "DictEntry") and ((#$a) == 1)): (($a.type == "DictEntry") and ((#$a) == 1)): $a = $a.1
$a = $a.1 (all of [$a.type == "DictEntry", (#$a) == 2]): $a = \($a.1 = $a.2)
(all of [$a.type == "DictEntry", (#$a) == 2]):
$a = \($a.1 = $a.2)
$new_assignments.$i = $a $new_assignments.$i = $a
return \(with $new_assignments $body) return \(with $new_assignments $body)

9
lib/compatibility/6.14.nom
View File

@ -1,6 +1,7 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines upgrades from Nomsu <6.14 to 6.14 This file defines upgrades from Nomsu <6.14 to 6.14
use "compatibility/compatibility" use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -26,16 +27,12 @@ upgrade action (assume $assumption or barf $err) to "6.14" as
unless $assumption: fail $err unless $assumption: fail $err
upgrade action (barf $msg) to "6.14" as (fail $msg) upgrade action (barf $msg) to "6.14" as (fail $msg)
upgrade action (\(1's meaning)).stub to "6.14" via upgrade action (\(1's meaning)).stub to "6.14" via
$tree -> (SyntaxTree {.source = $tree.source, .type = "Var", $tree.1}) $tree -> (SyntaxTree {.source = $tree.source, .type = "Var", $tree.1})
upgrade action (log base $b of $n) to "6.14" as (log $n base $b) upgrade action (log base $b of $n) to "6.14" as (log $n base $b)
upgrade action "use" to "6.14" via upgrade action "use" to "6.14" via
for $tree: for $tree:
$path = $tree.2.1 $path = $tree.2.1
$path = ($path, with "%.nom$" -> "") $path = ($path, with "%.nom$" -> "")
$path = ($path, with "^lib/" -> "") $path = ($path, with "^lib/" -> "")
return \(use (SyntaxTree {.source = $tree.2.source, .type="Text"} $path)) return \(use (SyntaxTree {.source = $tree.2.source, .type = "Text"} $path))

20
lib/compatibility/6.15.nom Normal file
View File

@ -0,0 +1,20 @@
#!/usr/bin/env nomsu -V6.15.13.8
#
This file defines upgrades from Nomsu <6.15 to 6.15
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action (external $x = $y) to "6.15" as (external ($x = $y))
upgrade action (externally $x means $y) to "6.15" as (external ($x means $y))
upgrade action (externally $x all mean $y) to "6.15" as
external ($x all mean $y)
upgrade action ($lists flattened) to "6.15" as [
: for $ in recursive $lists:
if ($ is a "List"):
for $child in $:
recurse $ on $child
..else: add $
]

209
lib/compatibility/compatibility.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains code for defining ways to upgrade code between different versions This file contains code for defining ways to upgrade code between different versions
of Nomsu. of Nomsu.
@ -8,126 +8,123 @@ use "filesystem"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$UPGRADES = {} $UPGRADES = {}
externally (upgrade to $version via $upgrade_fn) means:
$UPGRADES.$version = $upgrade_fn
$ACTION_UPGRADES = ({} with fallback $ -> {}) $ACTION_UPGRADES = ({} with fallback $ -> {})
externally (upgrade action $stub to $version via $upgrade_fn) means: external:
$ACTION_UPGRADES.$version.$stub = $upgrade_fn (upgrade to $version via $upgrade_fn) means:
$UPGRADES.$version = $upgrade_fn
(upgrade $tree to $version as $body) parses as (upgrade action $stub to $version via $upgrade_fn) means:
upgrade to $version via (($ $end_version) -> ($ with $tree -> $body)) $ACTION_UPGRADES.$version.$stub = $upgrade_fn
(upgrade action $actions to $version as $body) compiles to: (upgrade $tree to $version as $body) parses as
if ($actions is "Action" syntax tree): upgrade to $version via (($ $end_version) -> ($ with $tree -> $body))
$actions = \[$actions]
$lua = (Lua "")
for $action in $actions:
$replacements = {}
for $i in 1 to (size of $action):
if ($action.$i is "Var" syntax tree):
$replacements.($action.$i.1) = "\(\$tree as lua id)[\$i]"
define mangler
(make tree $t) means:
when:
($t is "Var" syntax tree):
if $replacements.($t.1):
return $replacements.($t.1)
..else:
external $needs_mangle = (yes)
return ("
SyntaxTree{type=\(quote $t.type), source=\(quote "\($t.source)"), \(quote (mangle $t.1))}
")
($t is syntax tree): (upgrade action $actions to $version as $body) compiles to:
$args = [] if ($actions is "Action" syntax tree):
for $k = $v in $t: $actions = \[$actions]
if ((type of $k) == "number"): $lua = (Lua "")
$args, add (make tree $v) for $action in $actions:
$replacements = {}
for $i in 1 to (size of $action):
if ($action.$i is "Var" syntax tree):
$replacements.($action.$i.1) = "\(\$tree as lua id)[\$i]"
define mangler
(make tree $t) means:
when:
($t is "Var" syntax tree):
if $replacements.($t.1):
return $replacements.($t.1)
..else: ..else:
$args, add "\($k)=\(make tree $v)" external ($needs_mangle = (yes))
return "SyntaxTree{\($args, joined with ", ")}" return ("
SyntaxTree{type=\(quote $t.type), source=\(quote "\($t.source)"), \(quote (mangle $t.1))}
")
else: ($t is syntax tree):
return (quote $t) $args = []
for $k = $v in $t:
if ((type of $k) == "number"):
$args, add (make tree $v)
..else:
$args, add "\($k)=\(make tree $v)"
return "SyntaxTree{\($args, joined with ", ")}"
unless ("\$lua" == ""): else:
$lua, add "\n" return (quote $t)
$retval = (make tree $body) unless ("\$lua" == ""):
$lua, add $lua, add "\n"
Lua ("
upgrade_action_1_to_2_via(\(quote $action.stub), \($version as lua expr), function(\
..\(\$tree as lua id))
return \$retval
end)
")
return $lua
externally [ $retval = (make tree $body)
$tree upgraded from $start_version to $end_version $lua, add
$tree upgraded to $end_version from $start_version Lua ("
] all mean: upgrade_action_1_to_2_via(\(quote $action.stub), \($version as lua expr), function(\
unless ($tree is syntax tree): return $tree ..\(\$tree as lua id))
return \$retval
end)
")
return $lua
($ver as list) means (($ as number) for $ in $ver matching "[0-9]+") [
$tree upgraded from $start_version to $end_version
$tree upgraded to $end_version from $start_version
] all mean:
unless ($tree is syntax tree): return $tree
($ver as list) means (($ as number) for $ in $ver matching "[0-9]+")
(Ver $) means:
[$lib, $ver] = ($, match "(.*)/([0-9.]+)")
if $lib:
return {.lib = $lib, .version = ($ver as list)}
return {.version = ($ as list)}
$start = (Ver $start_version)
$end = (Ver $end_version)
$end.lib or= $start.lib
assume $start.lib == $end.lib
$seen = {}
$versions = {}
for $v = $ in $UPGRADES:
$versions.$v = (yes)
(Ver $) means: for $v = $ in $ACTION_UPGRADES:
[$lib, $ver] = ($, match "(.*)/([0-9.]+)") $versions.$v = (yes)
if $lib:
return {.lib = $lib, .version = ($ver as list)}
return {.version = ($ as list)}
$start = (Ver $start_version) $versions = [: for $v = $ in $versions: if ((Ver $v).lib == $start.lib): add $v]
$end = (Ver $end_version) sort $versions by $ -> ($ as list)
$end.lib or= $start.lib for $ver in $versions:
assume $start.lib == $end.lib if (($ver as list) <= $start.version): do next $ver
if (($ver as list) > $end.version): stop $ver
if $ACTION_UPGRADES.$ver:
$tree =
$tree with $ ->:
if (($ is "Action" syntax tree) and $ACTION_UPGRADES.$ver.($.stub)):
$with_upgraded_args = {
: for $k = $v in $:
add $k = ($v upgraded from $start_version to $end_version)
}
set $with_upgraded_args's metatable to ($'s metatable)
return ($ACTION_UPGRADES.$ver.($.stub) $with_upgraded_args $end_version)
$seen = {} if $UPGRADES.$ver:
$versions = {} $with_upgraded_args = {
for $v = $ in $UPGRADES: $versions.$v = (yes) : for $k = $v in $tree:
for $v = $ in $ACTION_UPGRADES: $versions.$v = (yes) add $k = ($v upgraded from $start_version to $end_version)
$versions = [ }
:for $v = $ in $versions: set $with_upgraded_args's metatable to ($tree's metatable)
if ((Ver $v).lib == $start.lib): $tree = ($UPGRADES.$ver $with_upgraded_args $end_version)
add $v
]
sort $versions by $ -> ($ as list) if ($tree.version != $end_version):
for $ver in $versions: $tree = (SyntaxTree {: for $k = $v in $tree: add $k = $v})
if (($ver as list) <= $start.version): do next $ver $tree.version = $end_version
if (($ver as list) > $end.version): stop $ver if $tree.shebang:
if $ACTION_UPGRADES.$ver: $tree.shebang = "#!/usr/bin/env nomsu -V\$end_version\n"
$tree =
$tree with $ ->:
if (($ is "Action" syntax tree) and $ACTION_UPGRADES.$ver.($.stub)):
$with_upgraded_args = {
: for $k = $v in $:
add $k = ($v upgraded from $start_version to $end_version)
}
set $with_upgraded_args's metatable to ($'s metatable)
return ($ACTION_UPGRADES.$ver.($.stub) $with_upgraded_args $end_version)
if $UPGRADES.$ver: return $tree
$with_upgraded_args = {
: for $k = $v in $tree:
add $k = ($v upgraded from $start_version to $end_version)
}
set $with_upgraded_args's metatable to ($tree's metatable)
$tree = ($UPGRADES.$ver $with_upgraded_args $end_version)
if ($tree.version != $end_version): ($tree upgraded from $start_version) means
$tree = (SyntaxTree {: for $k = $v in $tree: add $k = $v}) $tree upgraded from $start_version to (Nomsu version)
$tree.version = $end_version
if $tree.shebang:
$tree.shebang = "#!/usr/bin/env nomsu -V\$end_version\n"
return $tree ($tree upgraded to $end_version) means
$tree upgraded from ($tree.version or (Nomsu version)) to $end_version
externally ($tree upgraded from $start_version) means ($tree upgraded) means
$tree upgraded from $start_version to (Nomsu version) $tree upgraded from ($tree.version or (Nomsu version)) to (Nomsu version)
externally ($tree upgraded to $end_version) means
$tree upgraded from ($tree.version or (Nomsu version)) to $end_version
externally ($tree upgraded) means
$tree upgraded from ($tree.version or (Nomsu version)) to (Nomsu version)

2
lib/compatibility/init.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14.13.8 #!/usr/bin/env nomsu -V6.15.13.8
export "compatibility/compatibility" export "compatibility/compatibility"
export "compatibility/2" export "compatibility/2"
export "compatibility/2.3" export "compatibility/2.3"

2
lib/consolecolor/init.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines actions for ANSI console color escape codes. This file defines actions for ANSI console color escape codes.

56
lib/core/collections.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains code that supports manipulating and using collections like lists This file contains code that supports manipulating and using collections like lists
and dictionaries. and dictionaries.
@ -44,19 +44,6 @@ test:
assume ({.x = 1, .y = 1} & {.y = 10, .z = 10}) == {.y = 1} assume ({.x = 1, .y = 1} & {.y = 10, .z = 10}) == {.y = 1}
assume ({.x = 1, .y = 1} ~ {.y = 10, .z = 10}) == {.x = 1, .z = 10} assume ({.x = 1, .y = 1} ~ {.y = 10, .z = 10}) == {.x = 1, .z = 10}
test:
assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4])
externally ($lists flattened) means:
$flat = []
for $item in recursive $lists:
if ($item is a "List"):
for $ in $item:
recurse $item on $
..else:
$flat, add $item
return $flat
test: test:
assume ((entries in {.x = 1}) == [{.key = "x", .value = 1}]) assume ((entries in {.x = 1}) == [{.key = "x", .value = 1}])
@ -118,28 +105,29 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: external:
assume ((sorted [3, 1, 2]) == [1, 2, 3]) test:
assume ((sorted [3, 1, 2]) == [1, 2, 3])
externally [$items sorted, sorted $items] all mean: [$items sorted, sorted $items] all mean:
$copy = [: for $ in $items: add $]
sort $copy
return $copy
[$items sorted by $item = $key, $items sorted by $item -> $key] all parse as
result of:
$copy = [: for $ in $items: add $] $copy = [: for $ in $items: add $]
sort $copy by $item = $key sort $copy
return $copy return $copy
test: [$items sorted by $item = $key, $items sorted by $item -> $key] all parse as
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3]) result of:
$copy = [: for $ in $items: add $]
sort $copy by $item = $key
return $copy
externally (unique $items) means: test:
$unique = [] assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
$seen = {}
for $ in $items: (unique $items) means:
unless $seen.$: $unique = []
$unique, add $ $seen = {}
$seen.$ = (yes) for $ in $items:
return $unique unless $seen.$:
$unique, add $
$seen.$ = (yes)
return $unique

3
lib/core/control_flow.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains compile-time actions that define basic control flow structures This file contains compile-time actions that define basic control flow structures
like "if" statements and loops. like "if" statements and loops.
@ -466,6 +466,7 @@ test:
# Recurion control flow # Recurion control flow
(recurse $v on $x) compiles to (recurse $v on $x) compiles to
Lua "table.insert(_stack_\($v as lua expr), \($x as lua expr))" Lua "table.insert(_stack_\($v as lua expr), \($x as lua expr))"
(for $var in recursive $structure $body) compiles to: (for $var in recursive $structure $body) compiles to:
$lua = $lua =
Lua (" Lua ("

2
lib/core/coroutines.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines the code that creates and manipulates coroutines This file defines the code that creates and manipulates coroutines

4
lib/core/errors.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains basic error reporting code This file contains basic error reporting code
@ -23,9 +23,7 @@ use "core/control_flow"
(assume $a == $b) compiles to: (assume $a == $b) compiles to:
lua> "local \$assumption = 'Assumption failed: '..tostring(\(\($a == $b) as nomsu))" lua> "local \$assumption = 'Assumption failed: '..tostring(\(\($a == $b) as nomsu))"
define mangler define mangler
return return
Lua (" Lua ("
do do

59
lib/core/id.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
@ -33,34 +33,35 @@ set $id_by_obj's metatable to {
return $id return $id
} }
externally (uuid) means: external:
# Set all the other bits to randomly (or pseudo-randomly) chosen values. (uuid) means:
$bytes = [ # Set all the other bits to randomly (or pseudo-randomly) chosen values.
# time-low, time-mid, time-high-and-version $bytes = [
randint (2 ^ (4 * 8)), randint (2 ^ (2 * 8)), randint (2 ^ (2 * 8 - 4)) # time-low, time-mid, time-high-and-version
# clock-seq-and-reserved, clock-seq-low randint (2 ^ (4 * 8)), randint (2 ^ (2 * 8)), randint (2 ^ (2 * 8 - 4))
randint (2 ^ (1 * 8 - 2)), randint (2 ^ (1 * 8)), randint (2 ^ (3 * 8)) # clock-seq-and-reserved, clock-seq-low
# node randint (2 ^ (1 * 8 - 2)), randint (2 ^ (1 * 8)), randint (2 ^ (3 * 8))
randint (2 ^ (3 * 8)) # node
] randint (2 ^ (3 * 8))
]
# Set the four most significant bits (bits 12 through 15) of the # Set the four most significant bits (bits 12 through 15) of the
# time_hi_and_version field to the 4-bit version number from # time_hi_and_version field to the 4-bit version number from
# Section 4.1.3. # Section 4.1.3.
$bytes.3 += 0x4000 $bytes.3 += 0x4000
# Set the two most significant bits (bits 6 and 7) of the # Set the two most significant bits (bits 6 and 7) of the
# clock_seq_hi_and_reserved to zero and one, respectively. # clock_seq_hi_and_reserved to zero and one, respectively.
$bytes.4 += 0xC0 $bytes.4 += 0xC0
return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\$bytes))") return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\$bytes))")
# For strict identity checking, use ($x's id) == ($y's id) # For strict identity checking, use ($x's id) == ($y's id)
test: test:
assume (([] == []) and ((id of []) != (id of []))) assume (([] == []) and ((id of []) != (id of [])))
seed random with 0 seed random with 0
$x = [] $x = []
assume ((id of $x) == (id of $x)) assume ((id of $x) == (id of $x))
seed random with 0 seed random with 0
assume ((id of $x) != (id of [])) assume ((id of $x) != (id of []))
seed random seed random
externally [id of $, $'s id, $'id] all mean $id_by_obj.$ [id of $, $'s id, $'id] all mean $id_by_obj.$

2
lib/core/init.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14.13.8 #!/usr/bin/env nomsu -V6.15.13.8
# Export everything # Export everything
export "core/metaprogramming" export "core/metaprogramming"
export "core/operators" export "core/operators"

41
lib/core/io.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains basic input/output code This file contains basic input/output code
@ -6,24 +6,25 @@ use "core/metaprogramming"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(say $message) compiles to: external:
lua> (" (say $message) compiles to:
if \$message.type == "Text" then lua> ("
return LuaCode("say(", \($message as lua expr), ");"); if \$message.type == "Text" then
else return LuaCode("say(", \($message as lua expr), ");");
return LuaCode("say(tostring(", \($message as lua expr), "));"); else
end return LuaCode("say(tostring(", \($message as lua expr), "));");
") end
")
(say $message inline) compiles to: (say $message inline) compiles to:
lua> (" lua> ("
if \$message.type == "Text" then if \$message.type == "Text" then
return LuaCode("io.write(", \($message as lua expr), ")"); return LuaCode("io.write(", \($message as lua expr), ")");
else else
return LuaCode("io.write(tostring(", \($message as lua expr), "))"); return LuaCode("io.write(tostring(", \($message as lua expr), "))");
end end
") ")
externally (ask $prompt) means: (ask $prompt) means:
$io.write $prompt $io.write $prompt
return ($io.read()) return ($io.read())

346
lib/core/math.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines some common math literals and functions This file defines some common math literals and functions
@ -10,203 +10,201 @@ use "core/collections"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Literals: external:
test: # Literals:
unless (all of [inf, NaN, pi, tau, golden ratio, e]): test:
fail "math constants failed" unless (all of [inf, NaN, pi, tau, golden ratio, e]):
$nan = (NaN) fail "math constants failed"
unless ($nan != $nan): $nan = (NaN)
fail "NaN failed" unless ($nan != $nan):
[infinity, inf] all compile to "math.huge" fail "NaN failed"
[not a number, NaN, nan] all compile to "(0/0)" [infinity, inf] all compile to "math.huge"
[pi, Pi, PI] all compile to "math.pi" [not a number, NaN, nan] all compile to "(0/0)"
[tau, Tau, TAU] all compile to "(2*math.pi)" [pi, Pi, PI] all compile to "math.pi"
(golden ratio) compiles to "((1+math.sqrt(5))/2)" [tau, Tau, TAU] all compile to "(2*math.pi)"
(e) compiles to "math.exp(1)" (golden ratio) compiles to "((1+math.sqrt(5))/2)"
(e) compiles to "math.exp(1)"
# Functions: # Functions:
test: test:
assume (("5" as a number) == 5) assume (("5" as a number) == 5)
external $($ as a number) = $(tonumber $) $($ as a number) = $(tonumber $)
external $($ as number) = $(tonumber $) $($ as number) = $(tonumber $)
test: test:
unless unless
all of [ all of [
abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5 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 arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
hyperbolic tangent 5, e^ 5, ln 5, log 5 base 2, floor 5, ceiling 5, round 5 hyperbolic tangent 5, e^ 5, ln 5, log 5 base 2, floor 5, ceiling 5, round 5
] ]
..: ..:
fail "math functions failed" fail "math functions failed"
external [$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
[$math.abs, $math.abs, $math.abs, $math.abs]
external [$(square root $), $(square root of $), $(√ $), $(sqrt $)] =
[$math.sqrt, $math.sqrt, $math.sqrt, $math.sqrt]
external [$(sine $), $(sin $)] = [$math.sin, $math.sin]
external [$(cosine $), $(cos $)] = [$math.cos, $math.cos]
external [$(tangent $), $(tan $)] = [$math.tan, $math.tan]
external [$(arc sine $), $(asin $)] = [$math.asin, $math.asin]
external [$(arc cosine $), $(acos $)] = [$math.acos, $math.acos]
external [$(arc tangent $), $(atan $)] = [$math.atan, $math.atan]
external [$(arc tangent $y / $x), $(atan2 $y $x)] = [$math.atan2, $math.atan2]
external [$(hyperbolic sine $), $(sinh $)] = [$math.sinh, $math.sinh]
external [$(hyperbolic cosine $), $(cosh $)] = [$math.cosh, $math.cosh]
external [$(hyperbolic tangent $), $(tanh $)] = [$math.tanh, $math.tanh]
external [$(e^ $), $(exp $)] = [$math.exp, $math.exp]
external [$(natural log $), $(ln $), $(log $), $(log $ base $)] = [$math.log, $math.log, $math.log, $math.log]
external $(floor $) = $math.floor
external [$(ceiling $), $(ceil $)] = [$math.ceil, $math.ceil]
externally [round $, $ rounded] all mean
floor ($ + 0.5)
test:
unless ((463 to the nearest 100) == 500): fail "rounding failed"
unless ((2.6 to the nearest 0.25) == 2.5): fail "rounding failed"
externally ($n to the nearest $rounder) means [$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
$rounder * (floor ($n / $rounder + 0.5)) [$math.abs, $math.abs, $math.abs, $math.abs]
# Any/all [$(square root $), $(square root of $), $(√ $), $(sqrt $)] =
externally [all of $items, all $items] all mean: [$math.sqrt, $math.sqrt, $math.sqrt, $math.sqrt]
for $ in $items:
unless $:
return (no)
return (yes)
[not all of $items, not all $items] all parse as (not (all of $items))
externally [any of $items, any $items] all mean:
for $ in $items:
if $:
return (yes)
return (no)
[none of $items, none $items] all parse as (not (any of $items))
# Sum/product [$(sine $), $(sin $)] = [$math.sin, $math.sin]
externally [sum of $items, sum $items] all mean: [$(cosine $), $(cos $)] = [$math.cos, $math.cos]
$total = 0 [$(tangent $), $(tan $)] = [$math.tan, $math.tan]
for $ in $items: [$(arc sine $), $(asin $)] = [$math.asin, $math.asin]
$total += $ [$(arc cosine $), $(acos $)] = [$math.acos, $math.acos]
return $total [$(arc tangent $), $(atan $)] = [$math.atan, $math.atan]
[$(arc tangent $y / $x), $(atan2 $y $x)] = [$math.atan2, $math.atan2]
[$(hyperbolic sine $), $(sinh $)] = [$math.sinh, $math.sinh]
[$(hyperbolic cosine $), $(cosh $)] = [$math.cosh, $math.cosh]
[$(hyperbolic tangent $), $(tanh $)] = [$math.tanh, $math.tanh]
[$(e^ $), $(exp $)] = [$math.exp, $math.exp]
[$(natural log $), $(ln $), $(log $), $(log $ base $)] =
[$math.log, $math.log, $math.log, $math.log]
$(floor $) = $math.floor
[$(ceiling $), $(ceil $)] = [$math.ceil, $math.ceil]
[round $, $ rounded] all mean (floor ($ + 0.5))
test:
unless ((463 to the nearest 100) == 500): fail "rounding failed"
unless ((2.6 to the nearest 0.25) == 2.5): fail "rounding failed"
($n to the nearest $rounder) means ($rounder * (floor ($n / $rounder + 0.5)))
externally [product of $items, product $items] all mean: # Any/all
$prod = 1 [all of $items, all $items] all mean:
for $ in $items: for $ in $items:
$prod *= $ unless $:
return $prod return (no)
return (yes)
[not all of $items, not all $items] all parse as (not (all of $items))
[any of $items, any $items] all mean:
for $ in $items:
if $:
return (yes)
return (no)
[none of $items, none $items] all parse as (not (any of $items))
externally [avg of $items, average of $items] all mean # Sum/product
(sum of $items) / (size of $items) [sum of $items, sum $items] all mean:
$total = 0
for $ in $items:
$total += $
return $total
# Min/max [product of $items, product $items] all mean:
externally [min of $items, smallest of $items, lowest of $items] all mean: $prod = 1
$best = (nil) for $ in $items:
for $ in $items: $prod *= $
if (($best == (nil)) or ($ < $best)): $best = $ return $prod
return $best
externally [ [avg of $items, average of $items] all mean ((sum of $items) / (size of $items))
max of $items, biggest of $items, largest of $items, highest of $items
] all mean:
$best = (nil)
for $ in $items:
if (($best == (nil)) or ($ > $best)): $best = $
return $best
test: # Min/max
assume ((min of [3, -4, 1, 2] by $ = ($ * $)) == 1) [min of $items, smallest of $items, lowest of $items] all mean:
assume ((max of [3, -4, 1, 2] by $ = ($ * $)) == -4)
(min of $items by $item = $value_expr) parses as
result of:
$best = (nil) $best = (nil)
$best_key = (nil) for $ in $items:
for $item in $items: if (($best == (nil)) or ($ < $best)): $best = $
$key = $value_expr
if (($best == (nil)) or ($key < $best_key)):
$best = $item
$best_key = $key
return $best return $best
(max of $items by $item = $value_expr) parses as [max of $items, biggest of $items, largest of $items, highest of $items] all mean:
result of:
$best = (nil) $best = (nil)
$best_key = (nil) for $ in $items:
for $item in $items: if (($best == (nil)) or ($ > $best)): $best = $
$key = $value_expr
if (($best == (nil)) or ($key > $best_key)):
$best = $item
$best_key = $key
return $best return $best
test: test:
assume (100 clamped between 0 and 10) == 10 assume ((min of [3, -4, 1, 2] by $ = ($ * $)) == 1)
assume ((max of [3, -4, 1, 2] by $ = ($ * $)) == -4)
externally ($ clamped between $min and $max) means: (min of $items by $item = $value_expr) parses as
when: result of:
($ < $min): $best = (nil)
return $min $best_key = (nil)
for $item in $items:
$key = $value_expr
if (($best == (nil)) or ($key < $best_key)):
$best = $item
$best_key = $key
return $best
($ > $max): (max of $items by $item = $value_expr) parses as
return $max result of:
$best = (nil)
$best_key = (nil)
for $item in $items:
$key = $value_expr
if (($best == (nil)) or ($key > $best_key)):
$best = $item
$best_key = $key
return $best
else: test:
return $ assume (100 clamped between 0 and 10) == 10
test: ($ clamped between $min and $max) means:
assume (-0.1 smoothed by 2.7) == 0 when:
assume (0 smoothed by 2.7) == 0 ($ < $min):
assume (0.5 smoothed by 2.7) == 0.5 return $min
assume (1 smoothed by 2.7) == 1
assume (1.1 smoothed by 2.7) == 1
externally ($ smoothed by $smoothness) means: ($ > $max):
$ = ($ clamped between 0 and 1) return $max
if ($smoothness == 0): return $
$k = (2 ^ $smoothness)
if ($ < 0.5):
return (0.5 * (2 * $) ^ $k)
..else:
return (1 - 0.5 * (2 - 2 * $) ^ $k)
test: else:
assume (5 to 7 mixed by -1.0) == 5 return $
assume (5 to 7 mixed by 0.0) == 5
assume (5 to 7 mixed by 0.5) == 6
assume (5 to 7 mixed by 1.0) == 7
assume (5 to 7 mixed by 2.0) == 7
externally ($lo to $hi mixed by $amount) means: test:
$ = ($amount clamped between 0 and 1) assume (-0.1 smoothed by 2.7) == 0
return ((1 - $) * $lo + $ * $hi) assume (0 smoothed by 2.7) == 0
assume (0.5 smoothed by 2.7) == 0.5
assume (1 smoothed by 2.7) == 1
assume (1.1 smoothed by 2.7) == 1
test: ($ smoothed by $smoothness) means:
assume ([0, 1, 11] mixed by 0.0) == 0 $ = ($ clamped between 0 and 1)
assume ([0, 1, 11] mixed by 0.25) == 0.5 if ($smoothness == 0): return $
assume ([0, 1, 11] mixed by 0.5) == 1 $k = (2 ^ $smoothness)
assume ([0, 1, 11] mixed by 0.75) == 6 if ($ < 0.5):
assume ([0, 1, 11] mixed by 1.0) == 11 return (0.5 * (2 * $) ^ $k)
assume ([99] mixed by 0.5) == 99 ..else:
return (1 - 0.5 * (2 - 2 * $) ^ $k)
externally ($nums mixed by $amount) means: test:
$ = ($amount clamped between 0 and 1) assume (5 to 7 mixed by -1) == 5
$i = (1 + ($ * ((#$nums) - 1))) assume (5 to 7 mixed by 0) == 5
if ((floor $i) == (#$nums)): assume (5 to 7 mixed by 0.5) == 6
return $nums.(floor $i) assume (5 to 7 mixed by 1) == 7
[$lo, $hi] = [$nums.(floor $i), $nums.(floor ($i + 1))] assume (5 to 7 mixed by 2) == 7
return ($lo to $hi mixed by ($i mod 1))
# Random functions ($lo to $hi mixed by $amount) means:
externally (seed random with $) means: $ = ($amount clamped between 0 and 1)
lua> (" return ((1 - $) * $lo + $ * $hi)
math.randomseed(\$);
for i=1,20 do math.random(); end
")
(seed random) parses as (seed random with (=lua "os.time()"))
[random number, random, rand] all compile to "math.random()"
[random int $n, random integer $n, randint $n] all compile to
"math.random(\($n as lua expr))"
[random from $low to $high, random number from $low to $high, rand $low $high] test:
..all compile to "math.random(\($low as lua expr), \($high as lua expr))" assume ([0, 1, 11] mixed by 0) == 0
assume ([0, 1, 11] mixed by 0.25) == 0.5
assume ([0, 1, 11] mixed by 0.5) == 1
assume ([0, 1, 11] mixed by 0.75) == 6
assume ([0, 1, 11] mixed by 1) == 11
assume ([99] mixed by 0.5) == 99
externally [ ($nums mixed by $amount) means:
random choice from $elements, random choice $elements, random $elements $ = ($amount clamped between 0 and 1)
] all mean (=lua "\$elements[math.random(#\$elements)]") $i = (1 + ($ * ((#$nums) - 1)))
if ((floor $i) == (#$nums)):
return $nums.(floor $i)
[$lo, $hi] = [$nums.(floor $i), $nums.(floor ($i + 1))]
return ($lo to $hi mixed by ($i mod 1))
# Random functions
(seed random with $) means:
lua> ("
math.randomseed(\$);
for i=1,20 do math.random(); end
")
(seed random) parses as (seed random with (=lua "os.time()"))
[random number, random, rand] all compile to "math.random()"
[random int $n, random integer $n, randint $n] all compile to
"math.random(\($n as lua expr))"
[random from $low to $high, random number from $low to $high, rand $low $high]
..all compile to "math.random(\($low as lua expr), \($high as lua expr))"
[random choice from $elements, random choice $elements, random $elements]
..all mean (=lua "\$elements[math.random(#\$elements)]")

217
lib/core/metaprogramming.nom
View File

@ -1,9 +1,9 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This File contains actions for making actions and compile-time actions and some helper This File contains actions for making actions and compile-time actions and some helper
functions to make that easier. functions to make that easier.
lua> "NOMSU_CORE_VERSION = 14" lua> "NOMSU_CORE_VERSION = 15"
lua> "NOMSU_LIB_VERSION = 8" lua> "NOMSU_LIB_VERSION = 8"
lua> (" lua> ("
do do
@ -25,8 +25,7 @@ lua> ("
COMPILE_RULES["1 ->"] = function(\(nomsu environment), \$args, \$body) COMPILE_RULES["1 ->"] = function(\(nomsu environment), \$args, \$body)
if \$args and not \$body then \$args, \$body = {}, \$args end if \$args and not \$body then \$args, \$body = {}, \$args end
local body_lua = SyntaxTree:is_instance(\$body) and \(nomsu environment):compile(\$body) or \$body local body_lua = SyntaxTree:is_instance(\$body) and \(nomsu environment):compile(\$body) or \$body
if SyntaxTree:is_instance(\$body) and \$body.type ~= "Block" then body_lua:prepend("\ if SyntaxTree:is_instance(\$body) and \$body.type ~= "Block" then body_lua:prepend("return ") end
..return ") end
local lua = LuaCode("(function(") local lua = LuaCode("(function(")
if SyntaxTree:is_instance(\$args) and (\$args.type == "Action" or \$args.type == "MethodCall") then if SyntaxTree:is_instance(\$args) and (\$args.type == "Action" or \$args.type == "MethodCall") then
\$args = \$args:get_args() \$args = \$args:get_args()
@ -41,8 +40,7 @@ lua> ("
end end
elseif not arg_lua:is_lua_id() then elseif not arg_lua:is_lua_id() then
compile_error_at(SyntaxTree:is_instance(arg) and arg or nil, compile_error_at(SyntaxTree:is_instance(arg) and arg or nil,
"This does not compile to a Lua identifier, so it can't be used as a function \ "This does not compile to a Lua identifier, so it can't be used as a function argument.",
..argument.",
"This should probably be a Nomsu variable instead (like $x).") "This should probably be a Nomsu variable instead (like $x).")
end end
lua:add(i > 1 and ", " or "", arg_lua) lua:add(i > 1 and ", " or "", arg_lua)
@ -186,26 +184,40 @@ test:
") ")
test: test:
externally (baz1) means: $loc = 99
return "baz1" external ($glob = 99)
externally (baz2) means "baz2"
test: test:
assume ((baz1) == "baz1") assume $loc == (nil)
assume ((baz2) == "baz2") assume $glob == 99
(externally $action means $body) compiles to: (external $body) compiles to:
lua> (" lua> ("
local lua = \(\($action means $body) as lua) local lua = \($body as lua)
lua:remove_free_vars({\$action:get_stub():as_lua_id()}) lua:remove_free_vars()
return lua return lua
") ")
(externally $actions all mean $body) compiles to: test:
[$x, $y] = ["outer", "outer"]
external:
(set external x local y) means:
with external [$x]:
$x = "inner"
$y = "inner"
set external x local y
unless (($x == "inner") and ($y == "outer")):
fail "'with external' failed."
(with external $externals $body) compiles to:
lua> (" lua> ("
local lua = \(\($actions all mean $body) as lua) local body_lua = \($body as lua)
lua:remove_free_vars(table.map(\$actions, function(a) return a:get_stub():as_lua_id() end)) local varnames = {}
return lua for i,\$v in ipairs(\$externals) do
varnames[i] = \($v as lua):text()
end
body_lua:remove_free_vars(varnames)
return body_lua
") ")
test: test:
@ -239,8 +251,8 @@ test:
if replacements[t:as_var()] then if replacements[t:as_var()] then
return replacements[t:as_var()] return replacements[t:as_var()]
else else
return "SyntaxTree{mangle("..t:as_var():as_lua().."), type="..t.type:as_lua()..", \ return "SyntaxTree{mangle("..t:as_var():as_lua().."), type="..t.type:as_lua(\
..source="..tostring(t.source):as_lua().."}" ..)..", source="..tostring(t.source):as_lua().."}"
end end
elseif SyntaxTree:is_instance(t) then elseif SyntaxTree:is_instance(t) then
local ret = {} local ret = {}
@ -274,34 +286,37 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[$action parses as $body] all parse as ([$action] all parse as $body) [$action parses as $body] all parse as ([$action] all parse as $body)
externally (in (nomsu environment) $tree as lua expr) means: external:
lua> (" (in (nomsu environment) $tree as lua expr) means:
local tree_lua = \(nomsu environment):compile(\$tree) lua> ("
if \$tree.type == 'Block' then local tree_lua = \(nomsu environment):compile(\$tree)
tree_lua = LuaCode:from(\$tree.source, '(function()\\n ', tree_lua, '\\nend)()') if \$tree.type == 'Block' then
elseif \$tree.type == 'MethodCall' and #\$tree > 2 then tree_lua = LuaCode:from(\$tree.source, '(function()\\n ', tree_lua, '\\nend)()')
compile_error_at(\$tree, "This must be a single value instead of "..(#\$tree - 1).."\ elseif \$tree.type == 'MethodCall' and #\$tree > 2 then
.. method calls.", compile_error_at(\$tree, "This must be a single value instead of "..(#\$tree - 1).."\
"Replace this with a single method call.") .. method calls.",
end "Replace this with a single method call.")
return tree_lua end
") return tree_lua
")
# Need to make sure the proper environment is used for compilation (i.e. the caller's environment) # Need to make sure the proper environment is used for compilation (i.e. the caller's environment)
($tree as lua expr) compiles to (\(in \(nomsu environment) $tree as lua expr) as lua) ($tree as lua expr) compiles to
\(in \(nomsu environment) $tree as lua expr) as lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
externally [$var as lua identifier, $var as lua id] all mean: external:
lua> (" [$var as lua identifier, $var as lua id] all mean:
local lua = \($var as lua) lua> ("
if not lua:text():is_a_lua_id() then local lua = \($var as lua)
compile_error(\$var, if not lua:text():is_a_lua_id() then
"This is supposed to be something that compiles to a valid Lua identifier.", compile_error(\$var,
"This should probably be a variable.") "This is supposed to be something that compiles to a valid Lua identifier.",
end "This should probably be a variable.")
return lua end
") return lua
")
test: test:
(num args (*extra arguments*)) means (select "#" (*extra arguments*)) (num args (*extra arguments*)) means (select "#" (*extra arguments*))
@ -312,11 +327,10 @@ test:
assume (third arg 5 6 7 8) == 7 assume (third arg 5 6 7 8) == 7
(*extra arguments*) compiles to "..." (*extra arguments*) compiles to "..."
($ is syntax tree) compiles to "SyntaxTree:is_instance(\($ as lua expr))" ($ is syntax tree) compiles to "SyntaxTree:is_instance(\($ as lua expr))"
external:
externally ($ is $kind syntax tree) means ($ is $kind syntax tree) means
=lua "SyntaxTree:is_instance(\$) and \$.type == \$kind" =lua "SyntaxTree:is_instance(\$) and \$.type == \$kind"
($tree with $t -> $replacement) compiles to (" ($tree with $t -> $replacement) compiles to ("
\($tree as lua expr):map(function(\($t as lua expr)) \($tree as lua expr):map(function(\($t as lua expr))
@ -329,14 +343,15 @@ externally ($ is $kind syntax tree) means
end) end)
") ")
externally ($tree with vars $replacements) means external:
=lua (" ($tree with vars $replacements) means
\$tree:map(function(\$t) =lua ("
if \$t.type == "Var" then \$tree:map(function(\$t)
return \$replacements[\$t:as_var()] if \$t.type == "Var" then
end return \$replacements[\$t:as_var()]
end) end
") end)
")
(tree $tree with vars $replacements) compiles to (" (tree $tree with vars $replacements) compiles to ("
\(=lua "(\$tree):as_lua()"):map(function(t) \(=lua "(\$tree):as_lua()"):map(function(t)
@ -355,24 +370,25 @@ externally ($tree with vars $replacements) means
end)() end)()
") ")
externally (match $tree with $patt) means: external:
lua> (" (match $tree with $patt) means:
if \$patt.type == "Var" then return Dict{[\$patt:as_var()]=\$tree} end lua> ("
if \$patt.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end if \$patt.type == "Var" then return Dict{[\$patt:as_var()]=\$tree} end
if #\$patt ~= #\$tree then return nil end if \$patt.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end
local matches = Dict{} if #\$patt ~= #\$tree then return nil end
for \($i)=1,#\$patt do local matches = Dict{}
if SyntaxTree:is_instance(\$tree[\$i]) then for \($i)=1,#\$patt do
local submatch = \(match $tree.$i with $patt.$i) if SyntaxTree:is_instance(\$tree[\$i]) then
if not submatch then return nil end local submatch = \(match $tree.$i with $patt.$i)
for k,v in pairs(submatch) do if not submatch then return nil end
if matches[k] and matches[k] ~= v then return nil end for k,v in pairs(submatch) do
matches[k] = v if matches[k] and matches[k] ~= v then return nil end
matches[k] = v
end
end end
end end
end return matches
return matches ")
")
test: test:
assume assume
@ -390,20 +406,20 @@ test:
assume ({} is a "Dict") assume ({} is a "Dict")
assume ("" is text) assume ("" is text)
assume ("" isn't a "Dict") assume ("" isn't a "Dict")
externally ($ is text) means (=lua "\(lua type of $) == 'string'")
externally [$ is not text, $ isn't text] all mean
=lua "\(lua type of $) ~= 'string'"
externally (type of $) means: external:
lua> (" ($ is text) means (=lua "\(lua type of $) == 'string'")
local lua_type = \(lua type of $) [$ is not text, $ isn't text] all mean (=lua "\(lua type of $) ~= 'string'")
if lua_type == 'string' then return 'Text' (type of $) means:
elseif lua_type == 'table' or lua_type == 'userdata' then lua> ("
local mt = getmetatable(\$) local lua_type = \(lua type of $)
if mt and mt.__type then return mt.__type end if lua_type == 'string' then return 'Text'
end elseif lua_type == 'table' or lua_type == 'userdata' then
return lua_type local mt = getmetatable(\$)
") if mt and mt.__type then return mt.__type end
end
return lua_type
")
[$ is a $type, $ is an $type] all parse as ((type of $) == $type) [$ is a $type, $ is an $type] all parse as ((type of $) == $type)
[$ isn't a $type, $ isn't an $type, $ is not a $type, $ is not an $type] [$ isn't a $type, $ isn't an $type, $ is not a $type, $ is not an $type]
@ -441,19 +457,24 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# test:
(with local compile actions $body) compiles to (" using compile rules:
do (yes) compiles to "3"
local OLD_RULES = COMPILE_RULES assume $(COMPILE RULES).yes
local OLD_ENV = \(nomsu environment) ..do:
local \(nomsu environment) = setmetatable({ assume (yes) == 3
COMPILE_RULES=setmetatable({}, {__index=OLD_RULES}) assume (yes) == (=lua "true")
}, {__index=OLD_ENV})
\($body as lua) (using compile rules $rules do $body) compiles to:
end lua> ("
local env = \(new environment)
env:run(\$rules)
local lua = env:compile(\$body)
return lua
") ")
externally (Nomsu version) means: external:
return (" (Nomsu version) means:
\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version) return ("
") \(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
")

33
lib/core/operators.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains definitions of operators like "+" and "and". This file contains definitions of operators like "+" and "and".
@ -77,34 +77,6 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
[$foozle, $y] = ["outer", "outer"]
externally (set global x local y) means:
external $foozle = "inner"
$y = "inner"
set global x local y
unless (($foozle == "inner") and ($y == "outer")): fail "external failed."
(external $var = $value) compiles to:
$lua = ((SyntaxTree {.type = "Action", .source = $var.source} $var "=" $value) as lua)
$lua, remove free vars
return $lua
test:
[$foozle, $y] = ["outer", "outer"]
externally (set global x local y) means:
with external [$foozle]:
$foozle = "inner"
$y = "inner"
set global x local y
unless (($foozle == "inner") and ($y == "outer")):
fail "'with external' failed."
(with external $externs $body) compiles to:
$body_lua = ($body as lua)
lua> ("
\$body_lua:remove_free_vars(table.map(\$externs, function(v) return \(nomsu environment):compile(v):text() end))
")
return $body_lua
test: test:
[$x, $y] = [1, 2] [$x, $y] = [1, 2]
with [$z, $x = 999]: with [$z, $x = 999]:
@ -156,7 +128,8 @@ test:
test: test:
$calls = 0 $calls = 0
(one) means: (one) means:
external $calls = ($calls + 1) external:
$calls = ($calls + 1)
return 1 return 1
unless (0 <= (one) <= 2): unless (0 <= (one) <= 2):

19
lib/core/text.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains some definitions of text escape sequences, including ANSI console This file contains some definitions of text escape sequences, including ANSI console
color codes. color codes.
@ -34,7 +34,6 @@ test:
"), lines "), lines
..== ["one", "two", ""] ..== ["one", "two", ""]
($spec とは $body) parses as ($spec means $body) ($spec とは $body) parses as ($spec means $body)
test: test:
@ -61,16 +60,18 @@ test:
test: test:
assume (0xDEADBEEF as hex) == "0xDEADBEEF" assume (0xDEADBEEF as hex) == "0xDEADBEEF"
externally ($num as hex) means: external:
if ($num < 0): ($num as hex) means:
return ("-0x%X", formatted with (- $num)) if ($num < 0):
..else: return ("-0x%X", formatted with (- $num))
return ("0x%X", formatted with $num) ..else:
return ("0x%X", formatted with $num)
# Text literals # Text literals
$escapes = { $escapes = {
.nl = "\n", .newline = "\n", .tab = "\t", .bell = "\a", .cr = "\r", ."carriage return" = "\r" .nl = "\n", .newline = "\n", .tab = "\t", .bell = "\a", .cr = "\r"
.backspace = "\b", ."form feed" = "\f", .formfeed = "\f", ."vertical tab" = "\v" ."carriage return" = "\r", .backspace = "\b", ."form feed" = "\f"
.formfeed = "\f", ."vertical tab" = "\v"
} }
for $name = $str in $escapes: for $name = $str in $escapes:

40
lib/file_hash/init.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines some actions for hashing files and looking up files by hash. This file defines some actions for hashing files and looking up files by hash.
@ -32,9 +32,10 @@ test:
assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=") assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
if $use_sha1: if $use_sha1:
externally (hash $) means: external:
$hash = (=lua "\$hashlib.new('sha1'):final(\$)") (hash $) means:
return (base64 $hash) $hash = (=lua "\$hashlib.new('sha1'):final(\$)")
return (base64 $hash)
..else: ..else:
# TODO: remove warning? # TODO: remove warning?
say (" say ("
@ -42,19 +43,20 @@ if $use_sha1:
..hash function.\027[0m ..hash function.\027[0m
") ")
externally (hash $) means: external:
$bytes = ($, bytes) (hash $) means:
$hash = ($bytes.1 << 7) $bytes = ($, bytes)
for $i in 2 to (size of $bytes): $hash = ($bytes.1 << 7)
$hash = ((1000003 * $hash) ~ $bytes.$i) for $i in 2 to (size of $bytes):
$hash = ($hash ~ (size of $bytes)) $hash = ((1000003 * $hash) ~ $bytes.$i)
return "\$hash" $hash = ($hash ~ (size of $bytes))
return "\$hash"
externally (file with hash $hash) means: external:
for $filename in (files for "."): (file with hash $hash) means:
$contents = (read file $filename) for $filename in (files for "."):
$file_hash = (hash $contents) $contents = (read file $filename)
if ($file_hash == $hash): $file_hash = (hash $contents)
return $filename if ($file_hash == $hash):
return $filename
(hash of file $filename) parses as (hash (read file $filename)) (hash of file $filename) parses as (hash (read file $filename))

60
lib/filesystem/init.nom
View File

@ -1,36 +1,36 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines some actions that interact with the filesystem. This file defines some actions that interact with the filesystem.
externally (files for $path) means: external:
$files = (=lua "Files.list(\$path)") (files for $path) means:
if $files: $files = (=lua "Files.list(\$path)")
$files = (List $files) if $files:
return $files $files = (List $files)
return $files
$(read file $filename) = $Files.read
[
write to file $filename $text, to file $filename write $text
write $text to file $filename
] all mean:
unless ($filename != "stdin"):
fail "Cannot write to stdin"
external $(read file $filename) = $Files.read lua> ("
externally [ local file = io.open(\$filename, 'w')
write to file $filename $text, to file $filename write $text file:write(\$text)
write $text to file $filename file:close()
] all mean: ")
unless ($filename != "stdin"):
fail "Cannot write to stdin"
lua> (" (source lines of $tree) means:
local file = io.open(\$filename, 'w') $source = ($tree.source if ($tree is syntax tree) else $tree)
file:write(\$text) $file = (read file $source.filename)
file:close() return
") [
: for $ in ($file, line number at $source.start) to
$file, line number at $source.stop
..: add ($file, line $)
], joined with "\n"
externally (source lines of $tree) means: $(spoof file $text) = $Files.spoof
$source = ($tree.source if ($tree is syntax tree) else $tree) $(spoof file $filename = $text) = $Files.spoof
$file = (read file $source.filename)
return
[
: for $ in ($file, line number at $source.start) to
$file, line number at $source.stop
..: add ($file, line $)
], joined with "\n"
external $(spoof file $text) = $Files.spoof
external $(spoof file $filename = $text) = $Files.spoof

2
lib/object.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file contains the implementation of an Object-Oriented programming system. This file contains the implementation of an Object-Oriented programming system.

24
lib/progressbar/init.nom
View File

@ -1,16 +1,12 @@
#!/usr/bin/env nomsu -V6.15.13.8
# A progress bar # A progress bar
externally ($x / $w progress bar) means: external:
$x = ($x clamped between 0 and $w) ($x / $w progress bar) means:
$bits = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"] $x = ($x clamped between 0 and $w)
$middle = $bits = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"]
"" if ($x == $w) else $middle = ("" if ($x == $w) else $bits.(1 + (floor ((#$bits) * ($x mod 1)))))
$bits.(1 + (floor ((#$bits) * ($x mod 1)))) return ("
\027[32;40m\($bits, last, rep (floor $x))\$middle\(" ", rep ($w - ((floor $x) + 1)))\027[0m
return (" ")
\027[32;40m\($bits, last, rep (floor $x))\$middle\ ($w wide $ progress bar) means (($ * $w) / $w progress bar)
..\(" ", rep ($w - ((floor $x) + 1)))\027[0m
")
externally ($w wide $ progress bar) means
($ * $w) / $w progress bar

18
lib/shell/init.nom
View File

@ -1,12 +1,12 @@
# #
This file defines some actions for running shell commands. This file defines some actions for running shell commands.
externally (=sh $cmd) means: external:
lua> (" (=sh $cmd) means:
local result = io.popen(\$cmd) lua> ("
local contents = result:read("*a") local result = io.popen(\$cmd)
result:close() local contents = result:read("*a")
return contents result:close()
") return contents
")
external $(sh> $) = $os.execute $(sh> $) = $os.execute

121
lib/things.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
A library for simple object oriented programming. A library for simple object oriented programming.
@ -91,67 +91,70 @@ $METAMETHOD_MAP = {
} }
$($ as text like a dict) = ({}'s metatable).__tostring $($ as text like a dict) = ({}'s metatable).__tostring
externally (a class named $classname with $members $(initialize $)) means: external:
$class = {.__type = $classname} (a class named $classname with $members $(initialize $)) means:
$class.__index = $class $class = {.__type = $classname}
$class.class = $class $class.__index = $class
$class.__tostring = ($ -> "\($.__type) \($ as text like a dict)") $class.class = $class
$class.__eq = ({}'s metatable).__eq $class.__tostring = ($ -> "\($.__type) \($ as text like a dict)")
$class.__len = ({}'s metatable).__len $class.__eq = ({}'s metatable).__eq
if $members: $class.__len = ({}'s metatable).__len
$class.__members = $members if $members:
$class.__newindex = $class.__members = $members
for ($its $key = $value): $class.__newindex =
if $members.$key: for ($its $key = $value):
rawset $its $key $value if $members.$key:
..else: rawset $its $key $value
fail "Cannot set \$key, it's not one of the allowed member fields." ..else:
fail "Cannot set \$key, it's not one of the allowed member fields."
set $class's metatable to { set $class's metatable to {
.__tostring = ($class -> $class.__type) .__tostring = ($class -> $class.__type)
.__call = .__call =
for ($class with $initial_values): for ($class with $initial_values):
if ($initial_values == (nil)): return $class if ($initial_values == (nil)): return $class
set $initial_values's metatable to $class set $initial_values's metatable to $class
if $initial_values.set_up: if $initial_values.set_up:
$initial_values, set up $initial_values, set up
return $initial_values return $initial_values
} }
if $(initialize $): if $(initialize $):
initialize $class initialize $class
for $stub = $metamethod in $METAMETHOD_MAP: for $stub = $metamethod in $METAMETHOD_MAP:
if $class.($stub, as lua id): if $class.($stub, as lua id):
$class.$metamethod = $class.($stub, as lua id) $class.$metamethod = $class.($stub, as lua id)
return $class return $class
[ [
a $classname is a thing with $members $class_body a $classname is a thing with $members $class_body
an $classname is a thing with $members $class_body an $classname is a thing with $members $class_body
] all compile to: ] all compile to:
$class_id = ($classname.stub, as lua id) $class_id = ($classname.stub, as lua id)
if $class_body: if $class_body:
$body_lua = ($class_body as lua) $body_lua = ($class_body as lua)
$body_lua, remove free vars [$class_id] $body_lua, remove free vars [$class_id]
$body_lua, declare locals $body_lua, declare locals
return $lua =
Lua (" Lua ("
\$class_id = a_class_named_1_with(\(quote $classname.stub), \($members as lua)\( \$class_id = a_class_named_1_with(\(quote $classname.stub), \($members as lua)\(
( (
Lua (" Lua ("
, function(\$class_id) , function(\$class_id)
local it, its = \$class_id, \$class_id; local it, its = \$class_id, \$class_id;
\$body_lua \$body_lua
end end
") ")
) if $class_body else "" ) if $class_body else ""
)) ))
a_\$class_id = function(initial_values) return \($classname.stub, as lua id)(initial_values \ a_\$class_id = function(initial_values) return \($classname.stub, as lua id)(initial_values or {}) end
..or {}) end an_\$class_id, a_\($class_id)_with, an_\($class_id)_with = a_\$class_id, a_\$class_id, a_\$class_id
an_\$class_id, a_\($class_id)_with, an_\($class_id)_with = a_\$class_id, a_\$class_id, a_\$class_id ")
")
[a $classname is a thing $class_body, an $classname is a thing] all parse as $lua, add free vars [$class_id, "a_\$class_id", "an_\$class_id"]
a $classname is a thing with (nil) $class_body return $lua
[a $classname is a thing $class_body, an $classname is a thing] all parse as
a $classname is a thing with (nil) $class_body

8
lib/tools/find.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This is a tool to find syntax trees matching a pattern. "*" is a wildcard This is a tool to find syntax trees matching a pattern. "*" is a wildcard
that will match any subtree, and "**" is a wildcard that will match any that will match any subtree, and "**" is a wildcard that will match any
@ -79,7 +79,11 @@ command line program with $args:
if ($t matches $pattern_tree): if ($t matches $pattern_tree):
$line_num = ($file, line number at $t.source.start) $line_num = ($file, line number at $t.source.start)
$results, add { $results, add {
.line = $line_num, .text = "\(blue "\$filename:\$line_num:")\n\(source lines of $t)" .line = $line_num
.text = ("
\(blue "\$filename:\$line_num:")
\(source lines of $t)
")
} }
for $sub in $t: for $sub in $t:

2
lib/tools/format.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
Auto-format Nomsu code. Usage: Auto-format Nomsu code. Usage:
nomsu -t format [-i] file1 file2... nomsu -t format [-i] file1 file2...

4
lib/tools/parse.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
Tool to print out a parse tree of files in an easy-to-read format. Usage: Tool to print out a parse tree of files in an easy-to-read format. Usage:
nomsu tools/parse.nom file1 file2 directory1 ... nomsu tools/parse.nom file1 file2 directory1 ...
@ -8,7 +8,7 @@ use "commandline"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
externally (print tree $t at indent $indent) means: (print tree $t at indent $indent) means:
if $t.type is: if $t.type is:
"Action": "Action":
say "\($indent)Action (\($t.stub)):" say "\($indent)Action (\($t.stub)):"

17
lib/tools/repl.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This file defines a Read-Evaluate-Print-Loop (REPL) for Nomsu This file defines a Read-Evaluate-Print-Loop (REPL) for Nomsu
@ -8,12 +8,13 @@ use "commandline"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
externally (help) means: external:
say (" (help) means:
This is the Nomsu v\(Nomsu version) interactive console. say ("
You can type in Nomsu code here and hit 'enter' twice to run it. This is the Nomsu v\(Nomsu version) interactive console.
To exit, type 'exit' or 'quit' and hit enter twice. You can type in Nomsu code here and hit 'enter' twice to run it.
") To exit, type 'exit' or 'quit' and hit enter twice.
")
command line program with $args: command line program with $args:
say (" say ("
@ -38,9 +39,7 @@ command line program with $args:
go to (run buffer) go to (run buffer)
$buff, add ($line, with "\t" -> " ") $buff, add ($line, with "\t" -> " ")
say (dim (yellow ".. ")) inline say (dim (yellow ".. ")) inline
--- (run buffer) --- --- (run buffer) ---
if ((size of $buff) == 0): stop if ((size of $buff) == 0): stop
$buff = ($buff, joined) $buff = ($buff, joined)
spoof file $buff spoof file $buff

8
lib/tools/replace.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
This is a tool to replace syntax trees with something new. This is a tool to replace syntax trees with something new.
@ -95,7 +95,8 @@ command line program with $args:
$tree = ($code parsed) $tree = ($code parsed)
..if it fails with $msg: ..if it fails with $msg:
if $args.q: if $args.q:
unless $args.i: say $code unless $args.i:
say $code
..else: ..else:
say $msg say $msg
@ -124,13 +125,10 @@ command line program with $args:
..\(reset color) ..\(reset color)
") ")
say "\(bright)..be replaced with:" say "\(bright)..be replaced with:"
say (" say ("
\(bright)\(blue)\("\($ret as nomsu)", with "\n" -> "\n ")\(reset color) \(bright)\(blue)\("\($ret as nomsu)", with "\n" -> "\n ")\(reset color)
") ")
$user_answers.$t = (ask "\(bright)..? [Y/n]\(reset color) ") $user_answers.$t = (ask "\(bright)..? [Y/n]\(reset color) ")
if ($user_answers.$t == "n"): return (nil) if ($user_answers.$t == "n"): return (nil)
$replaced.$t = (yes) $replaced.$t = (yes)
return $ret return $ret

14
lib/tools/test.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
Tool to run all tests in a file (i.e. the code block inside a call to 'test $'). Usage: Tool to run all tests in a file (i.e. the code block inside a call to 'test $'). Usage:
nomsu tools/test.nom file1 file2 directory1 ... nomsu tools/test.nom file1 file2 directory1 ...
@ -14,7 +14,6 @@ command line program with $args:
$file = (read file $filename) $file = (read file $filename)
unless $file: unless $file:
fail "Couldn't find \$filename" fail "Couldn't find \$filename"
$(test environment) = (new environment) $(test environment) = (new environment)
$(test environment), export $filename $(test environment), export $filename
$version = $version =
@ -24,7 +23,7 @@ command line program with $args:
]*) ]*)
") ")
$file_tests = [] $file_tests = []
for $src = $test in $(test environment).TESTS: for $src = $test in (nomsu environment, Module $filename).TESTS:
if $version: if $version:
$test = (" $test = ("
#!/usr/bin/env nomsu -V\$version #!/usr/bin/env nomsu -V\$version
@ -36,20 +35,22 @@ command line program with $args:
sort $file_tests by $ -> $.source sort $file_tests by $ -> $.source
say "[ .. ] \$filename" inline say "[ .. ] \$filename" inline
$io.flush() $io.flush()
if $args.v: say "" if $args.v: say ""
$failures = [] $failures = []
for $ in $file_tests: for $ in $file_tests:
if $args.v: if $args.v:
say " \(yellow ($.test, with "\n" -> "\n "))" say " \(yellow ($.test, with "\n" -> "\n "))"
try: try:
$(test environment), run $.test $(test environment), run $.test
..if it fails with $msg: ..if it fails with $msg:
$src = ($Source, from string $.source) $src = ($Source, from string $.source)
$l1 = ($file, line number at $src.start) $l1 = ($file, line number at $src.start)
$l2 = ($file, line number at $src.stop) $l2 = ($file, line number at $src.stop)
$failures, add "\(yellow "\($src.filename):\($l1)-\$l2:")\n\(bright (red ($msg, indented)))" $failures, add ("
\(yellow "\($src.filename):\($l1)-\$l2:")
\(bright (red ($msg, indented)))
")
if ($failures is empty): if ($failures is empty):
if $args.v: if $args.v:
@ -62,4 +63,3 @@ command line program with $args:
..else: ..else:
say "\r[\(red (bright "FAIL"))" say "\r[\(red (bright "FAIL"))"
say "\($failures, joined with "\n", indented)" say "\($failures, joined with "\n", indented)"

2
lib/tools/upgrade.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V6.14 #!/usr/bin/env nomsu -V6.15.13.8
# #
Tool to automatically update code from old versions of Nomsu. Usage: Tool to automatically update code from old versions of Nomsu. Usage:
nomsu tools/upgrade.nom [-i] file1 file2 directory1 ... nomsu tools/upgrade.nom [-i] file1 file2 directory1 ...

6
nomsu.lua
View File

@ -131,6 +131,7 @@ local NOMSU_PACKAGEPATH = NOMSU_PACKAGEPATH or "/opt/nomsu"
add_path(NOMSU_PACKAGEPATH) add_path(NOMSU_PACKAGEPATH)
add_path(".") add_path(".")
package.nomsupath = table.concat(nomsupath, ";") package.nomsupath = table.concat(nomsupath, ";")
package.nomsuloaded = Dict({ })
local nomsu_environment = require('nomsu_environment') local nomsu_environment = require('nomsu_environment')
nomsu_environment.COMMAND_LINE_ARGS = nomsu_args nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
nomsu_environment.OPTIMIZATION = optimization nomsu_environment.OPTIMIZATION = optimization
@ -173,6 +174,10 @@ run = function()
nomsu_environment._1_parsed(NomsuCode:from(source, code)) nomsu_environment._1_parsed(NomsuCode:from(source, code))
print("Parse succeeded: " .. tostring(filename)) print("Parse succeeded: " .. tostring(filename))
elseif args.compile then elseif args.compile then
local code = Files.read(filename)
if not code then
error("Could not find file '" .. tostring(filename) .. "'")
end
if filename:match("%.lua$") then if filename:match("%.lua$") then
error("Cannot compile a lua file (expected a nomsu file as input)") error("Cannot compile a lua file (expected a nomsu file as input)")
end end
@ -182,7 +187,6 @@ run = function()
else else
output = io.open(filename:gsub("%.nom$", ".lua"), "w") output = io.open(filename:gsub("%.nom$", ".lua"), "w")
end end
local code = Files.read(filename)
local source = Source(filename, 1, #code) local source = Source(filename, 1, #code)
code = NomsuCode:from(source, code) code = NomsuCode:from(source, code)
local env = nomsu_environment.new_environment() local env = nomsu_environment.new_environment()

5
nomsu.moon
View File

@ -108,6 +108,7 @@ NOMSU_PACKAGEPATH or= "/opt/nomsu"
add_path NOMSU_PACKAGEPATH add_path NOMSU_PACKAGEPATH
add_path "." add_path "."
package.nomsupath = table.concat(nomsupath, ";") package.nomsupath = table.concat(nomsupath, ";")
package.nomsuloaded = Dict{}
nomsu_environment = require('nomsu_environment') nomsu_environment = require('nomsu_environment')
nomsu_environment.COMMAND_LINE_ARGS = nomsu_args nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
@ -141,12 +142,14 @@ run = ->
nomsu_environment._1_parsed(NomsuCode\from(source, code)) nomsu_environment._1_parsed(NomsuCode\from(source, code))
print("Parse succeeded: #{filename}") print("Parse succeeded: #{filename}")
elseif args.compile elseif args.compile
code = Files.read(filename)
if not code
error("Could not find file '#{filename}'")
-- Compile .nom files into .lua -- Compile .nom files into .lua
if filename\match("%.lua$") if filename\match("%.lua$")
error("Cannot compile a lua file (expected a nomsu file as input)") error("Cannot compile a lua file (expected a nomsu file as input)")
output = if filename == 'stdin' then io.output() output = if filename == 'stdin' then io.output()
else io.open(filename\gsub("%.nom$", ".lua"), "w") else io.open(filename\gsub("%.nom$", ".lua"), "w")
code = Files.read(filename)
source = Source(filename, 1, #code) source = Source(filename, 1, #code)
code = NomsuCode\from(source, code) code = NomsuCode\from(source, code)
env = nomsu_environment.new_environment! env = nomsu_environment.new_environment!

8
nomsu_decompiler.lua
View File

@ -193,7 +193,7 @@ tree_to_inline_nomsu = function(tree)
local target = tree[1] local target = tree[1]
local target_nomsu = tree_to_inline_nomsu(target) local target_nomsu = tree_to_inline_nomsu(target)
local _exp_1 = target.type local _exp_1 = target.type
if "Action" == _exp_1 or "MethodCall" == _exp_1 then if "Action" == _exp_1 or "MethodCall" == _exp_1 or "EscapedNomsu" == _exp_1 then
target_nomsu:parenthesize() target_nomsu:parenthesize()
elseif "Number" == _exp_1 then elseif "Number" == _exp_1 then
if target_nomsu:text():match("%.") then if target_nomsu:text():match("%.") then
@ -498,10 +498,10 @@ tree_to_nomsu = function(tree)
while #line > 0 do while #line > 0 do
local space = max_line - nomsu:trailing_line_len() local space = max_line - nomsu:trailing_line_len()
local split = find(line, "[%p%s]", space) local split = find(line, "[%p%s]", space)
if not split or split > space + 10 then if not split or split > space + 16 then
split = space + 10 split = space + 16
end end
if #line - split < 10 then if #line - split < 16 then
split = #line split = #line
end end
local bite local bite

8
nomsu_decompiler.moon
View File

@ -147,7 +147,7 @@ tree_to_inline_nomsu = (tree)->
target = tree[1] target = tree[1]
target_nomsu = tree_to_inline_nomsu(target) target_nomsu = tree_to_inline_nomsu(target)
switch target.type switch target.type
when "Action", "MethodCall" when "Action", "MethodCall", "EscapedNomsu"
target_nomsu\parenthesize! target_nomsu\parenthesize!
when "Number" when "Number"
target_nomsu\parenthesize! if target_nomsu\text!\match("%.") target_nomsu\parenthesize! if target_nomsu\text!\match("%.")
@ -381,9 +381,9 @@ tree_to_nomsu = (tree)->
while #line > 0 while #line > 0
space = max_line - nomsu\trailing_line_len! space = max_line - nomsu\trailing_line_len!
split = find(line, "[%p%s]", space) split = find(line, "[%p%s]", space)
if not split or split > space + 10 if not split or split > space + 16
split = space + 10 split = space + 16
if #line - split < 10 if #line - split < 16
split = #line split = #line
bite, line = sub(line, 1, split), sub(line, split+1, -1) bite, line = sub(line, 1, split), sub(line, split+1, -1)
nomsu\add bite nomsu\add bite

18
nomsu_environment.lua
View File

@ -99,7 +99,6 @@ nomsu_environment = Importer({
tostring = tostring, tostring = tostring,
string = string, string = string,
xpcall = xpcall, xpcall = xpcall,
module = module,
say = print, say = print,
loadfile = loadfile, loadfile = loadfile,
rawset = rawset, rawset = rawset,
@ -215,7 +214,7 @@ nomsu_environment = Importer({
end end
return tree return tree
end, end,
load_module = function(self, package_name) Module = function(self, package_name)
local path local path
if package_name:match("%.nom$") or package_name:match("%.lua") then if package_name:match("%.nom$") or package_name:match("%.lua") then
path = package_name path = package_name
@ -228,7 +227,7 @@ nomsu_environment = Importer({
end end
path = path:gsub("^%./", "") path = path:gsub("^%./", "")
do do
local ret = package.loaded[package_name] or package.loaded[path] local ret = package.nomsuloaded[package_name] or package.nomsuloaded[path]
if ret then if ret then
return ret return ret
end end
@ -250,12 +249,12 @@ nomsu_environment = Importer({
_currently_running_files:add(path) _currently_running_files:add(path)
mod:run(code) mod:run(code)
_currently_running_files:pop() _currently_running_files:pop()
package.loaded[package_name] = mod package.nomsuloaded[package_name] = mod
package.loaded[path] = mod package.nomsuloaded[path] = mod
return mod return mod
end, end,
use = function(self, package_name) use = function(self, package_name)
local mod = self:load_module(package_name) local mod = self:Module(package_name)
local imports = assert(_module_imports[self]) local imports = assert(_module_imports[self])
for k, v in pairs(mod) do for k, v in pairs(mod) do
imports[k] = v imports[k] = v
@ -267,7 +266,7 @@ nomsu_environment = Importer({
return mod return mod
end, end,
export = function(self, package_name) export = function(self, package_name)
local mod = self:load_module(package_name) local mod = self:Module(package_name)
local imports = assert(_module_imports[self]) local imports = assert(_module_imports[self])
for k, v in pairs(_module_imports[mod]) do for k, v in pairs(_module_imports[mod]) do
if rawget(imports, k) == nil then if rawget(imports, k) == nil then
@ -290,11 +289,6 @@ nomsu_environment = Importer({
self.COMPILE_RULES[k] = v self.COMPILE_RULES[k] = v
end end
end end
for k, v in pairs(mod.TESTS) do
if rawget(self.TESTS, k) == nil then
self.TESTS[k] = v
end
end
return mod return mod
end, end,
run = function(self, to_run) run = function(self, to_run)

20
nomsu_environment.moon
View File

@ -48,7 +48,7 @@ nomsu_environment = Importer{
:next, unpack: unpack or table.unpack, :setmetatable, :rawequal, :getmetatable, :pcall, :next, unpack: unpack or table.unpack, :setmetatable, :rawequal, :getmetatable, :pcall,
yield:coroutine.yield, resume:coroutine.resume, coroutine_status_of:coroutine.status, yield:coroutine.yield, resume:coroutine.resume, coroutine_status_of:coroutine.status,
coroutine_wrap:coroutine.wrap, coroutine_from: coroutine.create, coroutine_wrap:coroutine.wrap, coroutine_from: coroutine.create,
:error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module, :error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall,
say:print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen, say:print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :rawlen,
:table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load, :table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load,
:pairs, :ipairs, :jit, :_VERSION :pairs, :ipairs, :jit, :_VERSION
@ -105,7 +105,7 @@ nomsu_environment = Importer{
return tree return tree
load_module: (package_name)=> Module: (package_name)=>
local path local path
if package_name\match("%.nom$") or package_name\match("%.lua") if package_name\match("%.nom$") or package_name\match("%.lua")
path = package_name path = package_name
@ -114,7 +114,7 @@ nomsu_environment = Importer{
if not path then error(err) if not path then error(err)
path = path\gsub("^%./", "") path = path\gsub("^%./", "")
if ret = package.loaded[package_name] or package.loaded[path] if ret = package.nomsuloaded[package_name] or package.nomsuloaded[path]
return ret return ret
if _currently_running_files\has(path) if _currently_running_files\has(path)
@ -132,12 +132,12 @@ nomsu_environment = Importer{
_currently_running_files\add path _currently_running_files\add path
mod\run(code) mod\run(code)
_currently_running_files\pop! _currently_running_files\pop!
package.loaded[package_name] = mod package.nomsuloaded[package_name] = mod
package.loaded[path] = mod package.nomsuloaded[path] = mod
return mod return mod
use: (package_name)=> use: (package_name)=>
mod = @load_module(package_name) mod = @Module(package_name)
imports = assert _module_imports[@] imports = assert _module_imports[@]
for k,v in pairs(mod) for k,v in pairs(mod)
imports[k] = v imports[k] = v
@ -147,7 +147,7 @@ nomsu_environment = Importer{
return mod return mod
export: (package_name)=> export: (package_name)=>
mod = @load_module(package_name) mod = @Module(package_name)
imports = assert _module_imports[@] imports = assert _module_imports[@]
for k,v in pairs(_module_imports[mod]) for k,v in pairs(_module_imports[mod])
if rawget(imports, k) == nil if rawget(imports, k) == nil
@ -163,9 +163,9 @@ nomsu_environment = Importer{
for k,v in pairs(mod.COMPILE_RULES) for k,v in pairs(mod.COMPILE_RULES)
if rawget(@COMPILE_RULES, k) == nil if rawget(@COMPILE_RULES, k) == nil
@COMPILE_RULES[k] = v @COMPILE_RULES[k] = v
for k,v in pairs(mod.TESTS) --for k,v in pairs(mod.TESTS)
if rawget(@TESTS, k) == nil -- if rawget(@TESTS, k) == nil
@TESTS[k] = v -- @TESTS[k] = v
return mod return mod
run: (to_run)=> run: (to_run)=>

2
parser.lua
View File

@ -96,7 +96,7 @@ make_parser = function(peg, make_tree)
file = input file = input
} }
local tree = peg:match(input, nil, userdata) local tree = peg:match(input, nil, userdata)
if not tree then if not tree or type(tree) == 'number' then
error("File " .. tostring(filename) .. " failed to parse:\n" .. tostring(input)) error("File " .. tostring(filename) .. " failed to parse:\n" .. tostring(input))
end end
return tree return tree

2
parser.moon
View File

@ -74,7 +74,7 @@ make_parser = (peg, make_tree=nil)->
:filename, file:input :filename, file:input
} }
tree = peg\match(input, nil, userdata) tree = peg\match(input, nil, userdata)
if not tree if not tree or type(tree) == 'number'
error "File #{filename} failed to parse:\n#{input}" error "File #{filename} failed to parse:\n#{input}"
return tree return tree