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

6
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...
# Write a comment? Put a # and go till the end of the line
# How do I write a multi-line comment?
@ -6,7 +6,7 @@
is considered part of the comment
(including any deeper-level indented text)
The comment ends when the indentation ends
# How do I import a libarary?
use "consolecolor"
@ -247,7 +247,6 @@ say (2 + 3)
# 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"
..and also "short second arg"
(my favorite number) means (21 + 2)
# 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))
# The line above expands to:
say
result of:

1
ldt.lua
View File

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

68
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:
https://tools.ietf.org/html/rfc4648
@ -15,36 +15,36 @@ test:
assume (base64 $plain) == $encoded
assume (base64 decode $encoded) == $plain
externally [base64 $str, base64 encode $str, $str base64] all mean:
$chars = []
for $i in 1 to (size of $str) via 3:
$bytes = [=lua "\$str:byte(\$i, \($i + 2))"]
$chars, add $b64_chars.((($bytes.1 & 252) >> 2) + 1)
if (size of $bytes) is:
3:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
$chars, add $b64_chars.((($bytes.2 & 15) << 2) + (($bytes.3 & 192) >> 6) + 1)
$chars, add $b64_chars.(($bytes.3 & 63) + 1)
2:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
$chars, add $b64_chars.((($bytes.2 & 15) << 2) + 1)
$chars, add "="
1:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + 1)
$chars, add "="
$chars, add "="
return ($chars, joined)
externally (chr $) means (=lua "string.char(\$)")
externally [decode base64 $str, $str base64 decoded, base64 decode $str] all mean:
$chars = []
for $i in 1 to (size of $str) via 4:
$indices = [: for $j in $i to ($i + 3): add $reverse_b64.($str, character $j)]
$chars, add (chr (($indices.1 << 2) + (($indices.2 & 48) >> 4)))
if (($str, character ($i + 2)) == "="): stop
$chars, add (chr ((($indices.2 & 15) << 4) + (($indices.3 & 60) >> 2)))
if (($str, character ($i + 3)) == "="): stop
$chars, add (chr ((($indices.3 & 3) << 6) + $indices.4))
return ($chars, joined)
external:
[base64 $str, base64 encode $str, $str base64] all mean:
$chars = []
for $i in 1 to (size of $str) via 3:
$bytes = [=lua "\$str:byte(\$i, \($i + 2))"]
$chars, add $b64_chars.((($bytes.1 & 252) >> 2) + 1)
if (size of $bytes) is:
3:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
$chars, add $b64_chars.((($bytes.2 & 15) << 2) + (($bytes.3 & 192) >> 6) + 1)
$chars, add $b64_chars.(($bytes.3 & 63) + 1)
2:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + (($bytes.2 & 240) >> 4) + 1)
$chars, add $b64_chars.((($bytes.2 & 15) << 2) + 1)
$chars, add "="
1:
$chars, add $b64_chars.((($bytes.1 & 3) << 4) + 1)
$chars, add "="
$chars, add "="
return ($chars, joined)
(chr $) means (=lua "string.char(\$)")
[decode base64 $str, $str base64 decoded, base64 decode $str] all mean:
$chars = []
for $i in 1 to (size of $str) via 4:
$indices = [: for $j in $i to ($i + 3): add $reverse_b64.($str, character $j)]
$chars, add (chr (($indices.1 << 2) + (($indices.2 & 48) >> 4)))
if (($str, character ($i + 2)) == "="): stop
$chars, add (chr ((($indices.2 & 15) << 4) + (($indices.3 & 60) >> 2)))
if (($str, character ($i + 3)) == "="): stop
$chars, add (chr ((($indices.3 & 3) << 6) + $indices.4))
return ($chars, joined)

19
lib/commandline/init.nom
View File

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

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

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

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

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
@ -24,8 +24,8 @@ upgrade $tree to "2" as:
$need_blocks = [
"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"
"for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with", "result of"
"when"
"for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with"
"result of", "when"
]
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

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
@ -7,7 +7,8 @@ use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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)
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

6
lib/compatibility/3.8.nom
View File

