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...
# Write a comment? Put a # and go till the end of the line
# 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 ".."
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

10
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,7 +15,8 @@ test:
assume (base64 $plain) == $encoded
assume (base64 decode $encoded) == $plain
externally [base64 $str, base64 encode $str, $str base64] all mean:
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))"]
@ -36,9 +37,8 @@ externally [base64 $str, base64 encode $str, $str base64] all mean:
$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:
(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)]

5
lib/commandline/init.nom
View File

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

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)

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)

7
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))

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 $
]

37
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,10 +8,12 @@ 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:
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
@ -33,7 +35,7 @@ externally (upgrade action $stub to $version via $upgrade_fn) means:
if $replacements.($t.1):
return $replacements.($t.1)
..else:
external $needs_mangle = (yes)
external ($needs_mangle = (yes))
return ("
SyntaxTree{type=\(quote $t.type), source=\(quote "\($t.source)"), \(quote (mangle $t.1))}
")
@ -63,35 +65,30 @@ externally (upgrade action $stub to $version via $upgrade_fn) means:
")
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
]
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]
sort $versions by $ -> ($ as list)
for $ver in $versions:
if (($ver as list) <= $start.version): do next $ver
@ -123,11 +120,11 @@ externally [
return $tree
externally ($tree upgraded from $start_version) means
($tree upgraded from $start_version) means
$tree upgraded from $start_version to (Nomsu version)
externally ($tree upgraded to $end_version) means
($tree upgraded to $end_version) means
$tree upgraded from ($tree.version or (Nomsu version)) to $end_version
externally ($tree upgraded) means
($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.

20
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,10 +105,11 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
external:
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
@ -135,7 +123,7 @@ externally [$items sorted, sorted $items] all mean:
test:
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
externally (unique $items) means:
(unique $items) means:
$unique = []
$seen = {}
for $ in $items:

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

7
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,7 +33,8 @@ set $id_by_obj's metatable to {
return $id
}
externally (uuid) means:
external:
(uuid) means:
# Set all the other bits to randomly (or pseudo-randomly) chosen values.
$bytes = [
# time-low, time-mid, time-high-and-version
@ -63,4 +64,4 @@ test:
seed random with 0
assume ((id of $x) != (id of []))
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 "core/metaprogramming"
export "core/operators"

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

94
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,6 +10,7 @@ use "core/collections"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
external:
# Literals:
test:
unless (all of [inf, NaN, pi, tau, golden ratio, e]):
@ -27,8 +28,8 @@ test:
# Functions:
test:
assume (("5" as a number) == 5)
external $($ as a number) = $(tonumber $)
external $($ as number) = $(tonumber $)
$($ as a number) = $(tonumber $)
$($ as number) = $(tonumber $)
test:
unless
all of [
@ -38,41 +39,42 @@ test:
]
..:
fail "math functions failed"
external [$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
[$(absolute value $), $(absolute value of $), $(| $ |), $(abs $)] =
[$math.abs, $math.abs, $math.abs, $math.abs]
external [$(square root $), $(square root of $), $(√ $), $(sqrt $)] =
[$(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)
[$(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"
externally ($n to the nearest $rounder) means
$rounder * (floor ($n / $rounder + 0.5))
($n to the nearest $rounder) means ($rounder * (floor ($n / $rounder + 0.5)))
# Any/all
externally [all of $items, all $items] all mean:
[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:
[any of $items, any $items] all mean:
for $ in $items:
if $:
return (yes)
@ -80,31 +82,28 @@ externally [any of $items, any $items] all mean:
[none of $items, none $items] all parse as (not (any of $items))
# Sum/product
externally [sum of $items, sum $items] all mean:
[sum of $items, sum $items] all mean:
$total = 0
for $ in $items:
$total += $
return $total
externally [product of $items, product $items] all mean:
[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)
[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:
[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:
[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 = $
@ -139,7 +138,7 @@ test:
test:
assume (100 clamped between 0 and 10) == 10
externally ($ clamped between $min and $max) means:
($ clamped between $min and $max) means:
when:
($ < $min):
return $min
@ -157,7 +156,7 @@ test:
assume (1 smoothed by 2.7) == 1
assume (1.1 smoothed by 2.7) == 1
externally ($ smoothed by $smoothness) means:
($ smoothed by $smoothness) means:
$ = ($ clamped between 0 and 1)
if ($smoothness == 0): return $
$k = (2 ^ $smoothness)
@ -167,25 +166,25 @@ externally ($ smoothed by $smoothness) means:
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 -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.0) == 7
assume (5 to 7 mixed by 2.0) == 7
assume (5 to 7 mixed by 1) == 7
assume (5 to 7 mixed by 2) == 7
externally ($lo to $hi mixed by $amount) means:
($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) == 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 ([0, 1, 11] mixed by 1) == 11
assume ([99] mixed by 0.5) == 99
externally ($nums mixed by $amount) means:
($nums mixed by $amount) means:
$ = ($amount clamped between 0 and 1)
$i = (1 + ($ * ((#$nums) - 1)))
if ((floor $i) == (#$nums)):
@ -194,7 +193,7 @@ externally ($nums mixed by $amount) means:
return ($lo to $hi mixed by ($i mod 1))
# Random functions
externally (seed random with $) means:
(seed random with $) means:
lua> ("
math.randomseed(\$);
for i=1,20 do math.random(); end
@ -207,6 +206,5 @@ externally (seed random with $) means:
[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)]")
[random choice from $elements, random choice $elements, random $elements]
..all mean (=lua "\$elements[math.random(#\$elements)]")

107
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,7 +286,8 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[$action parses as $body] all parse as ([$action] all parse as $body)
externally (in (nomsu environment) $tree as lua expr) means:
external:
(in (nomsu environment) $tree as lua expr) means:
lua> ("
local tree_lua = \(nomsu environment):compile(\$tree)
if \$tree.type == 'Block' then
@ -288,11 +301,13 @@ externally (in (nomsu environment) $tree as lua expr) means:
")
# 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:
[$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
@ -312,10 +327,9 @@ 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
external:
($ is $kind syntax tree) means
=lua "SyntaxTree:is_instance(\$) and \$.type == \$kind"
($tree with $t -> $replacement) compiles to ("
@ -329,7 +343,8 @@ externally ($ is $kind syntax tree) means
end)
")
externally ($tree with vars $replacements) means
external:
($tree with vars $replacements) means
=lua ("
\$tree:map(function(\$t)
if \$t.type == "Var" then
@ -355,7 +370,8 @@ externally ($tree with vars $replacements) means
end)()
")
externally (match $tree with $patt) means:
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
@ -390,11 +406,11 @@ 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:
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'
@ -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:
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):

11
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,7 +60,8 @@ test:
test:
assume (0xDEADBEEF as hex) == "0xDEADBEEF"
externally ($num as hex) means:
external:
($num as hex) means:
if ($num < 0):
return ("-0x%X", formatted with (- $num))
..else:
@ -69,8 +69,9 @@ externally ($num as hex) means:
# 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:

12
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,7 +32,8 @@ test:
assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
if $use_sha1:
externally (hash $) means:
external:
(hash $) means:
$hash = (=lua "\$hashlib.new('sha1'):final(\$)")
return (base64 $hash)
..else:
@ -42,7 +43,8 @@ if $use_sha1:
..hash function.\027[0m
")
externally (hash $) means:
external:
(hash $) means:
$bytes = ($, bytes)
$hash = ($bytes.1 << 7)
for $i in 2 to (size of $bytes):
@ -50,11 +52,11 @@ if $use_sha1:
$hash = ($hash ~ (size of $bytes))
return "\$hash"
externally (file with hash $hash) means:
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))

16
lib/filesystem/init.nom
View File

@ -1,15 +1,15 @@
#!/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:
external:
(files for $path) means:
$files = (=lua "Files.list(\$path)")
if $files:
$files = (List $files)
return $files
external $(read file $filename) = $Files.read
externally [
$(read file $filename) = $Files.read
[
write to file $filename $text, to file $filename write $text
write $text to file $filename
] all mean:
@ -22,7 +22,7 @@ externally [
file:close()
")
externally (source lines of $tree) means:
(source lines of $tree) means:
$source = ($tree.source if ($tree is syntax tree) else $tree)
$file = (read file $source.filename)
return
@ -32,5 +32,5 @@ externally (source lines of $tree) means:
..: add ($file, line $)
], joined with "\n"
external $(spoof file $text) = $Files.spoof
external $(spoof file $filename = $text) = $Files.spoof
$(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.

16
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:
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))))
$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
\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
($w wide $ progress bar) means (($ * $w) / $w progress bar)

6
lib/shell/init.nom
View File

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

13
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,7 +91,8 @@ $METAMETHOD_MAP = {
}
$($ as text like a dict) = ({}'s metatable).__tostring
externally (a class named $classname with $members $(initialize $)) means:
external:
(a class named $classname with $members $(initialize $)) means:
$class = {.__type = $classname}
$class.__index = $class
$class.class = $class
@ -136,7 +137,7 @@ externally (a class named $classname with $members $(initialize $)) means:
$body_lua, remove free vars [$class_id]
$body_lua, declare locals
return
$lua =
Lua ("
\$class_id = a_class_named_1_with(\(quote $classname.stub), \($members as lua)\(
(
@ -148,10 +149,12 @@ externally (a class named $classname with $members $(initialize $)) means:
")
) if $class_body else ""
))
a_\$class_id = function(initial_values) return \($classname.stub, as lua id)(initial_values \
..or {}) end
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
[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
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):
$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:

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:
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:
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)):"

7
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,7 +8,8 @@ use "commandline"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
externally (help) means:
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.
@ -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

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.
@ -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