@ -1,11 +1,11 @@
#!/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)
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action [$texts joined with $glue] to "3.8" as ($texts, joined with $glue)
upgrade action [$texts joined, joined $texts] to "3.8" as ($texts, joined)
upgrade action [byte $i of $text] to "3.8" as ($text, byte $i)

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

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
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 return) to "4.10.12.7" as
=lua "\$.type == 'Block' and \($ as lua) or 'return '..\($ as lua expr)"
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 $k = $v in $items) to "4.10.12.7" as
[: 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
(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:
$lhs.$i = $entry.1
$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
for $tree:
@ -93,5 +91,6 @@ upgrade action [
] to "4.11" as (if (not (any of $items)) $body else $else)
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)

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
(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")
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
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
use "compatibility/compatibility"
@ -6,19 +6,15 @@ use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action (size of $) to "5.13" as (#$)
upgrade action "with" to "5.13" via (..)
upgrade action "with" to "5.13" via
for $tree:
$assignments = $tree.2
$body = $tree.3
if ($assignments.type != "Dict"):
return $tree
if ($assignments.type != "Dict"): return $tree
$new_assignments = \[]
for $a in $assignments at $i:
when:
(($a.type == "DictEntry") and ((#$a) == 1)):
$a = $a.1
(all of [$a.type == "DictEntry", (#$a) == 2]):
$a = \($a.1 = $a.2)
(($a.type == "DictEntry") and ((#$a) == 1)): $a = $a.1
(all of [$a.type == "DictEntry", (#$a) == 2]): $a = \($a.1 = $a.2)
$new_assignments.$i = $a
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
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -26,16 +27,12 @@ upgrade action (assume $assumption or barf $err) to "6.14" as
unless $assumption: fail $err
upgrade action (barf $msg) to "6.14" as (fail $msg)
upgrade action (\(1's meaning)).stub to "6.14" via
$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 "use" to "6.14" via
for $tree:
$path = $tree.2.1
$path = ($path, with "%.nom$" -> "")
$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 $
]

233
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
of Nomsu.
@ -8,126 +8,123 @@ use "filesystem"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$UPGRADES = {}
externally (upgrade to $version via $upgrade_fn) means:
$UPGRADES.$version = $upgrade_fn
$ACTION_UPGRADES = ({} with fallback $ -> {})
externally (upgrade action $stub to $version via $upgrade_fn) means:
$ACTION_UPGRADES.$version.$stub = $upgrade_fn
(upgrade $tree to $version as $body) parses as
upgrade to $version via (($ $end_version) -> ($ with $tree -> $body))
(upgrade action $actions to $version as $body) compiles to:
if ($actions is "Action" syntax tree):
$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):
$args = []
for $k = $v in $t:
if ((type of $k) == "number"):
$args, add (make tree $v)
external:
(upgrade to $version via $upgrade_fn) means:
$UPGRADES.$version = $upgrade_fn
(upgrade action $stub to $version via $upgrade_fn) means:
$ACTION_UPGRADES.$version.$stub = $upgrade_fn
(upgrade $tree to $version as $body) parses as
upgrade to $version via (($ $end_version) -> ($ with $tree -> $body))
(upgrade action $actions to $version as $body) compiles to:
if ($actions is "Action" syntax tree):
$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:
$args, add "\($k)=\(make tree $v)"
return "SyntaxTree{\($args, joined with ", ")}"
else:
return (quote $t)
unless ("\$lua" == ""):
$lua, add "\n"
$retval = (make tree $body)
$lua, add
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 [
$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)
for $v = $ in $ACTION_UPGRADES: $versions.$v = (yes)
$versions = [
:for $v = $ in $versions:
if ((Ver $v).lib == $start.lib):
add $v
]
external ($needs_mangle = (yes))
return ("
SyntaxTree{type=\(quote $t.type), source=\(quote "\($t.source)"), \(quote (mangle $t.1))}
")
($t is syntax tree):
$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 ", ")}"
else:
return (quote $t)
unless ("\$lua" == ""):
$lua, add "\n"
$retval = (make tree $body)
$lua, add
Lua ("
upgrade_action_1_to_2_via(\(quote $action.stub), \($version as lua expr), function(\
..\(\$tree as lua id))
return \$retval
end)
")
return $lua
sort $versions by $ -> ($ as list)
for $ver in $versions:
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)
[
$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)
if $UPGRADES.$ver:
$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)
for $v = $ in $ACTION_UPGRADES:
$versions.$v = (yes)
$versions = [: for $v = $ in $versions: if ((Ver $v).lib == $start.lib): add $v]
sort $versions by $ -> ($ as list)
for $ver in $versions:
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)
if $UPGRADES.$ver:
$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 = (SyntaxTree {: for $k = $v in $tree: add $k = $v})
$tree.version = $end_version
if $tree.shebang:
$tree.shebang = "#!/usr/bin/env nomsu -V\$end_version\n"
return $tree
if ($tree.version != $end_version):
$tree = (SyntaxTree {: for $k = $v in $tree: add $k = $v})
$tree.version = $end_version
if $tree.shebang:
$tree.shebang = "#!/usr/bin/env nomsu -V\$end_version\n"
($tree upgraded from $start_version) means
$tree upgraded from $start_version to (Nomsu version)
return $tree
externally ($tree upgraded from $start_version) means
$tree upgraded from $start_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)
($tree upgraded to $end_version) means
$tree upgraded from ($tree.version or (Nomsu version)) to $end_version
($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/2"
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.

62
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
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}) == {.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:
assume ((entries in {.x = 1}) == [{.key = "x", .value = 1}])
@ -118,28 +105,29 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
assume ((sorted [3, 1, 2]) == [1, 2, 3])
externally [$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:
external:
test:
assume ((sorted [3, 1, 2]) == [1, 2, 3])
[$items sorted, sorted $items] all mean:
$copy = [: for $ in $items: add $]
sort $copy by $item = $key
sort $copy
return $copy
test:
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
externally (unique $items) means:
$unique = []
$seen = {}
for $ in $items:
unless $seen.$:
$unique, add $
$seen.$ = (yes)
return $unique
[$items sorted by $item = $key, $items sorted by $item -> $key] all parse as
result of:
$copy = [: for $ in $items: add $]
sort $copy by $item = $key
return $copy
test:
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
(unique $items) means:
$unique = []
$seen = {}
for $ in $items:
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
like "if" statements and loops.
@ -466,6 +466,7 @@ test:
# 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 ("

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

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
@ -23,9 +23,7 @@ use "core/control_flow"
(assume $a == $b) compiles to:
lua> "local \$assumption = 'Assumption failed: '..tostring(\(\($a == $b) as nomsu))"
define mangler
return
Lua ("
do

63
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
@ -33,34 +33,35 @@ set $id_by_obj's metatable to {
return $id
}
externally (uuid) means:
# Set all the other bits to randomly (or pseudo-randomly) chosen values.
$bytes = [
# time-low, time-mid, time-high-and-version
randint (2 ^ (4 * 8)), randint (2 ^ (2 * 8)), randint (2 ^ (2 * 8 - 4))
# clock-seq-and-reserved, clock-seq-low
randint (2 ^ (1 * 8 - 2)), randint (2 ^ (1 * 8)), randint (2 ^ (3 * 8))
# node
randint (2 ^ (3 * 8))
]
external:
(uuid) means:
# Set all the other bits to randomly (or pseudo-randomly) chosen values.
$bytes = [
# time-low, time-mid, time-high-and-version
randint (2 ^ (4 * 8)), randint (2 ^ (2 * 8)), randint (2 ^ (2 * 8 - 4))
# clock-seq-and-reserved, clock-seq-low
randint (2 ^ (1 * 8 - 2)), randint (2 ^ (1 * 8)), randint (2 ^ (3 * 8))
# node
randint (2 ^ (3 * 8))
]
# Set the four most significant bits (bits 12 through 15) of the
# time_hi_and_version field to the 4-bit version number from
# Section 4.1.3.
$bytes.3 += 0x4000
# Set the two most significant bits (bits 6 and 7) of the
# clock_seq_hi_and_reserved to zero and one, respectively.
$bytes.4 += 0xC0
return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\$bytes))")
# Set the four most significant bits (bits 12 through 15) of the
# time_hi_and_version field to the 4-bit version number from
# Section 4.1.3.
$bytes.3 += 0x4000
# Set the two most significant bits (bits 6 and 7) of the
# clock_seq_hi_and_reserved to zero and one, respectively.
$bytes.4 += 0xC0
return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\$bytes))")
# For strict identity checking, use ($x's id) == ($y's id)
test:
assume (([] == []) and ((id of []) != (id of [])))
seed random with 0
$x = []
assume ((id of $x) == (id of $x))
seed random with 0
assume ((id of $x) != (id of []))
seed random
externally [id of $, $'s id, $'id] all mean $id_by_obj.$
# For strict identity checking, use ($x's id) == ($y's id)
test:
assume (([] == []) and ((id of []) != (id of [])))
seed random with 0
$x = []
assume ((id of $x) == (id of $x))
seed random with 0
assume ((id of $x) != (id of []))
seed random
[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 "core/metaprogramming"
export "core/operators"

45
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
@ -6,24 +6,25 @@ use "core/metaprogramming"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(say $message) compiles to:
lua> ("
if \$message.type == "Text" then
return LuaCode("say(", \($message as lua expr), ");");
else
return LuaCode("say(tostring(", \($message as lua expr), "));");
end
")
(say $message inline) compiles to:
lua> ("
if \$message.type == "Text" then
return LuaCode("io.write(", \($message as lua expr), ")");
else
return LuaCode("io.write(tostring(", \($message as lua expr), "))");
end
")
externally (ask $prompt) means:
$io.write $prompt
return ($io.read())
external:
(say $message) compiles to:
lua> ("
if \$message.type == "Text" then
return LuaCode("say(", \($message as lua expr), ");");
else
return LuaCode("say(tostring(", \($message as lua expr), "));");
end
")
(say $message inline) compiles to:
lua> ("
if \$message.type == "Text" then
return LuaCode("io.write(", \($message as lua expr), ")");
else
return LuaCode("io.write(tostring(", \($message as lua expr), "))");
end
")
(ask $prompt) means:
$io.write $prompt
return ($io.read())

392
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
@ -10,203 +10,201 @@ use "core/collections"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Literals:
test:
unless (all of [inf, NaN, pi, tau, golden ratio, e]):
fail "math constants failed"
$nan = (NaN)
unless ($nan != $nan):
fail "NaN failed"
[infinity, inf] all compile to "math.huge"
[not a number, NaN, nan] all compile to "(0/0)"
[pi, Pi, PI] all compile to "math.pi"
[tau, Tau, TAU] all compile to "(2*math.pi)"
(golden ratio) compiles to "((1+math.sqrt(5))/2)"
(e) compiles to "math.exp(1)"
# Functions:
test:
assume (("5" as a number) == 5)
external $($ as a number) = $(tonumber $)
external $($ as number) = $(tonumber $)
test:
unless
all of [
abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5
arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
hyperbolic tangent 5, e^ 5, ln 5, log 5 base 2, floor 5, ceiling 5, round 5
]
..:
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
$rounder * (floor ($n / $rounder + 0.5))
# Any/all
externally [all of $items, all $items] all mean:
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
externally [sum of $items, sum $items] all mean:
$total = 0
for $ in $items:
$total += $
return $total
externally [product of $items, product $items] all mean:
$prod = 1
for $ in $items:
$prod *= $
return $prod
externally [avg of $items, average of $items] all mean
(sum of $items) / (size of $items)
# Min/max
externally [min of $items, smallest of $items, lowest of $items] all mean:
$best = (nil)
for $ in $items:
if (($best == (nil)) or ($ < $best)): $best = $
return $best
externally [
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:
assume ((min of [3, -4, 1, 2] by $ = ($ * $)) == 1)
assume ((max of [3, -4, 1, 2] by $ = ($ * $)) == -4)
(min of $items by $item = $value_expr) parses as
result of:
external:
# Literals:
test:
unless (all of [inf, NaN, pi, tau, golden ratio, e]):
fail "math constants failed"
$nan = (NaN)
unless ($nan != $nan):
fail "NaN failed"
[infinity, inf] all compile to "math.huge"
[not a number, NaN, nan] all compile to "(0/0)"
[pi, Pi, PI] all compile to "math.pi"
[tau, Tau, TAU] all compile to "(2*math.pi)"
(golden ratio) compiles to "((1+math.sqrt(5))/2)"
(e) compiles to "math.exp(1)"
# Functions:
test:
assume (("5" as a number) == 5)
$($ as a number) = $(tonumber $)
$($ as number) = $(tonumber $)
test:
unless
all of [
abs 5, | 5 |, sqrt 5, √ 5, sine 5, cosine 5, tangent 5, arc sine 5, arc cosine 5
arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
hyperbolic tangent 5, e^ 5, ln 5, log 5 base 2, floor 5, ceiling 5, round 5
]
..:
fail "math functions failed"
[$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
[$math.abs, $math.abs, $math.abs, $math.abs]
[$(square root $), $(square root of $), $(√ $), $(sqrt $)] =
[$math.sqrt, $math.sqrt, $math.sqrt, $math.sqrt]
[$(sine $), $(sin $)] = [$math.sin, $math.sin]
[$(cosine $), $(cos $)] = [$math.cos, $math.cos]
[$(tangent $), $(tan $)] = [$math.tan, $math.tan]
[$(arc sine $), $(asin $)] = [$math.asin, $math.asin]
[$(arc cosine $), $(acos $)] = [$math.acos, $math.acos]
[$(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)))
# Any/all
[all of $items, all $items] all mean:
for $ in $items:
unless $:
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))
# Sum/product
[sum of $items, sum $items] all mean:
$total = 0
for $ in $items:
$total += $
return $total
[product of $items, product $items] all mean:
$prod = 1
for $ in $items:
$prod *= $
return $prod
[avg of $items, average of $items] all mean ((sum of $items) / (size of $items))
# Min/max
[min of $items, smallest of $items, lowest of $items] all mean:
$best = (nil)
$best_key = (nil)
for $item in $items:
$key = $value_expr
if (($best == (nil)) or ($key < $best_key)):
$best = $item
$best_key = $key
for $ in $items:
if (($best == (nil)) or ($ < $best)): $best = $
return $best
(max of $items by $item = $value_expr) parses as
result of:
[max of $items, biggest of $items, largest of $items, highest of $items] all mean:
$best = (nil)
$best_key = (nil)
for $item in $items:
$key = $value_expr
if (($best == (nil)) or ($key > $best_key)):
$best = $item
$best_key = $key
for $ in $items:
if (($best == (nil)) or ($ > $best)): $best = $
return $best
test:
assume (100 clamped between 0 and 10) == 10
externally ($ clamped between $min and $max) means:
when:
($ < $min):
return $min
($ > $max):
return $max
else:
return $
test:
assume (-0.1 smoothed by 2.7) == 0
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
externally ($ smoothed by $smoothness) means:
$ = ($ clamped between 0 and 1)
if ($smoothness == 0): return $
$k = (2 ^ $smoothness)
if ($ < 0.5):
return (0.5 * (2 * $) ^ $k)
..else:
return (1 - 0.5 * (2 - 2 * $) ^ $k)
test:
assume (5 to 7 mixed by -1.0) == 5
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:
$ = ($amount clamped between 0 and 1)
return ((1 - $) * $lo + $ * $hi)
test:
assume ([0, 1, 11] mixed by 0.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.0) == 11
assume ([99] mixed by 0.5) == 99
externally ($nums mixed by $amount) means:
$ = ($amount clamped between 0 and 1)
$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
externally (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))"
externally [
random choice from $elements, random choice $elements, random $elements
] all mean (=lua "\$elements[math.random(#\$elements)]")
test:
assume ((min of [3, -4, 1, 2] by $ = ($ * $)) == 1)
assume ((max of [3, -4, 1, 2] by $ = ($ * $)) == -4)
(min of $items by $item = $value_expr) parses as
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
(max of $items by $item = $value_expr) parses as
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
test:
assume (100 clamped between 0 and 10) == 10
($ clamped between $min and $max) means:
when:
($ < $min):
return $min
($ > $max):
return $max
else:
return $
test:
assume (-0.1 smoothed by 2.7) == 0
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
($ smoothed by $smoothness) means:
$ = ($ clamped between 0 and 1)
if ($smoothness == 0): return $
$k = (2 ^ $smoothness)
if ($ < 0.5):
return (0.5 * (2 * $) ^ $k)
..else:
return (1 - 0.5 * (2 - 2 * $) ^ $k)
test:
assume (5 to 7 mixed by -1) == 5
assume (5 to 7 mixed by 0) == 5
assume (5 to 7 mixed by 0.5) == 6
assume (5 to 7 mixed by 1) == 7
assume (5 to 7 mixed by 2) == 7
($lo to $hi mixed by $amount) means:
$ = ($amount clamped between 0 and 1)
return ((1 - $) * $lo + $ * $hi)
test:
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
($nums mixed by $amount) means:
$ = ($amount clamped between 0 and 1)
$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
functions to make that easier.
lua> "NOMSU_CORE_VERSION = 14"
lua> "NOMSU_CORE_VERSION = 15"
lua> "NOMSU_LIB_VERSION = 8"
lua> ("
do
@ -25,8 +25,7 @@ lua> ("
COMPILE_RULES["1 ->"] = function(\(nomsu environment), \$args, \$body)
if \$args and not \$body then \$args, \$body = {}, \$args end
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("\
..return ") end
if SyntaxTree:is_instance(\$body) and \$body.type ~= "Block" then body_lua:prepend("return ") end
local lua = LuaCode("(function(")
if SyntaxTree:is_instance(\$args) and (\$args.type == "Action" or \$args.type == "MethodCall") then
\$args = \$args:get_args()
@ -41,8 +40,7 @@ lua> ("
end
elseif not arg_lua:is_lua_id() then
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 \
..argument.",
"This does not compile to a Lua identifier, so it can't be used as a function argument.",
"This should probably be a Nomsu variable instead (like $x).")
end
lua:add(i > 1 and ", " or "", arg_lua)
@ -186,26 +184,40 @@ test:
")
test:
externally (baz1) means:
return "baz1"
externally (baz2) means "baz2"
$loc = 99
external ($glob = 99)
test:
assume ((baz1) == "baz1")
assume ((baz2) == "baz2")
assume $loc == (nil)
assume $glob == 99
(externally $action means $body) compiles to:
(external $body) compiles to:
lua> ("
local lua = \(\($action means $body) as lua)
lua:remove_free_vars({\$action:get_stub():as_lua_id()})
local lua = \($body as lua)
lua:remove_free_vars()
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> ("
local lua = \(\($actions all mean $body) as lua)
lua:remove_free_vars(table.map(\$actions, function(a) return a:get_stub():as_lua_id() end))
return lua
local body_lua = \($body as lua)
local varnames = {}
for i,\$v in ipairs(\$externals) do
varnames[i] = \($v as lua):text()
end
body_lua:remove_free_vars(varnames)
return body_lua
")
test:
@ -239,8 +251,8 @@ test:
if replacements[t:as_var()] then
return replacements[t:as_var()]
else
return "SyntaxTree{mangle("..t:as_var():as_lua().."), type="..t.type:as_lua()..", \
..source="..tostring(t.source):as_lua().."}"
return "SyntaxTree{mangle("..t:as_var():as_lua().."), type="..t.type:as_lua(\
..)..", source="..tostring(t.source):as_lua().."}"
end
elseif SyntaxTree:is_instance(t) then
local ret = {}
@ -274,34 +286,37 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[$action parses as $body] all parse as ([$action] all parse as $body)
externally (in (nomsu environment) $tree as lua expr) means:
lua> ("
local tree_lua = \(nomsu environment):compile(\$tree)
if \$tree.type == 'Block' then
tree_lua = LuaCode:from(\$tree.source, '(function()\\n ', tree_lua, '\\nend)()')
elseif \$tree.type == 'MethodCall' and #\$tree > 2 then
compile_error_at(\$tree, "This must be a single value instead of "..(#\$tree - 1).."\
.. method calls.",
"Replace this with a single method call.")
end
return tree_lua
")
external:
(in (nomsu environment) $tree as lua expr) means:
lua> ("
local tree_lua = \(nomsu environment):compile(\$tree)
if \$tree.type == 'Block' then
tree_lua = LuaCode:from(\$tree.source, '(function()\\n ', tree_lua, '\\nend)()')
elseif \$tree.type == 'MethodCall' and #\$tree > 2 then
compile_error_at(\$tree, "This must be a single value instead of "..(#\$tree - 1).."\
.. method calls.",
"Replace this with a single method call.")
end
return tree_lua
")
# 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:
lua> ("
local lua = \($var as lua)
if not lua:text():is_a_lua_id() then
compile_error(\$var,
"This is supposed to be something that compiles to a valid Lua identifier.",
"This should probably be a variable.")
end
return lua
")
external:
[$var as lua identifier, $var as lua id] all mean:
lua> ("
local lua = \($var as lua)
if not lua:text():is_a_lua_id() then
compile_error(\$var,
"This is supposed to be something that compiles to a valid Lua identifier.",
"This should probably be a variable.")
end
return lua
")
test:
(num args (*extra arguments*)) means (select "#" (*extra arguments*))
@ -312,11 +327,10 @@ test:
assume (third arg 5 6 7 8) == 7
(*extra arguments*) compiles to "..."
($ is syntax tree) compiles to "SyntaxTree:is_instance(\($ as lua expr))"
externally ($ is $kind syntax tree) means
=lua "SyntaxTree:is_instance(\$) and \$.type == \$kind"
external:
($ is $kind syntax tree) means
=lua "SyntaxTree:is_instance(\$) and \$.type == \$kind"
($tree with $t -> $replacement) compiles to ("
\($tree as lua expr):map(function(\($t as lua expr))
@ -329,14 +343,15 @@ externally ($ is $kind syntax tree) means
end)
")
externally ($tree with vars $replacements) means
=lua ("
\$tree:map(function(\$t)
if \$t.type == "Var" then
return \$replacements[\$t:as_var()]
end
end)
")
external:
($tree with vars $replacements) means
=lua ("
\$tree:map(function(\$t)
if \$t.type == "Var" then
return \$replacements[\$t:as_var()]
end
end)
")
(tree $tree with vars $replacements) compiles to ("
\(=lua "(\$tree):as_lua()"):map(function(t)
@ -355,24 +370,25 @@ externally ($tree with vars $replacements) means
end)()
")
externally (match $tree with $patt) means:
lua> ("
if \$patt.type == "Var" then return Dict{[\$patt:as_var()]=\$tree} end
if \$patt.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end
if #\$patt ~= #\$tree then return nil end
local matches = Dict{}
for \($i)=1,#\$patt do
if SyntaxTree:is_instance(\$tree[\$i]) then
local submatch = \(match $tree.$i with $patt.$i)
if not submatch then return nil end
for k,v in pairs(submatch) do
if matches[k] and matches[k] ~= v then return nil end
matches[k] = v
external:
(match $tree with $patt) means:
lua> ("
if \$patt.type == "Var" then return Dict{[\$patt:as_var()]=\$tree} end
if \$patt.type == "Action" and \$patt:get_stub() ~= \$tree:get_stub() then return nil end
if #\$patt ~= #\$tree then return nil end
local matches = Dict{}
for \($i)=1,#\$patt do
if SyntaxTree:is_instance(\$tree[\$i]) then
local submatch = \(match $tree.$i with $patt.$i)
if not submatch then return nil end
for k,v in pairs(submatch) do
if matches[k] and matches[k] ~= v then return nil end
matches[k] = v
end
end
end
end
return matches
")
return matches
")
test:
assume
@ -390,20 +406,20 @@ test:
assume ({} is a "Dict")
assume ("" is text)
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:
lua> ("
local lua_type = \(lua type of $)
if lua_type == 'string' then return 'Text'
elseif lua_type == 'table' or lua_type == 'userdata' then
local mt = getmetatable(\$)
if mt and mt.__type then return mt.__type end
end
return lua_type
")
external:
($ is text) means (=lua "\(lua type of $) == 'string'")
[$ is not text, $ isn't text] all mean (=lua "\(lua type of $) ~= 'string'")
(type of $) means:
lua> ("
local lua_type = \(lua type of $)
if lua_type == 'string' then return 'Text'
elseif lua_type == 'table' or lua_type == 'userdata' then
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)
[$ isn't a $type, $ isn't an $type, $ is not a $type, $ is not an $type]
@ -441,19 +457,24 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
(with local compile actions $body) compiles to ("
do
local OLD_RULES = COMPILE_RULES
local OLD_ENV = \(nomsu environment)
local \(nomsu environment) = setmetatable({
COMPILE_RULES=setmetatable({}, {__index=OLD_RULES})
}, {__index=OLD_ENV})
\($body as lua)
end
test:
using compile rules:
(yes) compiles to "3"
assume $(COMPILE RULES).yes
..do:
assume (yes) == 3
assume (yes) == (=lua "true")
(using compile rules $rules do $body) compiles to:
lua> ("
local env = \(new environment)
env:run(\$rules)
local lua = env:compile(\$body)
return lua
")
externally (Nomsu version) means:
return ("
\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
")
external:
(Nomsu version) means:
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".
@ -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:
[$x, $y] = [1, 2]
with [$z, $x = 999]:
@ -156,7 +128,8 @@ test:
test:
$calls = 0
(one) means:
external $calls = ($calls + 1)
external:
$calls = ($calls + 1)
return 1
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
color codes.
@ -34,7 +34,6 @@ test:
"), lines
..== ["one", "two", ""]
($spec とは $body) parses as ($spec means $body)
test:
@ -61,16 +60,18 @@ test:
test:
assume (0xDEADBEEF as hex) == "0xDEADBEEF"
externally ($num as hex) means:
if ($num < 0):
return ("-0x%X", formatted with (- $num))
..else:
return ("0x%X", formatted with $num)
external:
($num as hex) means:
if ($num < 0):
return ("-0x%X", formatted with (- $num))
..else:
return ("0x%X", formatted with $num)
# Text literals
$escapes = {
.nl = "\n", .newline = "\n", .tab = "\t", .bell = "\a", .cr = "\r", ."carriage return" = "\r"
.backspace = "\b", ."form feed" = "\f", .formfeed = "\f", ."vertical tab" = "\v"
.nl = "\n", .newline = "\n", .tab = "\t", .bell = "\a", .cr = "\r"
."carriage return" = "\r", .backspace = "\b", ."form feed" = "\f"
.formfeed = "\f", ."vertical tab" = "\v"
}
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.
@ -32,9 +32,10 @@ test:
assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
if $use_sha1:
externally (hash $) means:
$hash = (=lua "\$hashlib.new('sha1'):final(\$)")
return (base64 $hash)
external:
(hash $) means:
$hash = (=lua "\$hashlib.new('sha1'):final(\$)")
return (base64 $hash)
..else:
# TODO: remove warning?
say ("
@ -42,19 +43,20 @@ if $use_sha1:
..hash function.\027[0m
")
externally (hash $) means:
$bytes = ($, bytes)
$hash = ($bytes.1 << 7)
for $i in 2 to (size of $bytes):
$hash = ((1000003 * $hash) ~ $bytes.$i)
$hash = ($hash ~ (size of $bytes))
return "\$hash"
external:
(hash $) means:
$bytes = ($, bytes)
$hash = ($bytes.1 << 7)
for $i in 2 to (size of $bytes):
$hash = ((1000003 * $hash) ~ $bytes.$i)
$hash = ($hash ~ (size of $bytes))
return "\$hash"
externally (file with hash $hash) means:
for $filename in (files for "."):
$contents = (read file $filename)
$file_hash = (hash $contents)
if ($file_hash == $hash):
return $filename
(hash of file $filename) parses as (hash (read file $filename))
external:
(file with hash $hash) means:
for $filename in (files for "."):
$contents = (read file $filename)
$file_hash = (hash $contents)
if ($file_hash == $hash):
return $filename
(hash of file $filename) parses as (hash (read file $filename))

64
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.
externally (files for $path) means:
$files = (=lua "Files.list(\$path)")
if $files:
$files = (List $files)
return $files
external $(read file $filename) = $Files.read
externally [
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:
(files for $path) means:
$files = (=lua "Files.list(\$path)")
if $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"
lua> ("
local file = io.open(\$filename, 'w')
file:write(\$text)
file:close()
")
lua> ("
local file = io.open(\$filename, 'w')
file:write(\$text)
file:close()
")
externally (source lines of $tree) means:
$source = ($tree.source if ($tree is syntax tree) else $tree)
$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
(source lines of $tree) means:
$source = ($tree.source if ($tree is syntax tree) else $tree)
$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"
$(spoof file $text) = $Files.spoof
$(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.

24
lib/progressbar/init.nom
View File

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

20
lib/shell/init.nom
View File

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

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

10
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
that will match any subtree, and "**" is a wildcard that will match any
@ -55,7 +55,7 @@ command line program with $args:
Warning: searching stdin (ctrl-d to abort). To avoid this message, use nomsu -t find -
")
$filenames = ["stdin"]
for $filename in $filenames:
$file = (read file $filename)
unless $file:
@ -79,7 +79,11 @@ command line program with $args:
if ($t matches $pattern_tree):
$line_num = ($file, line number at $t.source.start)
$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:

4
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:
nomsu -t format [-i] file1 file2...
@ -19,7 +19,7 @@ command line program with $args:
Warning: reading from stdin (ctrl-d to abort). To avoid this message, use nomsu -t format -
")
$filenames = ["stdin"]
for $filename in $filenames:
$file = (read file $filename)
unless $file:

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:
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:
"Action":
say "\($indent)Action (\($t.stub)):"

19
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
@ -8,12 +8,13 @@ use "commandline"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
externally (help) means:
say ("
This is the Nomsu v\(Nomsu version) interactive console.
You can type in Nomsu code here and hit 'enter' twice to run it.
To exit, type 'exit' or 'quit' and hit enter twice.
")
external:
(help) means:
say ("
This is the Nomsu v\(Nomsu version) interactive console.
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:
say ("
@ -23,7 +24,7 @@ command line program with $args:
press 'enter' twice to run a command
")
repeat:
say (bright (yellow ">> ")) inline
$buff = []
@ -38,9 +39,7 @@ command line program with $args:
go to (run buffer)
$buff, add ($line, with "\t" -> " ")
say (dim (yellow ".. ")) inline
--- (run buffer) ---
if ((size of $buff) == 0): stop
$buff = ($buff, joined)
spoof file $buff

16
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.
@ -34,10 +34,10 @@ command line program with $args:
if $args.literal:
for $var in ($args.literal, all matches of "$([^ ]*)"):
$literal_vars.$var = (yes)
if (($pattern_tree.type == "Var") and (not $literal_vars.($pattern_tree.1))):
fail "Pattern matches every part of the file."
$pattern_vars = {
: for $ in recursive $pattern_tree:
if (($.type == "Var") and (not $literal_vars.($.1))): add $.1
@ -45,7 +45,7 @@ command line program with $args:
if ($child is a "Syntax Tree"):
recurse $ on $child
}
# TODO: support wildcards and unpacking
e.g. nomsu -t replace "test(: $test; *$more_tests)" "*$more_tests; *$test"
($tree matches $patt with $substitution_values) means:
@ -85,7 +85,7 @@ command line program with $args:
Warning: searching stdin (ctrl-d to abort). To avoid this message, use nomsu -t find -
")
$filenames = ["stdin"]
for $filename in $filenames:
$file = (read file $filename)
unless $file:
@ -95,7 +95,8 @@ command line program with $args:
$tree = ($code parsed)
..if it fails with $msg:
if $args.q:
unless $args.i: say $code
unless $args.i:
say $code
..else:
say $msg
@ -124,13 +125,10 @@ command line program with $args:
..\(reset color)
")
say "\(bright)..be replaced with:"
say ("
\(bright)\(blue)\("\($ret as nomsu)", with "\n" -> "\n ")\(reset color)
")
$user_answers.$t = (ask "\(bright)..? [Y/n]\(reset color) ")
if ($user_answers.$t == "n"): return (nil)
$replaced.$t = (yes)
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:
nomsu tools/test.nom file1 file2 directory1 ...
@ -14,7 +14,6 @@ command line program with $args:
$file = (read file $filename)
unless $file:
fail "Couldn't find \$filename"
$(test environment) = (new environment)
$(test environment), export $filename
$version =
@ -24,7 +23,7 @@ command line program with $args:
]*)
")
$file_tests = []
for $src = $test in $(test environment).TESTS:
for $src = $test in (nomsu environment, Module $filename).TESTS:
if $version:
$test = ("
#!/usr/bin/env nomsu -V\$version
@ -36,20 +35,22 @@ command line program with $args:
sort $file_tests by $ -> $.source
say "[ .. ] \$filename" inline
$io.flush()
if $args.v: say ""
$failures = []
for $ in $file_tests:
if $args.v:
say " \(yellow ($.test, with "\n" -> "\n "))"
try:
$(test environment), run $.test
..if it fails with $msg:
$src = ($Source, from string $.source)
$l1 = ($file, line number at $src.start)
$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 $args.v:
@ -62,4 +63,3 @@ command line program with $args:
..else:
say "\r[\(red (bright "FAIL"))"
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:
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(".")
package.nomsupath = table.concat(nomsupath, ";")
package.nomsuloaded = Dict({ })
local nomsu_environment = require('nomsu_environment')
nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
nomsu_environment.OPTIMIZATION = optimization
@ -173,6 +174,10 @@ run = function()
nomsu_environment._1_parsed(NomsuCode:from(source, code))
print("Parse succeeded: " .. tostring(filename))
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
error("Cannot compile a lua file (expected a nomsu file as input)")
end
@ -182,7 +187,6 @@ run = function()
else
output = io.open(filename:gsub("%.nom$", ".lua"), "w")
end
local code = Files.read(filename)
local source = Source(filename, 1, #code)
code = NomsuCode:from(source, code)
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 "."
package.nomsupath = table.concat(nomsupath, ";")
package.nomsuloaded = Dict{}
nomsu_environment = require('nomsu_environment')
nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
@ -141,12 +142,14 @@ run = ->
nomsu_environment._1_parsed(NomsuCode\from(source, code))
print("Parse succeeded: #{filename}")
elseif args.compile
code = Files.read(filename)
if not code
error("Could not find file '#{filename}'")
-- Compile .nom files into .lua
if filename\match("%.lua$")
error("Cannot compile a lua file (expected a nomsu file as input)")
output = if filename == 'stdin' then io.output()
else io.open(filename\gsub("%.nom$", ".lua"), "w")
code = Files.read(filename)
source = Source(filename, 1, #code)
code = NomsuCode\from(source, code)
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_nomsu = tree_to_inline_nomsu(target)
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()
elseif "Number" == _exp_1 then
if target_nomsu:text():match("%.") then
@ -498,10 +498,10 @@ tree_to_nomsu = function(tree)
while #line > 0 do
local space = max_line - nomsu:trailing_line_len()
local split = find(line, "[%p%s]", space)
if not split or split > space + 10 then
split = space + 10
if not split or split > space + 16 then
split = space + 16
end
if #line - split < 10 then
if #line - split < 16 then
split = #line
end
local bite

8
nomsu_decompiler.moon
View File

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

18
nomsu_environment.lua
View File

@ -99,7 +99,6 @@ nomsu_environment = Importer({
tostring = tostring,
string = string,
xpcall = xpcall,
module = module,
say = print,
loadfile = loadfile,
rawset = rawset,
@ -215,7 +214,7 @@ nomsu_environment = Importer({
end
return tree
end,
load_module = function(self, package_name)
Module = function(self, package_name)
local path
if package_name:match("%.nom$") or package_name:match("%.lua") then
path = package_name
@ -228,7 +227,7 @@ nomsu_environment = Importer({
end
path = path:gsub("^%./", "")
do
local ret = package.loaded[package_name] or package.loaded[path]
local ret = package.nomsuloaded[package_name] or package.nomsuloaded[path]
if ret then
return ret
end
@ -250,12 +249,12 @@ nomsu_environment = Importer({
_currently_running_files:add(path)
mod:run(code)
_currently_running_files:pop()
package.loaded[package_name] = mod
package.loaded[path] = mod
package.nomsuloaded[package_name] = mod
package.nomsuloaded[path] = mod
return mod
end,
use = function(self, package_name)
local mod = self:load_module(package_name)
local mod = self:Module(package_name)
local imports = assert(_module_imports[self])
for k, v in pairs(mod) do
imports[k] = v
@ -267,7 +266,7 @@ nomsu_environment = Importer({
return mod
end,
export = function(self, package_name)
local mod = self:load_module(package_name)
local mod = self:Module(package_name)
local imports = assert(_module_imports[self])
for k, v in pairs(_module_imports[mod]) do
if rawget(imports, k) == nil then
@ -290,11 +289,6 @@ nomsu_environment = Importer({
self.COMPILE_RULES[k] = v
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
end,
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,
yield:coroutine.yield, resume:coroutine.resume, coroutine_status_of:coroutine.status,
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,
:table, :assert, :dofile, :loadstring, lua_type_of:type, :select, :math, :io, :load,
:pairs, :ipairs, :jit, :_VERSION
@ -105,7 +105,7 @@ nomsu_environment = Importer{
return tree
load_module: (package_name)=>
Module: (package_name)=>
local path
if package_name\match("%.nom$") or package_name\match("%.lua")
path = package_name
@ -114,7 +114,7 @@ nomsu_environment = Importer{
if not path then error(err)
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
if _currently_running_files\has(path)
@ -132,12 +132,12 @@ nomsu_environment = Importer{
_currently_running_files\add path
mod\run(code)
_currently_running_files\pop!
package.loaded[package_name] = mod
package.loaded[path] = mod
package.nomsuloaded[package_name] = mod
package.nomsuloaded[path] = mod
return mod
use: (package_name)=>
mod = @load_module(package_name)
mod = @Module(package_name)
imports = assert _module_imports[@]
for k,v in pairs(mod)
imports[k] = v
@ -147,7 +147,7 @@ nomsu_environment = Importer{
return mod
export: (package_name)=>
mod = @load_module(package_name)
mod = @Module(package_name)
imports = assert _module_imports[@]
for k,v in pairs(_module_imports[mod])
if rawget(imports, k) == nil
@ -163,9 +163,9 @@ nomsu_environment = Importer{
for k,v in pairs(mod.COMPILE_RULES)
if rawget(@COMPILE_RULES, k) == nil
@COMPILE_RULES[k] = v
for k,v in pairs(mod.TESTS)
if rawget(@TESTS, k) == nil
@TESTS[k] = v
--for k,v in pairs(mod.TESTS)
-- if rawget(@TESTS, k) == nil
-- @TESTS[k] = v
return mod
run: (to_run)=>

2
parser.lua
View File

@ -96,7 +96,7 @@ make_parser = function(peg, make_tree)
file = input
}
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))
end
return tree

2
parser.moon
View File

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