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

Fully upgraded to 4.10.12.7, including deprecating the old list/dict

Browse Source 
comprehension methods, in favor of the new native support.
This commit is contained in:
Bruce Hill 2018-11-11 15:50:46 -08:00
parent ba03cb67c3
commit 4efe44ed27
41 changed files with 638 additions and 666 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compatibility/2.3.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <2.3 to Nomsu 2.3 This file defines upgrades from Nomsu <2.3 to Nomsu 2.3

35
compatibility/2.4.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <2.4 to Nomsu 2.4 This file defines upgrades from Nomsu <2.4 to Nomsu 2.4
@ -10,60 +10,65 @@ upgrade %tree to "2.4" as:
unless (%tree is "Action" syntax tree): return unless (%tree is "Action" syntax tree): return
if %tree.stub is: if %tree.stub is:
"when" "if": "when" "if":
if ((size of %tree) == 3): if ((size of %tree) == 3): return %tree
return %tree
%conditions = [] %conditions = []
%new_lines = [] %new_lines = []
%body = (..) %body = ((%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded])
(%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded]
for %line in %body: for %line in %body:
when: when:
(not (%line is "Action" syntax tree)): (not (%line is "Action" syntax tree)):
%new_lines::add %line %new_lines::add %line
(%line.stub is "*"): (%line.stub is "*"):
if ((size of %line) == 2): if ((size of %line) == 2):
%conditions::add %line.2 %conditions::add %line.2
..else: ..else:
%new_lines::add %line %new_lines::add %line
(%line.stub == "* else"): (%line.stub == "* else"):
%new_lines::add (\(else %block) with vars {block:%line.3}) %new_lines::add (\(else %block) with vars {block: %line.3})
else: else:
%conditions::add %line.2 %conditions::add %line.2
%action = %line.3 %action = %line.3
unless (%action is "Block" syntax tree): unless (%action is "Block" syntax tree):
%action = (=lua "SyntaxTree{type='Block', source=\%action.source, \%action}") %action = (=lua "SyntaxTree{type='Block', source=\%action.source, \%action}")
%conditions::add %action %conditions::add %action
%new_lines::add (=lua "SyntaxTree{type='Action', source=\%conditions[1].source, unpack(\%conditions)}") %new_lines::add (..)
=lua "SyntaxTree{type='Action', source=\%conditions[1].source, unpack(\%conditions)}"
%conditions = [] %conditions = []
return (..) return (..)
\(when %body) with vars {body:=lua "SyntaxTree{type='Block', source=\%tree[2].source, unpack(\%new_lines)}"} \(when %body) with vars {..}
body: =lua "SyntaxTree{type='Block', source=\%tree[2].source, unpack(\%new_lines)}"
"if 1 is ?" "if 1 = ?": "if 1 is ?" "if 1 = ?":
%values = [] %values = []
%new_lines = [] %new_lines = []
%body = (..) %body = ((%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded])
(%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded]
for %line in %body: for %line in %body:
when: when:
(not (%line is "Action" syntax tree)): (not (%line is "Action" syntax tree)):
%new_lines::add %line %new_lines::add %line
(%line.stub is "*"): (%line.stub is "*"):
if ((size of %line) == 2): if ((size of %line) == 2):
%values::add %line.2 %values::add %line.2
..else: ..else:
%new_lines::add %line %new_lines::add %line
(%line.stub == "* else"): (%line.stub == "* else"):
%new_lines::add (\(else %block) with vars {block:%line.3}) %new_lines::add (\(else %block) with vars {block: %line.3})
else: else:
%values::add %line.2 %values::add %line.2
%action = %line.3 %action = %line.3
unless (%action is "Block" syntax tree): unless (%action is "Block" syntax tree): %action = \(: %action)
%action = \(: %action)
%values::add %action %values::add %action
%new_lines::add (=lua "SyntaxTree{type='Action', source=\%values[1].source, unpack(\%values)}") %new_lines::add (..)
=lua "SyntaxTree{type='Action', source=\%values[1].source, unpack(\%values)}"
%values = [] %values = []
return (..) return (..)
\(if %var is %body) with vars {..} \(if %var is %body) with vars {..}
var:%tree.2 upgraded, body:=lua "SyntaxTree{type='Block', source=\%tree[5].source, unpack(\%new_lines)}" var: %tree.2 upgraded, body: =lua "SyntaxTree{type='Block', source=\%tree[5].source, unpack(\%new_lines)}"

8
compatibility/2.5.5.5.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5 This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5
@ -7,10 +7,8 @@ use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action [hash %, sha1 %] to "2.5.5.5" as (..) upgrade action [hash %, sha1 %] to "2.5.5.5" as (..)
=lua "\ =lua "\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)"
..\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)"
upgrade action [file with hash %] to "2.5.5.5" as (..) upgrade action [file with hash %] to "2.5.5.5" as (..)
file with hash (..) file with hash (..)
base64 (..) base64 (=lua "\%:gsub('..', function(xx) return string.char(tonumber(xx, 16)) end)")
=lua "\%:gsub('..', function(xx) return string.char(tonumber(xx, 16)) end)"

2
compatibility/2.5.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <2.5 to Nomsu 2.5 This file defines upgrades from Nomsu <2.5 to Nomsu 2.5

19
compatibility/2.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu 1 to Nomsu 2 This file defines upgrades from Nomsu 1 to Nomsu 2
@ -15,21 +15,22 @@ upgrade %tree to "2" as:
%false_body = (%tree.5 upgraded) %false_body = (%tree.5 upgraded)
unless (%false_body is "Block" syntax tree): unless (%false_body is "Block" syntax tree):
%false_body = (=lua "Block(\%false_body.source, \%false_body)") %false_body = (=lua "Block(\%false_body.source, \%false_body)")
return (..) return (..)
\(if %cond %true_body else %false_body) with vars {..} \(if %cond %true_body else %false_body) with vars {..}
cond:%tree.2 upgraded, true_body:%true_body, false_body:%false_body cond: %tree.2 upgraded, true_body: %true_body, false_body: %false_body
%need_blocks = [..] %need_blocks = [..]
"if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1" "if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1", "repeat 1 times"
"repeat 1 times", "repeat", "repeat until 1", "for 1 in 2 to 3 by" "repeat", "repeat until 1", "for 1 in 2 to 3 by", "for 1 in 2 to 3 via"
"for 1 in 2 to 3 via", "for 1 in 2 to", "for 1 2 in" "for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with", "result of"
"do", "for 1 in recursive", "test", "with", "result of", "when" "when"
for %n in %need_blocks: for %n in %need_blocks:
if (%tree.stub is %n): if (%tree.stub is %n):
%bits = (((% upgraded) if (% is syntax tree) else %) for % in %tree) %bits = [: for % in %tree: add ((% upgraded) if (% is syntax tree) else %)]
unless ((%bits::last) is "Block" syntax tree): unless ((%bits::last) is "Block" syntax tree):
%body = (%bits::last) %body = (%bits::last)
%bits.(size of %bits) = (=lua "SyntaxTree{type='Block', source=\%body.source, \%body}") %bits.(size of %bits) = (..)
=lua "SyntaxTree{type='Block', source=\%body.source, \%body}"
return (=lua "SyntaxTree{type='Action', source=\%tree.source, unpack(\%bits)}") return (=lua "SyntaxTree{type='Action', source=\%tree.source, unpack(\%bits)}")

2
compatibility/3.5.5.6.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6 This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6

4
compatibility/3.6.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <3.6 to 3.6 This file defines upgrades from Nomsu <3.6 to 3.6
@ -16,11 +16,9 @@ upgrade action [add %item to %list at index %i] to "3.6" as (..)
upgrade action [pop from %list, remove last from %list] to "3.6" as (%list::pop) upgrade action [pop from %list, remove last from %list] to "3.6" as (%list::pop)
upgrade action [remove index %index from %list] to "3.6" as (..) upgrade action [remove index %index from %list] to "3.6" as (..)
%list::remove index %index %list::remove index %index
upgrade action [to %1 write %2, %1 <-write %2] to "3.6" as (%1::append %2) upgrade action [to %1 write %2, %1 <-write %2] to "3.6" as (%1::append %2)
upgrade action [to %1 write %2 joined by %3] to "3.6" as (..) upgrade action [to %1 write %2 joined by %3] to "3.6" as (..)
%1::append %2 joined by %3 %1::append %2 joined by %3
upgrade action [declare locals in %lua] to "3.6" as (%lua::declare locals) upgrade action [declare locals in %lua] to "3.6" as (%lua::declare locals)
upgrade action [declare locals %locs in %lua] to "3.6" as (..) upgrade action [declare locals %locs in %lua] to "3.6" as (..)
%lua::declare locals %locs %lua::declare locals %locs

22
compatibility/3.7.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <3.7 to 3.7 This file defines upgrades from Nomsu <3.7 to 3.7
@ -6,14 +6,22 @@ use "compatibility/compatibility.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
upgrade action [%index st to last in %list] to "3.7" as (%list::%index st to last) upgrade action [%index st to last in %list] to "3.7" as (..)
upgrade action [%index nd to last in %list] to "3.7" as (%list::%index nd to last) %list::%index st to last
upgrade action [%index rd to last in %list] to "3.7" as (%list::%index rd to last)
upgrade action [%index th to last in %list] to "3.7" as (%list::%index rd th last) upgrade action [%index nd to last in %list] to "3.7" as (..)
%list::%index nd to last
upgrade action [%index rd to last in %list] to "3.7" as (..)
%list::%index rd to last
upgrade action [%index th to last in %list] to "3.7" as (..)
%list::%index rd th last
upgrade action [last in %list] to "3.7" as (%list::last) upgrade action [last in %list] to "3.7" as (%list::last)
upgrade action [first in %list] to "3.7" as (%list::first) upgrade action [first in %list] to "3.7" as (%list::first)
upgrade action [%item is in %list, %list contains %item, %list has %item] upgrade action [%item is in %list, %list contains %item, %list has %item] to \
..to "3.7" as (%list::has %item) .."3.7" as (%list::has %item)
upgrade action [..] upgrade action [..]
%item isn't in %list, %item is not in %list, %list doesn't contain %item %item isn't in %list, %item is not in %list, %list doesn't contain %item

5
compatibility/3.8.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <3.8 to 3.8 (Text method changes) This file defines upgrades from Nomsu <3.8 to 3.8 (Text method changes)
@ -7,16 +7,13 @@ 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) upgrade action [byte %i of %text] to "3.8" as (%text::byte %i)
upgrade action [bytes %start to %stop of %text] to "3.8" as (..) upgrade action [bytes %start to %stop of %text] to "3.8" as (..)
%text::bytes %start to %stop %text::bytes %start to %stop
upgrade action [bytes of %text] to "3.8" as (%text::bytes) upgrade action [bytes of %text] to "3.8" as (%text::bytes)
upgrade action [capitalized %text, %text capitalized] to "3.8" as (..) upgrade action [capitalized %text, %text capitalized] to "3.8" as (..)
%text::capitalized %text::capitalized
upgrade action [uppercase %text, %text uppercase] to "3.8" as (%text::uppercase) upgrade action [uppercase %text, %text uppercase] to "3.8" as (%text::uppercase)
upgrade action [..] upgrade action [..]
%text with %sub instead of %patt, %text with %patt replaced by %sub %text with %sub instead of %patt, %text with %patt replaced by %sub
%text s/ %patt / %sub %text s/ %patt / %sub
..to "3.8" as (%text::with %patt -> %sub) ..to "3.8" as (%text::with %patt -> %sub)
upgrade action [%text matches %pattern] to "3.8" as (%text::matches %pattern) upgrade action [%text matches %pattern] to "3.8" as (%text::matches %pattern)
upgrade action [%text matching %pattern] to "3.8" as (%text::matching %pattern).1 upgrade action [%text matching %pattern] to "3.8" as (%text::matching %pattern).1

6
compatibility/3.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <=2 to Nomsu 3 This file defines upgrades from Nomsu <=2 to Nomsu 3
@ -10,6 +10,4 @@ upgrade action (method %spec %body) to "3" as (my action %spec %body)
upgrade action (me) to "3" as %me upgrade action (me) to "3" as %me
upgrade action (@) to "3" as %me upgrade action (@) to "3" as %me
upgrade action "as" to "3" via (..) upgrade action "as" to "3" via (..)
[] -> (..) [] -> (barf "Object API has changed. Use (%obj::action ...) instead of (as %obj: action ...)")
barf "\
..Object API has changed. Use (%obj::action ...) instead of (as %obj: action ...)"

43
compatibility/4.10.12.7.nom
View File

@ -9,22 +9,33 @@ upgrade action (% as lua statements) to "4.10.12.7" as (% as lua)
upgrade action (% as lua return) to "4.10.12.7" as (..) upgrade action (% as lua return) to "4.10.12.7" as (..)
=lua "\%.type == 'Block' and \(% as lua) or 'return '..\(% as lua expr)" =lua "\%.type == 'Block' and \(% as lua) or 'return '..\(% as lua expr)"
upgrade action (Lua value %) to "4.10.12.7" as (Lua %) upgrade action (Lua value %) to "4.10.12.7" as (Lua %)
upgrade action (%e for % in %items) to "4.10.12.7" as [: for % in %items: add %e]
upgrade action (%e for %k = %v in %items) to "4.10.12.7" as [..]
: for %k = %v in %items: add %e
upgrade action (%e for % in %items) to "4.10.12.7" as [:for % in %items: add %e] upgrade action (%e for %i in %start to %stop) to "4.10.12.7" as [..]
upgrade action (%e for %k = %v in %items) to "4.10.12.7" as [:for %k = %v in %items: add %e] : for %i in %start to %stop: add %e
upgrade action (%e for %i in %start to %stop) to "4.10.12.7" as [:for %i in %start to %stop: add %e]
upgrade action (%e for %i in %start to %stop by %step) to "4.10.12.7" as (..)
[:for %i in %start to %stop by %step: add %e]
upgrade action (%e for %i in %start to %stop via %step) to "4.10.12.7" as (..)
[:for %i in %start to %stop by %step: add %e]
upgrade action (%k = %v for % in %items) to "4.10.12.7" as {:for % in %items: add %k = %v} upgrade action (%e for %i in %start to %stop by %step) to "4.10.12.7" as [..]
upgrade action (%k = %v for %k0 = %v0 in %items) to "4.10.12.7" as {:for %k0 = %v0 in %items: add %k = %v} : for %i in %start to %stop by %step: add %e
upgrade action (%k = %v for %i in %start to %stop) to "4.10.12.7" as {:for %i in %start to %stop: add %k = %v}
upgrade action (%k = %v for %i in %start to %stop by %step) to "4.10.12.7" as (..) upgrade action (%e for %i in %start to %stop via %step) to "4.10.12.7" as [..]
{:for %i in %start to %stop by %step: add %k = %v} : for %i in %start to %stop by %step: add %e
upgrade action (%k = %v for %i in %start to %stop via %step) to "4.10.12.7" as (..)
{:for %i in %start to %stop by %step: add %k = %v} upgrade action (%k = %v for % in %items) to "4.10.12.7" as {..}
: for % in %items: add %k = %v
upgrade action (%k = %v for %k0 = %v0 in %items) to "4.10.12.7" as {..}
: for %k0 = %v0 in %items: add %k = %v
upgrade action (%k = %v for %i in %start to %stop) to "4.10.12.7" as {..}
: for %i in %start to %stop: add %k = %v
upgrade action (%k = %v for %i in %start to %stop by %step) to "4.10.12.7" as {..}
: for %i in %start to %stop by %step: add %k = %v
upgrade action (%k = %v for %i in %start to %stop via %step) to "4.10.12.7" as {..}
: for %i in %start to %stop by %step: add %k = %v
upgrade action (% as lua statements) to "4.10.12.7" as (% as lua) upgrade action (% as lua statements) to "4.10.12.7" as (% as lua)
upgrade action (compile error at %pos %err hint %hint) to "4.10.12.7" as (..) upgrade action (compile error at %pos %err hint %hint) to "4.10.12.7" as (..)
@ -38,11 +49,13 @@ upgrade %tree to "4.10.12.7" as:
repeat while (%i < (size of %first_chunk)): repeat while (%i < (size of %first_chunk)):
if %first_has_use: if %first_has_use:
if ((%first_chunk.%i.type != "Action") or (%first_chunk.%i.stub != "use")): if ((%first_chunk.%i.type != "Action") or (%first_chunk.%i.stub != "use")):
%chunk2 = (%SyntaxTree {type:"Block"}) %chunk2 = (%SyntaxTree {type: "Block"})
for %j in %i to (size of %first_chunk.%i): for %j in %i to (size of %first_chunk.%i):
%chunk2.((size of %chunk2) + 1) = %first_chunk.%i.%j %chunk2.((size of %chunk2) + 1) = %first_chunk.%i.%j
for %j in %i to (size of %first_chunk.%i): for %j in %i to (size of %first_chunk.%i):
%first_chunk.%i.%j = (nil) %first_chunk.%i.%j = (nil)
%table.insert %tree 2 %chunk2 %table.insert %tree 2 %chunk2
return %tree return %tree
..else: ..else:

6
compatibility/4.8.10.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10.6 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means") This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means")
use "compatibility/compatibility.nom" use "compatibility/compatibility.nom"
@ -15,6 +15,7 @@ upgrade action "local action" to "4.8.10" via (..)
return \(%spec.1 means %body) return \(%spec.1 means %body)
..else: ..else:
return \(%spec all mean %body) return \(%spec all mean %body)
else: else:
return \(%spec means %body) return \(%spec means %body)
@ -29,6 +30,7 @@ upgrade action "action" to "4.8.10" via (..)
return \(externally %spec.1 means %body) return \(externally %spec.1 means %body)
..else: ..else:
return \(externally %spec all mean %body) return \(externally %spec all mean %body)
else: else:
return \(externally %spec means %body) return \(externally %spec means %body)
..else: ..else:
@ -44,6 +46,7 @@ upgrade action "compile 1 to" to "4.8.10" via (..)
return \(%spec.1 compiles to %body) return \(%spec.1 compiles to %body)
..else: ..else:
return \(%spec all compile to %body) return \(%spec all compile to %body)
else: else:
return \(%spec compiles to %body) return \(%spec compiles to %body)
@ -57,6 +60,7 @@ upgrade action "parse 1 as" to "4.8.10" via (..)
return \(%spec.1 parses as %body) return \(%spec.1 parses as %body)
..else: ..else:
return \(%spec all parse as %body) return \(%spec all parse as %body)
else: else:
return \(%spec parse as %body) return \(%spec parse as %body)

2
compatibility/4.9.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.9.11.6 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines upgrades from Nomsu <4.9 to 4.9 This file defines upgrades from Nomsu <4.9 to 4.9
use "compatibility/compatibility.nom" use "compatibility/compatibility.nom"

40
compatibility/compatibility.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains code for defining ways to upgrade code between different versions This file contains code for defining ways to upgrade code between different versions
of Nomsu. of Nomsu.
@ -10,7 +10,6 @@ use "lib/os.nom"
%UPGRADES = {} %UPGRADES = {}
externally (upgrade to %version via %upgrade_fn) means: externally (upgrade to %version via %upgrade_fn) means:
%UPGRADES.%version = %upgrade_fn %UPGRADES.%version = %upgrade_fn
%ACTION_UPGRADES = ({} with fallback % -> {}) %ACTION_UPGRADES = ({} with fallback % -> {})
externally (upgrade action %stub to %version via %upgrade_fn) means: externally (upgrade action %stub to %version via %upgrade_fn) means:
%ACTION_UPGRADES.%version.%stub = %upgrade_fn %ACTION_UPGRADES.%version.%stub = %upgrade_fn
@ -27,7 +26,6 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
for %i in 1 to (size of %action): for %i in 1 to (size of %action):
if (%action.%i.type is "Var"): if (%action.%i.type is "Var"):
%replacements.(%action.%i.1) = "\(\%tree as lua id)[\%i]" %replacements.(%action.%i.1) = "\(\%tree as lua id)[\%i]"
define mangler define mangler
(make tree %t) means: (make tree %t) means:
when: when:
@ -45,21 +43,20 @@ externally (upgrade action %stub to %version via %upgrade_fn) means:
%args::add (make tree %v) %args::add (make tree %v)
..else: ..else:
%args::add "\(%k)=\(make tree %v)" %args::add "\(%k)=\(make tree %v)"
return "SyntaxTree{\(%args::joined with ", ")}" return "SyntaxTree{\(%args::joined with ", ")}"
else: return (quote %t) else:
return (quote %t)
unless ("\%lua" == ""):
%lua::append "\n"
unless ("\%lua" == ""): %lua::append "\n"
%retval = (make tree %body) %retval = (make tree %body)
%lua::append (..) %lua::append (..)
Lua "\ Lua "\
..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(..) ..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(\%tree as lua id))
\%tree as lua id
..)
return \%retval return \%retval
end)" end)"
return %lua return %lua
externally [..] externally [..]
@ -71,8 +68,10 @@ externally [..]
%versions = {} %versions = {}
for %v = % in %UPGRADES: for %v = % in %UPGRADES:
%versions.%v = (yes) %versions.%v = (yes)
for %v = % in %ACTION_UPGRADES: for %v = % in %ACTION_UPGRADES:
%versions.%v = (yes) %versions.%v = (yes)
%versions = ((keys in %versions) sorted by % -> (% as list)) %versions = ((keys in %versions) sorted by % -> (% as list))
for %ver in %versions: for %ver in %versions:
if ((%ver as list) <= (%start_version as list)): do next %ver if ((%ver as list) <= (%start_version as list)): do next %ver
@ -81,18 +80,18 @@ externally [..]
%tree = (..) %tree = (..)
%tree with % ->: %tree with % ->:
if ((% is "Action" syntax tree) and %ACTION_UPGRADES.%ver.(%.stub)): if ((% is "Action" syntax tree) and %ACTION_UPGRADES.%ver.(%.stub)):
%with_upgraded_args = (..) %with_upgraded_args = {..}
%k = (%v upgraded from %start_version to %end_version) for %k = %v in % : for %k = %v in %: add %k = (%v upgraded from %start_version to %end_version)
set %with_upgraded_args 's metatable to (% 's metatable) set %with_upgraded_args's metatable to (%'s metatable)
return (..) return (%ACTION_UPGRADES.%ver.(%.stub) %with_upgraded_args %end_version)
%ACTION_UPGRADES.%ver.(%.stub) %with_upgraded_args %end_version
if %UPGRADES.%ver: if %UPGRADES.%ver:
%with_upgraded_args = (..) %with_upgraded_args = {..}
%k = (%v upgraded from %start_version to %end_version) for %k = %v in %tree :
set %with_upgraded_args 's metatable to (%tree 's metatable) 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 = (call %UPGRADES.%ver with [%with_upgraded_args, %end_version]) %tree = (call %UPGRADES.%ver with [%with_upgraded_args, %end_version])
%tree.shebang = "#!/usr/bin/env nomsu -V\%end_version" %tree.shebang = "#!/usr/bin/env nomsu -V\%end_version"
return %tree return %tree
@ -107,7 +106,8 @@ externally (%tree upgraded) means (..)
externally (use %path from version %version) means: externally (use %path from version %version) means:
for file %filename in %path: for file %filename in %path:
if (=lua "LOADED[\%filename]"): do next %filename if (=lua "LOADED[\%filename]"):
do next %filename
%file = (read file %filename) %file = (read file %filename)
%tree = (parse %file from %filename) %tree = (parse %file from %filename)
%tree = (upgrade %tree from %version) %tree = (upgrade %tree from %version)

149
core/collections.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains code that supports manipulating and using collections like lists This file contains code that supports manipulating and using collections like lists
and dictionaries. and dictionaries.
@ -15,11 +15,11 @@ test:
%visited = {} %visited = {}
for %i = %x in %list: for %i = %x in %list:
%visited.%i = (yes) %visited.%i = (yes)
assume (%visited == {1:yes, 2:yes, 3:yes, 4:yes, 5:yes}) assume (%visited == {1: yes, 2: yes, 3: yes, 4: yes, 5: yes})
%visited = {} %visited = {}
for %x in %list: for %x in %list:
%visited.%x = (yes) %visited.%x = (yes)
assume (%visited == {1:yes, 2:yes, 3:yes, 4:yes, 5:yes}) assume (%visited == {1: yes, 2: yes, 3: yes, 4: yes, 5: yes})
assume ((%list::2 nd to last) == 4) assume ((%list::2 nd to last) == 4)
assume ((%list::first) == 1) assume ((%list::first) == 1)
assume (%list::has 3) assume (%list::has 3)
@ -35,130 +35,53 @@ test:
# Dict functionality # Dict functionality
test: test:
%dict = {x:1, y:2, z:3} %dict = {x: 1, y: 2, z: 3}
assume ((size of %dict) == 3) assume (size of %dict) == 3
assume ((% for % in {x:1}) == [{key:"x", value:1}]) assume [: for % in {x: 1}: add %] == [{key: "x", value: 1}]
assume (({key:%k, value:%v} for %k = %v in {x:1}) == [{key:"x", value:1}]) assume [: for %k = %v in {x: 1}: add {key: %k, value: %v}] == [..]
assume (({x:1, y:1} + {y:10, z:10}) == {x:1, y:11, z:10}) {key: "x", value: 1}
assume (({x:1, y:1} | {y:10, z:10}) == {x:1, y:1, z:10}) assume ({x: 1, y: 1} + {y: 10, z: 10}) == {x: 1, y: 11, z: 10}
assume (({x:1, y:1} & {y:10, z:10}) == {y:1}) assume ({x: 1, y: 1} | {y: 10, z: 10}) == {x: 1, y: 1, z: 10}
assume (({x:1, y:1} ~ {y:10, z:10}) == {x:1, z:10}) assume ({x: 1, y: 1} & {y: 10, z: 10}) == {y: 1}
assume ({x: 1, y: 1} ~ {y: 10, z: 10}) == {x: 1, z: 10}
# List Comprehension
test:
assume (((% * %) for % in [1, 2, 3]) == [1, 4, 9])
(%expression for %item in %iterable) parses as (..)
result of:
%comprehension = []
for %item in %iterable:
%comprehension::add %expression
return %comprehension
[..]
%expression for %index in %start to %stop via %step
%expression for %index in %start to %stop by %step
..all parse as (..)
result of:
%comprehension = []
for %index in %start to %stop via %step:
%comprehension::add %expression
return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
assume (((% * %) for % in 1 to 3) == [1, 4, 9])
(%expression for %var in %start to %stop) parses as (..)
%expression for %var in %start to %stop via 1
test:
assume (("\%k,\%v" for %k = %v in {x:1}) == ["x,1"])
[..]
%expression for %key = %value in %iterable
%expression for %key %value in %iterable
..all parse as (..)
result of:
%comprehension = []
for %key = %value in %iterable:
%comprehension::add %expression
return %comprehension
# Dict comprehensions
test:
assume (((% * %) = % for % in [1, 2, 3]) == {1:1, 4:2, 9:3})
[..]
%key = %value for %item in %iterable, %key %value for %item in %iterable
..all parse as (..)
result of:
%comprehension = {}
for %item in %iterable:
%comprehension.%key = %value
return %comprehension
test:
assume ((%k = (%v * %v) for %k = %v in {x:1, y:2, z:3}) == {x:1, y:4, z:9})
[..]
%key = %value for %src_key = %src_value in %iterable
%key %value for %src_key %src_value in %iterable
..all parse as (..)
result of:
%comprehension = {}
for %src_key = %src_value in %iterable:
%comprehension.%key = %value
return %comprehension
[..]
%key = %value for %item in %start to %stop via %step
%key %value for %item in %start to %stop via %step
..all parse as (..)
result of:
%comprehension = {}
for %item in %start to %stop via %step:
%comprehension.%key = %value
return %comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
assume (((% * %) = % for % in 1 to 3) == {1:1, 4:2, 9:3})
[..]
%key = %value for %item in %start to %stop
%key %value for %item in %start to %stop
..all parse as (%key = %value for %item in %start to %stop via 1)
test: test:
assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4]) assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4])
externally (%lists flattened) means: externally (%lists flattened) means:
%flat = [] %flat = []
for %list in %lists: for %item in recursive %lists:
for %item in %list: %flat::add %item if (%item is a "List"):
for % in %item:
recurse %item on %
..else:
%flat::add %item
return %flat return %flat
test: test:
assume ((entries in {x:1}) == [{key:"x", value:1}]) assume ((entries in {x: 1}) == [{key: "x", value: 1}])
(entries in %dict) parses as ({key:%k, value:%v} for %k = %v in %dict)
(entries in %dict) parses as [: for %k = %v in %dict: add {key: %k, value: %v}]
test: test:
assume ((keys in {x:1}) == ["x"]) assume ((keys in {x: 1}) == ["x"])
[keys in %dict, keys of %dict] all parse as (%k for %k = %v in %dict) [keys in %dict, keys of %dict] all parse as [: for %k = %v in %dict: add %k]
test: test:
assume ((values in {x:1}) == [1]) assume ((values in {x: 1}) == [1])
[values in %dict, values of %dict] all parse as (%v for %k = %v in %dict) [values in %dict, values of %dict] all parse as [: for %k = %v in %dict: add %v]
# Metatable stuff # Metatable stuff
test: test:
%t = {} %t = {}
set %t 's metatable to {__tostring:[%] -> "XXX"} set %t's metatable to {__tostring: [%] -> "XXX"}
assume ("\%t" == "XXX") assume ("\%t" == "XXX")
(set %dict 's metatable to %metatable) compiles to "\
(set %dict's metatable to %metatable) compiles to "\
..setmetatable(\(%dict as lua expr), \(%metatable as lua expr));" ..setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
[% 's metatable, % 'metatable] all compile to "\ [%'s metatable, %'metatable] all compile to "getmetatable(\(% as lua expr))"
..getmetatable(\(% as lua expr))"
test: test:
assume (({} with fallback % -> (% + 1)).10 == 11) assume (({} with fallback % -> (% + 1)).10 == 11)
(%dict with fallback %key -> %value) compiles to "\ (%dict with fallback %key -> %value) compiles to "\
..(function(d) ..(function(d)
local mt = {} local mt = {}
@ -178,12 +101,11 @@ test:
assume (%x == [1, 2, 3]) assume (%x == [1, 2, 3])
sort %x by % = (- %) sort %x by % = (- %)
assume (%x == [3, 2, 1]) assume (%x == [3, 2, 1])
%keys = {1:999, 2:0, 3:50} %keys = {1: 999, 2: 0, 3: 50}
sort %x by % = %keys.% sort %x by % = %keys.%
assume (%x == [2, 3, 1]) assume (%x == [2, 3, 1])
(sort %items) compiles to "table.sort(\(%items as lua expr));" (sort %items) compiles to "table.sort(\(%items as lua expr));"
[..] [sort %items by %item = %key_expr, sort %items by %item -> %key_expr] \
sort %items by %item = %key_expr, sort %items by %item -> %key_expr
..all parse as (..) ..all parse as (..)
do: do:
%keys = ({} with fallback %item -> %key_expr) %keys = ({} with fallback %item -> %key_expr)
@ -193,19 +115,21 @@ test:
test: test:
assume ((sorted [3, 1, 2]) == [1, 2, 3]) assume ((sorted [3, 1, 2]) == [1, 2, 3])
externally [%items sorted, sorted %items] all mean: externally [%items sorted, sorted %items] all mean:
%copy = (% for % in %items) %copy = [: for % in %items: add %]
sort %copy sort %copy
return %copy return %copy
[%items sorted by %item = %key, %items sorted by %item -> %key] all parse as (..) [%items sorted by %item = %key, %items sorted by %item -> %key] all parse as (..)
result of: result of:
%copy = (% for % in %items) %copy = [: for % in %items: add %]
sort %copy by %item = %key sort %copy by %item = %key
return %copy return %copy
test: test:
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3]) assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
externally (unique %items) means: externally (unique %items) means:
%unique = [] %unique = []
%seen = {} %seen = {}
@ -213,5 +137,4 @@ externally (unique %items) means:
unless %seen.%: unless %seen.%:
%unique::add % %unique::add %
%seen.% = (yes) %seen.% = (yes)
return %unique return %unique

232
core/control_flow.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains compile-time actions that define basic control flow structures This file contains compile-time actions that define basic control flow structures
like "if" statements and loops. like "if" statements and loops.
@ -10,13 +10,15 @@ use "core/errors.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# No-Op # No-Op
test: do nothing test:
do nothing
(do nothing) compiles to "" (do nothing) compiles to ""
# Conditionals # Conditionals
test: test:
if (no): if (no):
barf "conditional fail" barf "conditional fail"
(if %condition %if_body) compiles to "\ (if %condition %if_body) compiles to "\
..if \(%condition as lua expr) then ..if \(%condition as lua expr) then
\(%if_body as lua) \(%if_body as lua)
@ -25,9 +27,9 @@ test:
test: test:
unless (yes): unless (yes):
barf "conditional fail" barf "conditional fail"
(unless %condition %unless_body) parses as (if (not %condition) %unless_body) (unless %condition %unless_body) parses as (if (not %condition) %unless_body)
[..] [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] \
if %condition %if_body else %else_body, unless %condition %else_body else %if_body
..all compile to "\ ..all compile to "\
..if \(%condition as lua expr) then ..if \(%condition as lua expr) then
\(%if_body as lua) \(%if_body as lua)
@ -43,6 +45,7 @@ test:
test: test:
assume ((1 if (yes) else 2) == 1) assume ((1 if (yes) else 2) == 1)
assume ((1 if (no) else 2) == 2) assume ((1 if (no) else 2) == 2)
[..] [..]
%when_true_expr if %condition else %when_false_expr %when_true_expr if %condition else %when_false_expr
%when_true_expr if %condition otherwise %when_false_expr %when_true_expr if %condition otherwise %when_false_expr
@ -51,12 +54,8 @@ test:
..all compile to: ..all compile to:
# If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic # If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic
equivalent of a conditional expression: (cond and if_true or if_false) equivalent of a conditional expression: (cond and if_true or if_false)
if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type): if {Text: yes, List: yes, Dict: yes, Number: yes}.(%when_true_expr.type):
return (..) return (Lua "(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr))")
Lua "\
..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
%when_false_expr as lua expr
..)"
..else: ..else:
# Otherwise, need to do an anonymous inline function (yuck, too bad lua # Otherwise, need to do an anonymous inline function (yuck, too bad lua
doesn't have a proper ternary operator!) doesn't have a proper ternary operator!)
@ -78,35 +77,37 @@ test:
%i = 0 %i = 0
=== %loop === === %loop ===
%i += 1 %i += 1
unless (%i == 10): go to %loop unless (%i == 10):
go to %loop
assume (%i == 10) assume (%i == 10)
=== (Loop) === === (Loop) ===
%i -= 1 %i -= 1
unless (%i == 0): go to (Loop) unless (%i == 0):
go to (Loop)
assume (%i == 0) assume (%i == 0)
[=== %label ===, --- %label ---, *** %label ***] all compile to "\ [=== %label ===, --- %label ---, *** %label ***] all compile to "\
..::label_\(..) ..::label_\((%label.stub if (%label.type == "Action") else %label) as lua identifier)::"
(%label.stub if (%label.type == "Action") else %label) as lua identifier
..::"
(go to %label) compiles to "\ (go to %label) compiles to "\
..goto label_\(..) ..goto label_\((%label.stub if (%label.type == "Action") else %label) as lua identifier)"
(%label.stub if (%label.type == "Action") else %label) as lua identifier
.."
# Basic loop control # Basic loop control
(stop %var) compiles to: (stop %var) compiles to:
if %var: if %var:
return (..) return (Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)")
Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)" ..else:
..else: return (Lua "break") return (Lua "break")
(do next %var) compiles to: (do next %var) compiles to:
if %var: if %var:
return (..) return (Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)")
Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)" ..else:
..else: return (Lua "goto continue") return (Lua "goto continue")
[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\ [===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\
..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::" ..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
[===next %var ===, ---next %var ---, ***next %var ***] all compile to "\ [===next %var ===, ---next %var ---, ***next %var ***] all compile to "\
..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::" ..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
@ -116,32 +117,31 @@ test:
repeat while (%x < 10): %x += 1 repeat while (%x < 10): %x += 1
assume (%x == 10) assume (%x == 10)
repeat while (%x < 20): stop repeat while (%x < 20): stop
repeat while (%x < 20): stop repeating repeat while (%x < 20):
stop repeating
assume (%x == 10) assume (%x == 10)
repeat while (%x < 20): repeat while (%x < 20):
%x += 1 %x += 1
if (yes): do next if (yes):
do next
barf "Failed to 'do next'" barf "Failed to 'do next'"
assume (%x == 20) assume (%x == 20)
repeat while (%x < 30): repeat while (%x < 30):
%x += 1 %x += 1
if (yes): do next repeat if (yes):
do next repeat
barf "Failed to 'do next repeat'" barf "Failed to 'do next repeat'"
assume (%x == 30) assume (%x == 30)
(do next repeat) compiles to "goto continue_repeat" (do next repeat) compiles to "goto continue_repeat"
(stop repeating) compiles to "goto stop_repeat" (stop repeating) compiles to "goto stop_repeat"
(repeat while %condition %body) compiles to: (repeat while %condition %body) compiles to:
%lua = (..) %lua = (Lua "while \(%condition as lua expr) do\n \(%body as lua)")
Lua "\
..while \(%condition as lua expr) do
\(%body as lua)"
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next repeat)): if (%body has subtree \(do next repeat)):
%lua::append "\n ::continue_repeat::" %lua::append "\n ::continue_repeat::"
%lua::append "\nend --while-loop" %lua::append "\nend --while-loop"
if (%body has subtree \(stop repeating)): if (%body has subtree \(stop repeating)):
%inner_lua = %lua %inner_lua = %lua
@ -150,25 +150,24 @@ test:
.. ..
::stop_repeat:: ::stop_repeat::
end -- end of 'stop repeating' label scope" end -- end of 'stop repeating' label scope"
return %lua return %lua
(repeat %body) parses as (repeat while (yes) %body) (repeat %body) parses as (repeat while (yes) %body)
(repeat until %condition %body) parses as (repeat while (not %condition) %body) (repeat until %condition %body) parses as (repeat while (not %condition) %body)
test: test:
%x = 0 %x = 0
repeat 10 times: %x += 1 repeat 10 times: %x += 1
assume (%x == 10) assume (%x == 10)
(repeat %n times %body) compiles to: (repeat %n times %body) compiles to:
define mangler define mangler
%lua = (..) %lua = (Lua "for \(mangle "i")=1,\(%n as lua expr) do\n ")
Lua "for \(mangle "i")=1,\(%n as lua expr) do\n "
%lua::append (%body as lua) %lua::append (%body as lua)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next repeat)): if (%body has subtree \(do next repeat)):
%lua::append "\n ::continue_repeat::" %lua::append "\n ::continue_repeat::"
%lua::append "\nend --numeric for-loop" %lua::append "\nend --numeric for-loop"
if (%body has subtree \(stop repeating)): if (%body has subtree \(stop repeating)):
%inner_lua = %lua %inner_lua = %lua
@ -177,17 +176,18 @@ test:
.. ..
::stop_repeat:: ::stop_repeat::
end -- end of 'stop repeating' label scope" end -- end of 'stop repeating' label scope"
return %lua return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
%nums = [] %nums = []
for %x in 1 to 5: %nums::add %x for %x in 1 to 5:
%nums::add %x
assume (%nums == [1, 2, 3, 4, 5]) assume (%nums == [1, 2, 3, 4, 5])
%nums = [] %nums = []
for %x in 1 to 5 via 2: %nums::add %x for %x in 1 to 5 via 2:
%nums::add %x
assume (%nums == [1, 3, 5]) assume (%nums == [1, 3, 5])
%nums = [] %nums = []
for %outer in 1 to 100: for %outer in 1 to 100:
@ -195,10 +195,9 @@ test:
if (%inner == 2): if (%inner == 2):
%nums::add -2 %nums::add -2
do next %inner do next %inner
%nums::add %inner %nums::add %inner
if (%inner == 5): stop %outer if (%inner == 5):
stop %outer
assume (%nums == [1, -2, 3, -2, 3, 4, 3, 4, 5]) assume (%nums == [1, -2, 3, -2, 3, 4, 3, 4, 5])
# Numeric range for loops # Numeric range for loops
@ -209,15 +208,11 @@ test:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%var.type is "Var"): unless (%var.type is "Var"):
compile error at %var "Expected a variable here, not a \(%var.type)" compile error at %var "Expected a variable here, not a \(%var.type)"
%lua = (..) %lua = (Lua "for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do")
Lua "\
..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
%step as lua expr
.. do"
%lua::append "\n " (%body as lua) %lua::append "\n " (%body as lua)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append "\n " (what (===next %var ===) compiles to) %lua::append "\n " (what (===next %var ===) compiles to)
@ -228,7 +223,6 @@ test:
%lua::append %inner_lua "\n " %lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to) %lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop" %lua::append "\nend -- end of scope for stopping for-loop"
return %lua return %lua
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -239,25 +233,33 @@ test:
test: test:
%a = [10, 20, 30, 40, 50] %a = [10, 20, 30, 40, 50]
%b = [] %b = []
for %x in %a: %b::add %x for %x in %a:
%b::add %x
assume (%a == %b) assume (%a == %b)
%b = [] %b = []
for %x in %a: for %x in %a:
if (%x == 10): do next %x if (%x == 10):
if (%x == 50): stop %x do next %x
%b::add %x
if (%x == 50):
stop %x
%b::add %x
assume (%b == [20, 30, 40]) assume (%b == [20, 30, 40])
# For-each loop (lua's "ipairs()") # For-each loop (lua's "ipairs()")
(for %var in %iterable %body) compiles to: (for %var in %iterable %body) compiles to:
define mangler define mangler
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
%lua = (..) %lua = (..)
Lua "for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do\n " Lua "\
..for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
"
%lua::append (%body as lua) %lua::append (%body as lua)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append "\n " (what (===next %var ===) compiles to) %lua::append "\n " (what (===next %var ===) compiles to)
@ -268,17 +270,19 @@ test:
%lua::append %inner_lua "\n " %lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to) %lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop" %lua::append "\nend -- end of scope for stopping for-loop"
return %lua return %lua
# TODO: reduce code duplication # TODO: reduce code duplication
(for %var in %iterable at %i %body) compiles to: (for %var in %iterable at %i %body) compiles to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
%lua = (..) %lua = (..)
Lua "for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do\n " Lua "\
..for \(%i as lua identifier),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
"
%lua::append (%body as lua) %lua::append (%body as lua)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append "\n " (what (===next %var ===) compiles to) %lua::append "\n " (what (===next %var ===) compiles to)
@ -289,37 +293,36 @@ test:
%lua::append %inner_lua "\n " %lua::append %inner_lua "\n "
%lua::append (what (===stop %var ===) compiles to) %lua::append (what (===stop %var ===) compiles to)
%lua::append "\nend -- end of scope for stopping for-loop" %lua::append "\nend -- end of scope for stopping for-loop"
return %lua return %lua
test: test:
%d = {a:10, b:20, c:30, d:40, e:50} %d = {a: 10, b: 20, c: 30, d: 40, e: 50}
%result = [] %result = []
for %k = %v in %d: for %k = %v in %d:
if (%k == "a"): do next %k if (%k == "a"):
if (%v == 20): do next %v do next %k
%result::add "\%k = \%v"
if (%v == 20):
do next %v
%result::add "\%k = \%v"
assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"]) assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"])
# Dict iteration (lua's "pairs()") # Dict iteration (lua's "pairs()")
[..] [for %key = %value in %iterable %body, for %key %value in %iterable %body] \
for %key = %value in %iterable %body, for %key %value in %iterable %body
..all compile to: ..all compile to:
# This uses Lua's approach of only allowing loop-scoped variables in a loop # This uses Lua's approach of only allowing loop-scoped variables in a loop
unless (%key.type is "Var"): unless (%key.type is "Var"):
compile error at %key "Expected a variable here, not a \(%key.type)" compile error at %key "Expected a variable here, not a \(%key.type)"
unless (%value.type is "Var"): unless (%value.type is "Var"):
compile error at %value "Expected a variable here, not a \(%value.type)" compile error at %value "Expected a variable here, not a \(%value.type)"
%lua = (..)
Lua "\
..for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
%iterable as lua expr
..) do"
%lua = (Lua "for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do")
%lua::append "\n " (%body as lua) %lua::append "\n " (%body as lua)
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %key)): if (%body has subtree \(do next %key)):
%lua::append "\n " (what (===next %key ===) compiles to) %lua::append "\n " (what (===next %key ===) compiles to)
@ -350,8 +353,10 @@ test:
(1 == 0) (1 == 1) %not_a_variable.x: do nothing (1 == 0) (1 == 1) %not_a_variable.x: do nothing
(1 == 1): (1 == 1):
barf "bad conditional" barf "bad conditional"
(1 == 2): (1 == 2):
barf "bad conditional" barf "bad conditional"
else: else:
barf "bad conditional" barf "bad conditional"
@ -361,30 +366,29 @@ test:
%clause = "if" %clause = "if"
%else_allowed = (yes) %else_allowed = (yes)
unless (%body.type is "Block"): unless (%body.type is "Block"):
compile error at %body "'if' expected a Block, but got a \(%body.type)." compile error at %body "'if' expected a Block, but got a \(%body.type)." "\
..hint "Perhaps you forgot to put a ':' after 'if'?" ..Perhaps you forgot to put a ':' after 'if'?"
for %line in %body: for %line in %body:
unless (..) unless (..)
((%line.type is "Action") and ((size of %line) >= 2)) and (..) ((%line.type is "Action") and ((size of %line) >= 2)) and (..)
%line.(size of %line) is "Block" syntax tree %line.(size of %line) is "Block" syntax tree
..: ..:
compile error at %line "Invalid line for the body of an 'if' block." compile error at %line "Invalid line for the body of an 'if' block." "\
..hint "Each line should contain one or more conditional expressions \ ..Each line should contain one or more conditional expressions followed by a block, or "else" followed \
..followed by a block, or "else" followed by a block." ..by a block."
%action = %line.(size of %line) %action = %line.(size of %line)
if ((%line.1 is "else") and ((size of %line) == 2)): if ((%line.1 is "else") and ((size of %line) == 2)):
unless %else_allowed: unless %else_allowed:
compile error at %line "You can't have two 'else' blocks." compile error at %line "You can't have two 'else' blocks." "\
..hint "Merge all of the 'else' blocks together." ..Merge all of the 'else' blocks together."
unless ((size of "\%code") > 0): unless ((size of "\%code") > 0):
compile error at %line "\ compile error at %line "\
..You can't have an 'else' block without a preceeding condition" ..You can't have an 'else' block without a preceeding condition"
..hint "If you want the code in this block to always execute, you don't \ .."\
..need a conditional block around it. Otherwise, make sure the 'else' \ ..If you want the code in this block to always execute, you don't need a conditional block around it. \
..block comes last." ..Otherwise, make sure the 'else' block comes last."
%code::append "\nelse\n " (%action as lua) %code::append "\nelse\n " (%action as lua)
%else_allowed = (no) %else_allowed = (no)
@ -394,13 +398,13 @@ test:
if (%i > 1): if (%i > 1):
%code::append " or " %code::append " or "
%code::append (%line.%i as lua expr) %code::append (%line.%i as lua expr)
%code::append " then\n " (%action as lua) %code::append " then\n " (%action as lua)
%clause = "\nelseif" %clause = "\nelseif"
if ((size of "\%code") == 0): if ((size of "\%code") == 0):
compile error at %body "'if' block has an empty body." compile error at %body "'if' block has an empty body." "\
..hint "This means nothing would happen, so the 'if' block should be deleted." ..This means nothing would happen, so the 'if' block should be deleted."
%code::append "\nend --when" %code::append "\nend --when"
return %code return %code
@ -408,9 +412,13 @@ test:
if 5 is: if 5 is:
1 2 3: 1 2 3:
barf "bad switch statement" barf "bad switch statement"
4 5: do nothing
4 5:
do nothing
5 6: 5 6:
barf "bad switch statement" barf "bad switch statement"
else: else:
barf "bad switch statement" barf "bad switch statement"
@ -421,28 +429,28 @@ test:
%else_allowed = (yes) %else_allowed = (yes)
define mangler define mangler
unless (%body.type is "Block"): unless (%body.type is "Block"):
compile error at %body "'if' expected a Block, but got a \(%body.type)" compile error at %body "'if' expected a Block, but got a \(%body.type)" "\
..hint "Perhaps you forgot to put a ':' after the 'is'?" ..Perhaps you forgot to put a ':' after the 'is'?"
for %line in %body: for %line in %body:
unless (..) unless (..)
((%line.type is "Action") and ((size of %line) >= 2)) and (..) ((%line.type is "Action") and ((size of %line) >= 2)) and (..)
%line.(size of %line) is "Block" syntax tree %line.(size of %line) is "Block" syntax tree
..: ..:
compile error at %line "Invalid line for 'if' block." compile error at %line "Invalid line for 'if' block." "\
..hint "Each line should contain expressions \ ..Each line should contain expressions followed by a block, or "else" followed by a block"
..followed by a block, or "else" followed by a block"
%action = %line.(size of %line) %action = %line.(size of %line)
if ((%line.1 is "else") and ((size of %line) == 2)): if ((%line.1 is "else") and ((size of %line) == 2)):
unless %else_allowed: unless %else_allowed:
compile error at %line "You can't have two 'else' blocks." compile error at %line "You can't have two 'else' blocks." "\
..hint "Merge all of the 'else' blocks together." ..Merge all of the 'else' blocks together."
unless ((size of "\%code") > 0): unless ((size of "\%code") > 0):
compile error at %line "\ compile error at %line "\
..You can't have an 'else' block without a preceeding condition" ..You can't have an 'else' block without a preceeding condition"
..hint "If you want the code in this block to always execute, you don't \ .."\
..need a conditional block around it. Otherwise, make sure the 'else' \ ..If you want the code in this block to always execute, you don't need a conditional block around it. \
..block comes last." ..Otherwise, make sure the 'else' block comes last."
%code::append "\nelse\n " (%action as lua) %code::append "\nelse\n " (%action as lua)
%else_allowed = (no) %else_allowed = (no)
@ -452,13 +460,13 @@ test:
if (%i > 1): if (%i > 1):
%code::append " or " %code::append " or "
%code::append "\(mangle "branch value") == " (%line.%i as lua expr) %code::append "\(mangle "branch value") == " (%line.%i as lua expr)
%code::append " then\n " (%action as lua) %code::append " then\n " (%action as lua)
%clause = "\nelseif" %clause = "\nelseif"
if ((size of "\%code") == 0): if ((size of "\%code") == 0):
compile error at %body "'if' block has an empty body." compile error at %body "'if' block has an empty body." "\
..hint "This means nothing would happen, so the 'if' block should be deleted." ..This means nothing would happen, so the 'if' block should be deleted."
%code::append "\nend --when" %code::append "\nend --when"
return (..) return (..)
Lua "\ Lua "\
@ -468,19 +476,17 @@ test:
end -- if % is..." end -- if % is..."
# Do/finally # Do/finally
(do %action) compiles to "\ (do %action) compiles to "do\n \(%action as lua)\nend -- do"
..do
\(%action as lua)
end -- do"
test: test:
%d = {} %d = {}
try: try:
do: do:
%d.x = "bad" %d.x = "bad"
barf barf
..then always: %d.x = "good" ..then always:
%d.x = "good"
assume (%d.x == "good") assume (%d.x == "good")
(do %action then always %final_action) compiles to: (do %action then always %final_action) compiles to:
define mangler define mangler
return (..) return (..)
@ -497,19 +503,19 @@ test:
end" end"
test: test:
assume ((result of (: return 99)) == 99) assume ((result of: return 99) == 99)
# Inline thunk: # Inline thunk:
(result of %body) compiles to "\(what ([] -> %body) compiles to)()" (result of %body) compiles to "\(what ([] -> %body) compiles to)()"
test: test:
%t = [1, [2, [[3], 4], 5, [[[6]]]]] %t = [1, [2, [[3], 4], 5, [[[6]]]]]
%flat = [] %flat = []
for % in recursive %t: for % in recursive %t:
if ((lua type of %) is "table"): if ((lua type of %) is "table"):
for %2 in %: recurse % on %2 for %2 in %:
..else: %flat::add % recurse % on %2
..else:
%flat::add %
assume (sorted %flat) == [1, 2, 3, 4, 5, 6] assume (sorted %flat) == [1, 2, 3, 4, 5, 6]
# Recurion control flow # Recurion control flow
@ -518,6 +524,7 @@ test:
define mangler define mangler
(recurse %v on %x) compiles to (..) (recurse %v on %x) compiles to (..)
Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))" Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))"
%lua = (..) %lua = (..)
Lua "\ Lua "\
..do ..do
@ -525,10 +532,13 @@ test:
while #\(mangle "stack \(%var.1)") > 0 do while #\(mangle "stack \(%var.1)") > 0 do
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1) \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
\(%body as lua)" \(%body as lua)"
if (%body has subtree \(do next)): if (%body has subtree \(do next)):
%lua::append "\n ::continue::" %lua::append "\n ::continue::"
if (%body has subtree \(do next %var)): if (%body has subtree \(do next %var)):
%lua::append "\n \(what (===next %var ===) compiles to)" %lua::append "\n \(what (===next %var ===) compiles to)"
%lua::append "\n end -- Recursive loop" %lua::append "\n end -- Recursive loop"
if (%body has subtree \(stop %var)): if (%body has subtree \(stop %var)):
%lua::append "\n \(what (===stop %var ===) compiles to)" %lua::append "\n \(what (===stop %var ===) compiles to)"

7
core/coroutines.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines the code that creates and manipulates coroutines This file defines the code that creates and manipulates coroutines
@ -14,8 +14,11 @@ test:
-> 5 -> 5
repeat 3 times: -> 6 repeat 3 times: -> 6
for % in coroutine %co: %nums::add % for % in coroutine %co:
%nums::add %
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed" assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
[coroutine %body, generator %body] all compile to "\ [coroutine %body, generator %body] all compile to "\
..(function() ..(function()
\(%body as lua) \(%body as lua)

31
core/errors.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains basic error reporting code This file contains basic error reporting code
@ -6,11 +6,11 @@ use "core/metaprogramming.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(barf %msg) compiles to "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);" (barf %msg) compiles to "\
..error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);"
(assume %condition) compiles to: (assume %condition) compiles to:
lua> "\ lua> "local \%assumption = 'Assumption failed: '..tostring((\%condition):get_source_code())"
..local \%assumption = 'Assumption failed: '..tostring((\%condition):get_source_code())"
return (..) return (..)
Lua "\ Lua "\
..if not \(%condition as lua expr) then ..if not \(%condition as lua expr) then
@ -18,17 +18,14 @@ use "core/metaprogramming.nom"
end" end"
(assume %a == %b) compiles to: (assume %a == %b) compiles to:
lua> "\ lua> "local \%assumption = 'Assumption failed: '..tostring(\(\(%a == %b) as nomsu))"
..local \%assumption = 'Assumption failed: '..tostring(\(\(%a == %b) as nomsu))"
define mangler define mangler
return (..) return (..)
Lua "\ Lua "\
..do ..do
local \(mangle "a"), \(mangle "b") = \(%a as lua expr), \(%b as lua expr) local \(mangle "a"), \(mangle "b") = \(%a as lua expr), \(%b as lua expr)
if \(mangle "a") ~= \(mangle "b") then if \(mangle "a") ~= \(mangle "b") then
error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(..) error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(mangle "b")), 0)
mangle "b"
..), 0)
end end
end" end"
@ -38,16 +35,18 @@ use "core/metaprogramming.nom"
end" end"
test: test:
try (barf) and if it succeeds: barf "try failed." try (barf) and if it succeeds:
barf "try failed."
%worked = (no) %worked = (no)
try (barf) and if it barfs: %worked = (yes) try (barf) and if it barfs:
%worked = (yes)
assume %worked or barf "try/catch failed" assume %worked or barf "try/catch failed"
%x = 1 %x = 1
try: try:
%x = 2 %x = 2
do (barf) then always: %x = 3 do (barf) then always: %x = 3
..and if it barfs: do nothing ..and if it barfs:
do nothing
assume (%x == 3) or barf "do/then always failed" assume (%x == 3) or barf "do/then always failed"
# Try/except # Try/except
@ -81,10 +80,10 @@ test:
# #
[..] [..]
try %action and if it succeeds %success or if it barfs %fallback try %action and if it succeeds %success or if it barfs %fallback
try %action and if it barfs %fallback or if it succeeds %success try %action and if it barfs %fallback or if it succeeds %success
..all parse as (..) ..all parse as (..)
try %action and if it succeeds %success or if it barfs (=lua "") %fallback try %action and if it succeeds %success or if it barfs (=lua "") %fallback
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

31
core/id.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
@ -13,21 +13,22 @@ use "core/control_flow.nom"
%NaN_surrogate = {} %NaN_surrogate = {}
%nil_surrogate = {} %nil_surrogate = {}
%obj_by_id = {} %obj_by_id = {}
set %obj_by_id's metatable to {__mode:"v"} set %obj_by_id's metatable to {__mode: "v"}
%id_by_obj = {} %id_by_obj = {}
set %id_by_obj 's metatable to {..} set %id_by_obj's metatable to {..}
__mode:"k", __index: (..) __mode: "k", __index: [%self, %key] ->:
[%self, %key] ->: if (%key == (nil)):
if (%key == (nil)): return %self.%nil_surrogate
return %self.%nil_surrogate
if (%key != %key): if (%key != %key):
return %self.%NaN_surrogate return %self.%NaN_surrogate
--- (retry) ---
%id = (uuid) --- (retry) ---
if (%obj_by_id.%id != (nil)): go to (retry) %id = (uuid)
%self.%key = %id if (%obj_by_id.%id != (nil)): go to (retry)
%obj_by_id.%id = %key %self.%key = %id
return %id %obj_by_id.%id = %key
return %id
externally (uuid) means: externally (uuid) means:
# Set all the other bits to randomly (or pseudo-randomly) chosen values. # Set all the other bits to randomly (or pseudo-randomly) chosen values.

6
core/io.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains basic input/output code This file contains basic input/output code
@ -19,7 +19,5 @@ use "core/metaprogramming.nom"
..if \%prompt.type == "Text" then ..if \%prompt.type == "Text" then
return LuaCode("(io.write(", \(%prompt as lua expr), ") and io.read())"); return LuaCode("(io.write(", \(%prompt as lua expr), ") and io.read())");
else else
return LuaCode("(io.write(tostring(", \(..) return LuaCode("(io.write(tostring(", \(%prompt as lua expr), ")) and io.read())");
%prompt as lua expr
.., ")) and io.read())");
end" end"

135
core/math.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines some common math literals and functions This file defines some common math literals and functions
@ -28,7 +28,6 @@ test:
assume (("5" as a number) == 5) assume (("5" as a number) == 5)
((% as a number)'s meaning) = ((tonumber %)'s meaning) ((% as a number)'s meaning) = ((tonumber %)'s meaning)
((% as number)'s meaning) = ((tonumber %)'s meaning) ((% as number)'s meaning) = ((tonumber %)'s meaning)
test: test:
assume (..) assume (..)
all of [..] all of [..]
@ -36,101 +35,108 @@ test:
arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5 arc tangent 5, arc tangent 5 / 10, hyperbolic sine 5, hyperbolic cosine 5
hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5 hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
..or barf "math functions failed" ..or barf "math functions failed"
[absolute value %, | % |, abs %] all compile to (..) [absolute value %, | % |, abs %] all compile to "math.abs(\(% as lua expr))"
"math.abs(\(% as lua expr))" [square root %, square root of %, √ %, sqrt %] all compile to "\
..math.sqrt(\(% as lua expr))"
[square root %, square root of %, √ %, sqrt %] all compile to (..)
"math.sqrt(\(% as lua expr))"
[sine %, sin %] all compile to "math.sin(\(% as lua expr))" [sine %, sin %] all compile to "math.sin(\(% as lua expr))"
[cosine %, cos %] all compile to "math.cos(\(% as lua expr))" [cosine %, cos %] all compile to "math.cos(\(% as lua expr))"
[tangent %, tan %] all compile to "math.tan(\(% as lua expr))" [tangent %, tan %] all compile to "math.tan(\(% as lua expr))"
[arc sine %, asin %] all compile to "math.asin(\(% as lua expr))" [arc sine %, asin %] all compile to "math.asin(\(% as lua expr))"
[arc cosine %, acos %] all compile to "math.acos(\(% as lua expr))" [arc cosine %, acos %] all compile to "math.acos(\(% as lua expr))"
[arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))" [arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))"
[arc tangent %y / %x, atan2 %y %x] all compile to (..) [arc tangent %y / %x, atan2 %y %x] all compile to "\
"math.atan2(\(%y as lua expr), \(%x as lua expr))" ..math.atan2(\(%y as lua expr), \(%x as lua expr))"
[hyperbolic sine %, sinh %] all compile to "math.sinh(\(% as lua expr))"
[hyperbolic sine %, sinh %] all compile to (..) [hyperbolic cosine %, cosh %] all compile to "math.cosh(\(% as lua expr))"
"math.sinh(\(% as lua expr))" [hyperbolic tangent %, tanh %] all compile to "math.tanh(\(% as lua expr))"
[hyperbolic cosine %, cosh %] all compile to (..)
"math.cosh(\(% as lua expr))"
[hyperbolic tangent %, tanh %] all compile to (..)
"math.tanh(\(% as lua expr))"
[e^ %, exp %] all compile to "math.exp(\(% as lua expr))" [e^ %, exp %] all compile to "math.exp(\(% as lua expr))"
[natural log %, ln %, log %] all compile to (..) [natural log %, ln %, log %] all compile to "math.log(\(% as lua expr))"
"math.log(\(% as lua expr))" [log % base %base, log base %base of %] all compile to "\
..math.log(\(% as lua expr), \(%base as lua expr))"
[log % base %base, log base %base of %] all compile to (..)
"math.log(\(% as lua expr), \(%base as lua expr))"
(floor %) compiles to "math.floor(\(% as lua expr))" (floor %) compiles to "math.floor(\(% as lua expr))"
[ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))" [ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))"
[round %, % rounded] all compile to (..) [round %, % rounded] all compile to "math.floor(\(% as lua expr) + .5)"
"math.floor(\(% as lua expr) + .5)"
test: test:
assume ((463 to the nearest 100) == 500) or barf "rounding failed" assume ((463 to the nearest 100) == 500) or barf "rounding failed"
assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed" assume ((2.6 to the nearest 0.25) == 2.5) or barf "rounding failed"
externally (%n to the nearest %rounder) means (..) externally (%n to the nearest %rounder) means (..)
=lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)" =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
# Any/all # Any/all
externally [all of %items, all %items] all mean: externally [all of %items, all %items] all mean:
for % in %items: for % in %items:
unless %: return (no) unless %:
return (no)
return (yes) return (yes)
[all of %items, all %items] all compile to: [all of %items, all %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(all of %items) return \(all of %items)
if ((size of %items) == 0): return (Lua "true")
if ((size of %items) == 0):
return (Lua "true")
%lua = (Lua "(") %lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " and " %lua::add [: for % in %items: add (% as lua expr)] joined with " and "
%lua::append ")" %lua::append ")"
return %lua return %lua
[not all of %items, not all %items] all parse as (not (all of %items))
[not all of %items, not all %items] all parse as (not (all of %items))
externally [any of %items, any %items] all mean: externally [any of %items, any %items] all mean:
for % in %items: for % in %items:
if %: return (yes) if %:
return (yes)
return (no) return (no)
[any of %items, any %items] all compile to: [any of %items, any %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(any of %items) return \(any of %items)
if ((size of %items) == 0): return (Lua "false")
if ((size of %items) == 0):
return (Lua "false")
%lua = (Lua "(") %lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " or " %lua::add [: for % in %items: add (% as lua expr)] joined with " or "
%lua::append ")" %lua::append ")"
return %lua return %lua
[none of %items, none %items] all parse as (not (any of %items)) [none of %items, none %items] all parse as (not (any of %items))
# Sum/product # Sum/product
externally [sum of %items, sum %items] all mean: externally [sum of %items, sum %items] all mean:
%total = 0 %total = 0
for % in %items: %total += % for % in %items:
%total += %
return %total return %total
[sum of %items, sum %items] all compile to: [sum of %items, sum %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(sum of %items) return \(sum of %items)
if ((size of %items) == 0): return (Lua "0")
if ((size of %items) == 0):
return (Lua "0")
%lua = (Lua "(") %lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " + " %lua::add [: for % in %items: add (% as lua expr)] joined with " + "
%lua::append ")" %lua::append ")"
return %lua return %lua
externally [product of %items, product %items] all mean: externally [product of %items, product %items] all mean:
%prod = 1 %prod = 1
for % in %items: %prod *= % for % in %items:
%prod *= %
return %prod return %prod
[product of %items, product %items] all compile to: [product of %items, product %items] all compile to:
unless (%items.type is "List"): unless (%items.type is "List"):
return \(product of %items) return \(product of %items)
if ((size of %items) == 0): return (Lua "1")
if ((size of %items) == 0):
return (Lua "1")
%lua = (Lua "(") %lua = (Lua "(")
%lua::add ((% as lua expr) for % in %items) joined with " * " %lua::add [: for % in %items: add (% as lua expr)] joined with " * "
%lua::append ")" %lua::append ")"
return %lua return %lua
@ -156,45 +162,43 @@ externally [avg of %items, average of %items] all mean (..)
[unless none of %items %body, unless none of %items then %body] all parse as (..) [unless none of %items %body, unless none of %items then %body] all parse as (..)
if (any of %items) %body if (any of %items) %body
[if all of %items %body else %else, if all of %items then %body else %else] all parse \ [if all of %items %body else %else, if all of %items then %body else %else] \
..as (if (all of %items) %body else %else) ..all parse as (if (all of %items) %body else %else)
[..] [unless all of %items %body else %else, unless all of %items then %body else %else] \
unless all of %items %body else %else, unless all of %items then %body else %else
..all parse as (if (not (all of %items)) %body else %else) ..all parse as (if (not (all of %items)) %body else %else)
[if any of %items %body else %else, if any of %items then %body else %else] all parse \ [if any of %items %body else %else, if any of %items then %body else %else] \
..as (if (any of %items) %body else %else) ..all parse as (if (any of %items) %body else %else)
[..] [unless any of %items %body else %else, unless any of %items then %body else %else] \
unless any of %items %body else %else, unless any of %items then %body else %else
..all parse as (if (not (any of %items)) %body else %else) ..all parse as (if (not (any of %items)) %body else %else)
[if none of %items %body else %else, if none of %items then %body else %else] all \ [if none of %items %body else %else, if none of %items then %body else %else] \
..parse as (if (not (any of %items)) %body else %else) ..all parse as (if (not (any of %items)) %body else %else)
[..] [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
..all parse as (if (any of %items) %body else %else) ..all parse as (if (any of %items) %body else %else)
# Min/max # Min/max
externally [min of %items, smallest of %items, lowest of %items] all mean: externally [min of %items, smallest of %items, lowest of %items] all mean:
%best = (nil) %best = (nil)
for % in %items: for % in %items:
if ((%best == (nil)) or (% < %best)): if ((%best == (nil)) or (% < %best)): %best = %
%best = %
return %best return %best
externally [max of %items, biggest of %items, largest of %items, highest of %items] all mean: externally [..]
max of %items, biggest of %items, largest of %items, highest of %items
..all mean:
%best = (nil) %best = (nil)
for % in %items: for % in %items:
if ((%best == (nil)) or (% > %best)): if ((%best == (nil)) or (% > %best)): %best = %
%best = %
return %best return %best
test: test:
assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1) assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1)
assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4) assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4)
(min of %items by %item = %value_expr) parses as (..) (min of %items by %item = %value_expr) parses as (..)
result of: result of:
%best = (nil) %best = (nil)
@ -219,17 +223,14 @@ test:
# Random functions # Random functions
externally (seed random with %) means: externally (seed random with %) means:
lua> "\ lua> "math.randomseed(\%);\nfor i=1,20 do math.random(); end"
..math.randomseed(\%);
for i=1,20 do math.random(); end"
(seed random) parses as (seed random with (=lua "os.time()")) (seed random) parses as (seed random with (=lua "os.time()"))
[random number, random, rand] all compile to "math.random()" [random number, random, rand] all compile to "math.random()"
[random int %n, random integer %n, randint %n] all compile to (..) [random int %n, random integer %n, randint %n] all compile to "\
"math.random(\(%n as lua expr))" ..math.random(\(%n as lua expr))"
[random from %low to %high, random number from %low to %high, rand %low %high] all \ [random from %low to %high, random number from %low to %high, rand %low %high] \
..compile to "math.random(\(%low as lua expr), \(%high as lua expr))" ..all compile to "math.random(\(%low as lua expr), \(%high as lua expr))"
externally [..] externally [..]
random choice from %elements, random choice %elements, random %elements random choice from %elements, random choice %elements, random %elements

68
core/metaprogramming.nom
View File

@ -1,11 +1,9 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This File contains actions for making actions and compile-time actions and some helper This File contains actions for making actions and compile-time actions and some helper
functions to make that easier. functions to make that easier.
lua> "\ lua> "NOMSU_CORE_VERSION = 10\nNOMSU_LIB_VERSION = 7"
..NOMSU_CORE_VERSION = 10
NOMSU_LIB_VERSION = 7"
lua> "\ lua> "\
..do ..do
local mangle_index = 0 local mangle_index = 0
@ -25,7 +23,8 @@ lua> "\
..compile.action["1 ->"] = function(compile, \%args, \%body) ..compile.action["1 ->"] = function(compile, \%args, \%body)
local lua = LuaCode("(function(") local lua = LuaCode("(function(")
if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args() end if SyntaxTree:is_instance(\%args) and \%args.type == "Action" then \%args = \%args:get_args() end
local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and compile(a):text() or a end) local lua_args = table.map(\%args, function(a) return SyntaxTree:is_instance(a) and compile(a):text(\
..) or a end)
lua:concat_append(lua_args, ", ") lua:concat_append(lua_args, ", ")
local body_lua = SyntaxTree:is_instance(\%body) and compile(\%body) or \%body local body_lua = SyntaxTree:is_instance(\%body) and 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
@ -49,9 +48,11 @@ lua> "\
test: test:
(five) compiles to "5" (five) compiles to "5"
test: test:
assume ((five) == 5) or barf "Compile to expression failed." assume ((five) == 5) or barf "Compile to expression failed."
(loc x) compiles to "local x = 99;" (loc x) compiles to "local x = 99;"
test: test:
lua> "do" lua> "do"
loc x loc x
@ -61,9 +62,11 @@ test:
(asdf) compiles to: (asdf) compiles to:
%tmp = "" %tmp = ""
return (Lua %tmp) return (Lua %tmp)
test: test:
asdf asdf
assume (%tmp is (nil)) or barf "compile to is leaking variables" assume (%tmp is (nil)) or barf "compile to is leaking variables"
lua> "\ lua> "\
..compile.action["1 compiles to"] = function(compile, \%action, \%body) ..compile.action["1 compiles to"] = function(compile, \%action, \%body)
local \%args = List{\(\%compile), unpack(\%action:get_args())} local \%args = List{\(\%compile), unpack(\%action:get_args())}
@ -114,11 +117,9 @@ test:
(foo %x) means: (foo %x) means:
%y = (%x + 1) %y = (%x + 1)
return %y return %y
assume ((foo 10) == 11) or barf "Action didn't work." assume ((foo 10) == 11) or barf "Action didn't work."
assume (%y is (nil)) or barf "Action leaked a local into globals." assume (%y is (nil)) or barf "Action leaked a local into globals."
(baz %) parses as (foo %) (baz %) parses as (foo %)
assume ((foo 1) == "outer") assume ((foo 1) == "outer")
(%action means %body) compiles to: (%action means %body) compiles to:
@ -128,6 +129,7 @@ test:
local lua = LuaCode(fn_name, " = ", \(what (%args -> %body) compiles to)) local lua = LuaCode(fn_name, " = ", \(what (%args -> %body) compiles to))
lua:add_free_vars({fn_name}) lua:add_free_vars({fn_name})
return lua" return lua"
(%actions all mean %body) compiles to: (%actions all mean %body) compiles to:
lua> "\ lua> "\
..local fn_name = \%actions[1].stub:as_lua_id() ..local fn_name = \%actions[1].stub:as_lua_id()
@ -148,16 +150,20 @@ test:
return lua" return lua"
test: test:
externally (baz1) means: return "baz1" externally (baz1) means:
return "baz1"
externally (baz2) means "baz2" externally (baz2) means "baz2"
test: test:
assume ((baz1) == "baz1") assume ((baz1) == "baz1")
assume ((baz2) == "baz2") assume ((baz2) == "baz2")
(externally %action means %body) compiles to: (externally %action means %body) compiles to:
lua> "\ lua> "\
..local lua = \(what (%action means %body) compiles to) ..local lua = \(what (%action means %body) compiles to)
lua:remove_free_vars({\%action.stub:as_lua_id()}) lua:remove_free_vars({\%action.stub:as_lua_id()})
return lua" return lua"
(externally %actions all mean %body) compiles to: (externally %actions all mean %body) compiles to:
lua> "\ lua> "\
..local lua = \(what (%actions all mean %body) compiles to) ..local lua = \(what (%actions all mean %body) compiles to)
@ -166,23 +172,25 @@ test:
test: test:
assume (((say %)'s meaning) == (=lua "say")) assume (((say %)'s meaning) == (=lua "say"))
(%action's meaning) compiles to (Lua (%action.stub as lua id))
(%action's meaning) compiles to (Lua (%action.stub as lua id))
test: test:
(swap %x and %y) parses as (..) (swap %x and %y) parses as (..)
do: do:
%tmp = %x %tmp = %x
%x = %y %x = %y
%y = %tmp %y = %tmp
test: test:
set {%1:1, %2:2} set {%1: 1, %2: 2}
swap %1 and %2 swap %1 and %2
assume ((%1 == 2) and (%2 == 1)) or barf "\ assume ((%1 == 2) and (%2 == 1)) or barf "\
..'parse % as %' failed on 'swap % and %'" ..'parse % as %' failed on 'swap % and %'"
set {%tmp:1, %tmp2:2} set {%tmp: 1, %tmp2: 2}
swap %tmp and %tmp2 swap %tmp and %tmp2
assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\ assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\
..'parse % as %' variable mangling failed." ..'parse % as %' variable mangling failed."
(%actions all parse as %body) compiles to: (%actions all parse as %body) compiles to:
lua> "\ lua> "\
..local replacements = {} ..local replacements = {}
@ -197,7 +205,8 @@ test:
if replacements[t[1]] then if replacements[t[1]] then
return replacements[t[1]] return replacements[t[1]]
else else
return "SyntaxTree{mangle("..t[1]:as_lua().."), type="..t.type:as_lua()..", source="..tostring(t.source):as_lua().."}" return "SyntaxTree{mangle("..t[1]:as_lua().."), type="..t.type:as_lua()..", source="..tostring(\
..t.source):as_lua().."}"
end end
elseif SyntaxTree:is_instance(t) then elseif SyntaxTree:is_instance(t) then
local ret = {} local ret = {}
@ -227,12 +236,10 @@ test:
local ret = \(what (%actions all compile to %new_body) compiles to) local ret = \(what (%actions all compile to %new_body) compiles to)
return ret" return ret"
~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[%action parses as %body] all parse as ([%action] all parse as %body) [%action parses as %body] all parse as ([%action] all parse as %body)
(%tree as lua expr) compiles to "compile(\(=lua "compile(\%tree, true)"), true)"
(%tree as lua expr) compiles to "\
..compile(\(=lua "compile(\%tree, true)"), true)"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -257,7 +264,10 @@ externally (% is %kind syntax tree) means (..)
(%tree with %t -> %replacement) compiles to "\ (%tree with %t -> %replacement) compiles to "\
..\(%tree as lua expr):map(function(\(%t as lua expr)) ..\(%tree as lua expr):map(function(\(%t as lua expr))
\((%replacement as lua) if (%replacement.type == "Block") else ("return \(%replacement as lua expr)")) \(..)
(%replacement as lua) if (%replacement.type == "Block") else "\
..return \(%replacement as lua expr)"
..
end)" end)"
externally (%tree with vars %replacements) means (..) externally (%tree with vars %replacements) means (..)
@ -317,14 +327,9 @@ externally (%tree with %patt ~> %replacement) means:
end)" end)"
test: test:
assume (..) assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"")
(..)
quote "\
..one
"two""
..== "\"one\\n\\\"two\\\"\""
(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
test: test:
assume (lua type of {}) == "table" assume (lua type of {}) == "table"
assume (type of {}) == "Dict" assume (type of {}) == "Dict"
@ -346,8 +351,8 @@ externally (type of %) means:
return lua_type" return lua_type"
[% is a %type, % is an %type] all parse as ((type of %) == %type) [% is a %type, % is an %type] all parse as ((type of %) == %type)
[% isn't a %type, % isn't an %type, % is not a %type, % is not an %type] all parse as (..) [% isn't a %type, % isn't an %type, % is not a %type, % is not an %type] \
(type of %) != %type ..all parse as ((type of %) != %type)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -357,18 +362,14 @@ test:
run "external %passed = (yes)" run "external %passed = (yes)"
assume %passed assume %passed
assume (run \(return \(\(5) + \(5)))) == 10 assume (run \(return \(\(5) + \(5)))) == 10
(run %nomsu_code) compiles to "\ (run %nomsu_code) compiles to "run_1_in(\(%nomsu_code as lua expr), _ENV)"
..run_1_in(\(%nomsu_code as lua expr), _ENV)"
[compile %block, compiled %block, %block compiled] all compile to "\ [compile %block, compiled %block, %block compiled] all compile to "\
..compile(\(%block as lua))" ..compile(\(%block as lua))"
# Return statement is wrapped in a do..end block because Lua is unhappy if you # Return statement is wrapped in a do..end block because Lua is unhappy if you
put code after a return statement, unless you wrap it in a block. put code after a return statement, unless you wrap it in a block.
(return %return_value) compiles to "\ (return %return_value) compiles to "\
..do return \(..) ..do return \(=lua "\%return_value and \(%return_value as lua expr) or ''") end"
=lua "\%return_value and \(%return_value as lua expr) or ''"
.. end"
# Literals # Literals
(yes) compiles to "true" (yes) compiles to "true"
@ -392,5 +393,4 @@ test:
end" end"
externally (Nomsu version) means: externally (Nomsu version) means:
return "\ return "\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)"
..\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)"

57
core/operators.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains definitions of operators like "+" and "and". This file contains definitions of operators like "+" and "and".
@ -16,7 +16,6 @@ test:
(%x <= %y) compiles to "(\(%x as lua expr) <= \(%y as lua expr))" (%x <= %y) compiles to "(\(%x as lua expr) <= \(%y as lua expr))"
(%x >= %y) compiles to "(\(%x as lua expr) >= \(%y as lua expr))" (%x >= %y) compiles to "(\(%x as lua expr) >= \(%y as lua expr))"
[%a is %b, %a == %b] all compile to "(\(%a as lua expr) == \(%b as lua expr))" [%a is %b, %a == %b] all compile to "(\(%a as lua expr) == \(%b as lua expr))"
[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to "\ [%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to "\
..(\(%a as lua expr) ~= \(%b as lua expr))" ..(\(%a as lua expr) ~= \(%b as lua expr))"
@ -38,9 +37,9 @@ test:
return lua" return lua"
test: test:
set {%x:10, %y:20} set {%x: 10, %y: 20}
assume ((%x == 10) and (%y == 20)) or barf "mutli-assignment failed." assume ((%x == 10) and (%y == 20)) or barf "mutli-assignment failed."
set {%x:%y, %y:%x} set {%x: %y, %y: %x}
assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed." assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed."
# Simultaneous mutli-assignments like: x,y,z = 1,x,3; # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
@ -48,6 +47,7 @@ test:
(set %assignments) compiles to: (set %assignments) compiles to:
assume (%assignments.type is "Dict") or barf "\ assume (%assignments.type is "Dict") or barf "\
..Expected a Dict for the assignments part of '<- %' statement, not \%assignments" ..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
lua> "\ lua> "\
..local lhs, rhs = LuaCode(), LuaCode() ..local lhs, rhs = LuaCode(), LuaCode()
for i, item in ipairs(\%assignments) do for i, item in ipairs(\%assignments) do
@ -74,40 +74,37 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test: test:
set {%foozle:"outer", %y:"outer"} set {%foozle: "outer", %y: "outer"}
externally (set global x local y) means: externally (set global x local y) means:
external %foozle = "inner" external %foozle = "inner"
%y = "inner" %y = "inner"
set global x local y set global x local y
assume ((%foozle == "inner") and (%y == "outer")) or barf "external failed." assume ((%foozle == "inner") and (%y == "outer")) or barf "external failed."
(external %var = %value) compiles to "\(%var as lua) = \(%value as lua)" (external %var = %value) compiles to "\(%var as lua) = \(%value as lua)"
test: test:
set {%foozle:"outer", %y:"outer"} set {%foozle: "outer", %y: "outer"}
externally (set global x local y) means: externally (set global x local y) means:
with external [%foozle]: with external [%foozle]:
%foozle = "inner" %foozle = "inner"
%y = "inner" %y = "inner"
set global x local y set global x local y
assume ((%foozle == "inner") and (%y == "outer")) or barf "\ assume ((%foozle == "inner") and (%y == "outer")) or barf "\
..'with external' failed." ..'with external' failed."
(with external %externs %body) compiles to: (with external %externs %body) compiles to:
%body_lua = (%body as lua) %body_lua = (%body as lua)
lua> "\ lua> "\%body_lua:remove_free_vars(table.map(\%externs, function(v) return compile(v):text() end))"
..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return compile(v):text() end))"
return %body_lua return %body_lua
test: test:
set {%x:1, %y:2} set {%x: 1, %y: 2}
with {%z:nil, %x:999}: with {%z: nil, %x: 999}:
%z = 999 %z = 999
assume (%z == 999) or barf "'with' failed." assume (%z == 999) or barf "'with' failed."
assume (%x == 999) or barf "'with' assignment failed." assume (%x == 999) or barf "'with' assignment failed."
assume (%x == 1) or barf "'with' scoping failed" assume (%x == 1) or barf "'with' scoping failed"
assume (%z == (nil)) or barf "'with' scoping failed" assume (%z == (nil)) or barf "'with' scoping failed"
(with %assignments %body) compiles to: (with %assignments %body) compiles to:
%lua = (%body as lua) %lua = (%body as lua)
lua> "\ lua> "\
@ -132,18 +129,14 @@ test:
end end
\%lua:remove_free_vars(vars) \%lua:remove_free_vars(vars)
\%lua:prepend("local ", lhs, " = ", rhs, ";\\n")" \%lua:prepend("local ", lhs, " = ", rhs, ";\\n")"
return (Lua "do\n \%lua\nend -- 'with' block")
return (..)
Lua "\
..do
\%lua
end -- 'with' block"
# Math Operators # Math Operators
test: test:
assume ((5 wrapped around 2) == 1) or barf "mod not working" assume ((5 wrapped around 2) == 1) or barf "mod not working"
[%x wrapped around %y, %x mod %y] all compile to (..)
"((\(%x as lua expr)) % (\(%y as lua expr)))" [%x wrapped around %y, %x mod %y] all compile to "\
..((\(%x as lua expr)) % (\(%y as lua expr)))"
# 3-part chained comparisons # 3-part chained comparisons
# (uses a lambda to avoid re-evaluating middle value, while still being an expression) # (uses a lambda to avoid re-evaluating middle value, while still being an expression)
@ -152,10 +145,10 @@ test:
(one) means: (one) means:
external %calls = (%calls + 1) external %calls = (%calls + 1)
return 1 return 1
assume (0 <= (one) <= 2) or barf "Three-way chained comparison failed." assume (0 <= (one) <= 2) or barf "Three-way chained comparison failed."
assume (%calls == 1) or barf "\ assume (%calls == 1) or barf "\
..Three-way comparison evaluated middle value multiple times" ..Three-way comparison evaluated middle value multiple times"
(%x < %y < %z) parses as (..) (%x < %y < %z) parses as (..)
call ([%a, %b, %c] -> ((%a < %b) and (%b < %c))) with [%x, %y, %z] call ([%a, %b, %c] -> ((%a < %b) and (%b < %c))) with [%x, %y, %z]
@ -206,13 +199,21 @@ test:
fall back to bit.bor(), bit.band(), etc. fall back to bit.bor(), bit.band(), etc.
lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then" lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then"
[NOT %, ~ %] all compile to "bit.bnot(\(% as lua expr))" [NOT %, ~ %] all compile to "bit.bnot(\(% as lua expr))"
[%x OR %y, %x | %y] all compile to "bit.bor(\(%x as lua expr), \(%y as lua expr))" [%x OR %y, %x | %y] all compile to "\
[%x XOR %y, %x ~ %y] all compile to "bit.bxor(\(%x as lua expr), \(%y as lua expr))" ..bit.bor(\(%x as lua expr), \(%y as lua expr))"
[%x AND %y, %x & %y] all compile to "bit.band(\(%x as lua expr), \(%y as lua expr))"
[%x XOR %y, %x ~ %y] all compile to "\
..bit.bxor(\(%x as lua expr), \(%y as lua expr))"
[%x AND %y, %x & %y] all compile to "\
..bit.band(\(%x as lua expr), \(%y as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to "\ [%x LSHIFT %shift, %x << %shift] all compile to "\
..bit.lshift(\(%x as lua expr), \(%shift as lua expr))" ..bit.lshift(\(%x as lua expr), \(%shift as lua expr))"
[%x RSHIFT %shift, %x >> %shift] all compile to "\ [%x RSHIFT %shift, %x >> %shift] all compile to "\
..bit.rshift(\(%x as lua expr), \(%shift as lua expr))" ..bit.rshift(\(%x as lua expr), \(%shift as lua expr))"
lua> "else" lua> "else"
[NOT %, ~ %] all compile to "~(\(% as lua expr))" [NOT %, ~ %] all compile to "~(\(% as lua expr))"
[%x OR %y, %x | %y] all compile to "(\(%x as lua expr) | \(%y as lua expr))" [%x OR %y, %x | %y] all compile to "(\(%x as lua expr) | \(%y as lua expr))"
@ -220,8 +221,10 @@ lua> "else"
[%x AND %y, %x & %y] all compile to "(\(%x as lua expr) & \(%y as lua expr))" [%x AND %y, %x & %y] all compile to "(\(%x as lua expr) & \(%y as lua expr))"
[%x LSHIFT %shift, %x << %shift] all compile to "\ [%x LSHIFT %shift, %x << %shift] all compile to "\
..(\(%x as lua expr) << \(%shift as lua expr))" ..(\(%x as lua expr) << \(%shift as lua expr))"
[%x RSHIFT %shift, %x >> %shift] all compile to "\ [%x RSHIFT %shift, %x >> %shift] all compile to "\
..(\(%x as lua expr) >> \(%shift as lua expr))" ..(\(%x as lua expr) >> \(%shift as lua expr))"
lua> "end" lua> "end"
# Unary operators # Unary operators
@ -230,11 +233,9 @@ test:
assume ((not (yes)) == (no)) assume ((not (yes)) == (no))
(- %) compiles to "(- \(% as lua expr))" (- %) compiles to "(- \(% as lua expr))"
(not %) compiles to "(not \(% as lua expr))" (not %) compiles to "(not \(% as lua expr))"
test: test:
assume ((size of [1, 2, 3]) == 3) assume ((size of [1, 2, 3]) == 3)
(size of %list) compiles to "(#\(%list as lua expr))" (size of %list) compiles to "(#\(%list as lua expr))"
(%list is empty) compiles to "(#\(%list as lua expr) == 0)" (%list is empty) compiles to "(#\(%list as lua expr) == 0)"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

24
core/scopes.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains definitions pertaining to variable scoping This file contains definitions pertaining to variable scoping
@ -14,34 +14,26 @@ test:
with local %x: with local %x:
%x = "inner" %x = "inner"
assume (%x == "inner") assume (%x == "inner")
assume (%x == "outer") assume (%x == "outer")
externally (foo) means "outer foo" externally (foo) means "outer foo"
with local [(foo)'s meaning]: with local [(foo)'s meaning]:
externally (foo) means "inner foo" externally (foo) means "inner foo"
assume ((foo) == "inner foo") assume ((foo) == "inner foo")
assume ((foo) == "outer foo") assume ((foo) == "outer foo")
[with local %locals %body, with local %locals do %body] all compile to: [with local %locals %body, with local %locals do %body] all compile to:
%body_lua = (%body as lua) %body_lua = (%body as lua)
if %locals.type is: if %locals.type is:
"Dict": "Dict":
%body_lua = (..) %body_lua = (Lua "\(what (<- %locals) compiles to)\n\%body_lua")
Lua "\ %body_lua::declare locals [: for % in %locals: add "\(%.1 as lua)"]
..\(what (<- %locals) compiles to)
\%body_lua"
%body_lua::declare locals ("\(%.1 as lua)" for % in %locals)
"List": "List":
%body_lua::declare locals ("\(% as lua)" for % in %locals) %body_lua::declare locals [: for % in %locals: add "\(% as lua)"]
"Var" "Action": "Var" "Action":
%body_lua::declare locals ["\(%locals as lua)"] %body_lua::declare locals ["\(%locals as lua)"]
else: else:
compile error at %locals "Unexpected local value" compile error at %locals "Unexpected local value"
return (Lua "do\n \%body_lua\nend")
return (..)
Lua "\
..do
\%body_lua
end"

15
core/text.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains some definitions of text escape sequences, including ANSI console This file contains some definitions of text escape sequences, including ANSI console
color codes. color codes.
@ -27,19 +27,19 @@ test:
assume ("asdf"::with "s" -> "X") == "aXdf" assume ("asdf"::with "s" -> "X") == "aXdf"
assume ("one\ntwo\n"::lines) == ["one", "two", ""] assume ("one\ntwo\n"::lines) == ["one", "two", ""]
(%spec とは %body) parses as (%spec means %body) (%spec とは %body) parses as (%spec means %body)
test: test:
%こんにちは = "こんにちは" %こんにちは = "こんにちは"
(% と言う) とは "\(%)世界" (% と言う) とは "\(%)世界"
assume (%こんにちは と言う) == "こんにちは世界" assume (%こんにちは と言う) == "こんにちは世界"
(%expr for %match in %text matching %patt) compiles to: (%expr for %match in %text matching %patt) compiles to:
define mangler define mangler
return (..) return (..)
Lua "\ Lua "\
..(function() ..(function()
local \(mangle "comprehension") = List{} local \(mangle "comprehension") = List{}
for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..) for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(%patt as lua expr)) do
%patt as lua expr
..) do
\(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua) \(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua)
end end
return \(mangle "comprehension") return \(mangle "comprehension")
@ -50,8 +50,9 @@ test:
# Text literals # Text literals
%escapes = {..} %escapes = {..}
nl:"\n", newline:"\n", tab:"\t", bell:"\a", cr:"\r", "carriage return":"\r", nl: "\n", newline: "\n", tab: "\t", bell: "\a", cr: "\r", "carriage return": "\r"
backspace:"\b", "form feed":"\f", formfeed:"\f", "vertical tab":"\v" backspace: "\b", "form feed": "\f", formfeed: "\f", "vertical tab": "\v"
for %name = %str in %escapes: for %name = %str in %escapes:
with {%lua: Lua (quote %str)}: with {%lua: Lua (quote %str)}:
%compile.action.%name = ([]-> %lua) %compile.action.%name = ([] -> %lua)

32
examples/how_do_i.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# How do I... # How do I...
# Write a comment? Put a # and go till the end of the line # Write a comment? Put a # and go till the end of the line
# How do I write a multi-line comment? # How do I write a multi-line comment?
@ -91,7 +91,7 @@ say %my_list.1
# How do I define a dictionary/hash map? # How do I define a dictionary/hash map?
One-word text keys don't need quotes, otherwise the key is an expression. One-word text keys don't need quotes, otherwise the key is an expression.
If the expression is more complex than a literal, it needs parentheses: If the expression is more complex than a literal, it needs parentheses:
%my_dict = {x:101, y:2, "how many bottles":99, 653:292, (5 + 6):11} %my_dict = {x: 101, y: 2, "how many bottles": 99, 653: 292, (5 + 6): 11}
# How do I use a dict? # How do I use a dict?
# Dicts are also implemented as Lua tables, so they're accessed and modified the same way as lists # Dicts are also implemented as Lua tables, so they're accessed and modified the same way as lists
@ -113,10 +113,13 @@ if (1 > 10):
when: when:
(3 > 3): (3 > 3):
say "this won't print" say "this won't print"
(3 > 6) (3 > 5) (3 > 4): (3 > 6) (3 > 5) (3 > 4):
say "this won't print because none of the conditions on the line above are true" say "this won't print because none of the conditions on the line above are true"
(3 > 2): (3 > 2):
say "this will print" say "this will print"
else: else:
say "this is the default case" say "this is the default case"
@ -124,8 +127,10 @@ when:
if (1 + 2) is: if (1 + 2) is:
0 1: 0 1:
say "this won't print" say "this won't print"
2 3: 2 3:
say "this will print" say "this will print"
else: else:
say "this won't print" say "this won't print"
@ -140,7 +145,9 @@ for %i in 1 to 3:
say "For %i in 1 to 3 loop #\%i" say "For %i in 1 to 3 loop #\%i"
# This will print 0,2, and 4 # This will print 0,2, and 4
for %even in 0 to 5 by 2: say "Even #\%even" for %even in 0 to 5 by 2:
say "Even #\%even"
for %backwards in 3 to 1 by -1: for %backwards in 3 to 1 by -1:
say "Backwards #\%backwards" say "Backwards #\%backwards"
@ -149,7 +156,6 @@ for %backwards in 3 to 1 by -1:
repeat while (%x <= 3): repeat while (%x <= 3):
say "repeat while loop #\%x" say "repeat while loop #\%x"
%x += 1 %x += 1
%x = 1 %x = 1
repeat until (%x > 3): repeat until (%x > 3):
say "repeat until loop #\%x" say "repeat until loop #\%x"
@ -160,7 +166,8 @@ repeat until (%x > 3):
repeat: repeat:
say "repeat loop #\%x" say "repeat loop #\%x"
%x += 1 %x += 1
if (%x > 3): stop repeating if (%x > 3):
stop repeating
# How do I do a 'goto'? # How do I do a 'goto'?
do: do:
@ -168,7 +175,8 @@ do:
=== (my loop) === === (my loop) ===
say "GOTO loop #\%x" say "GOTO loop #\%x"
%x += 1 %x += 1
if (%x <= 3): go to (my loop) if (%x <= 3):
go to (my loop)
say "finished going to" say "finished going to"
# How do I define a function/method/procedure? # How do I define a function/method/procedure?
@ -189,8 +197,8 @@ say both "Hello" and also "world!"
%tmp = (%f1 + %f2) %tmp = (%f1 + %f2)
%f1 = %f2 %f1 = %f2
%f2 = %tmp %f2 = %tmp
if (%f2 > %n): return %f2 if (%f2 > %n):
return %f2
say (first fibonacci above 10) say (first fibonacci above 10)
# Actions can have aliases, which may or may not have the arguments in different order # Actions can have aliases, which may or may not have the arguments in different order
@ -200,7 +208,6 @@ say (first fibonacci above 10)
I like %better_things more than %worse_things I like %better_things more than %worse_things
..all mean: ..all mean:
say "\(%better_things::capitalized) rule and \%worse_things drool!" say "\(%better_things::capitalized) rule and \%worse_things drool!"
I like "dogs" more than "cats" I like "dogs" more than "cats"
I think "chihuahuas" are worse than "corgis" I think "chihuahuas" are worse than "corgis"
@ -208,7 +215,6 @@ I think "chihuahuas" are worse than "corgis"
(%what_she_said is what she said) means: (%what_she_said is what she said) means:
say %what_she_said say %what_she_said
say "-- she said" say "-- she said"
"Howdy pardner" is what she said "Howdy pardner" is what she said
# The language only reserves []{}().,:;%#\ as special characters, so actions # The language only reserves []{}().,:;%#\ as special characters, so actions
@ -217,7 +223,6 @@ I think "chihuahuas" are worse than "corgis"
say %foo_bar say %foo_bar
say % say %
say %1 say %1
>> "wow" $@&' --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" ! >> "wow" $@&' --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" !
# There's also full unicode support # There's also full unicode support
@ -243,7 +248,6 @@ say (2 + 3)
# If you need to keep going after an indented region, you can start the next line with ".." # If you need to keep going after an indented region, you can start the next line with ".."
say both "Very long first argument that needs its own line" and also "\ say both "Very long first argument that needs its own line" and also "\
..short second arg" ..short second arg"
(my favorite number) means (21 + 2) (my favorite number) means (21 + 2)
# This can be nested: # This can be nested:
@ -253,7 +257,6 @@ say both (my favorite number) and also "foo"
# The "lua> %" and "=lua %" macros can be used to write raw lua code: # The "lua> %" and "=lua %" macros can be used to write raw lua code:
(say the time) means: (say the time) means:
lua> "io.write(\"The OS time is: \", os.time(), \"\\n\");" lua> "io.write(\"The OS time is: \", os.time(), \"\\n\");"
say the time say the time
say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2 % 5")" say "Math expression result is: \(=lua "(1 + 2*3 + 3*4)^2 % 5")"
@ -270,7 +273,6 @@ say "The square root of 2 is \(square root of 2)"
return (Lua "-- Debug code:\n\(%body as lua)") return (Lua "-- Debug code:\n\(%body as lua)")
..else: ..else:
return (Lua "-- (debug code removed for production)") return (Lua "-- (debug code removed for production)")
%DEBUG_ENABLED = (yes) %DEBUG_ENABLED = (yes)
# Constants can be defined as macros # Constants can be defined as macros
@ -301,7 +303,6 @@ debug only:
if ((%best is (nil)) or (%key > %best_key)): if ((%best is (nil)) or (%key > %best_key)):
%best = %item %best = %item
%best_key = %key %best_key = %key
return %best return %best
# Function literals look like: [%x] -> (%x * %x) # Function literals look like: [%x] -> (%x * %x)
@ -323,7 +324,6 @@ say (best of [2, -3, 4, -8] according to ((% squared)'s meaning))
if ((%best is (nil)) or (%key > %best_key)): if ((%best is (nil)) or (%key > %best_key)):
%best = %item %best = %item
%best_key = %key %best_key = %key
return %best return %best
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

10
lib/base64.nom
View File

@ -1,18 +1,18 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines actions for encoding/decoding base 64, as specified in: This file defines actions for encoding/decoding base 64, as specified in:
https://tools.ietf.org/html/rfc4648 https://tools.ietf.org/html/rfc4648
%b64_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" %b64_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
%reverse_b64 = (%b64_str.%i = (%i - 1) for %i in 1 to (size of %b64_str)) %reverse_b64 = {: for %i in 1 to (size of %b64_str): add %b64_str.%i = (%i - 1)}
%reverse_b64."=" = 0 %reverse_b64."=" = 0
test: test:
%cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"] %cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"]
for %len = %encoded in %cases: for %len = %encoded in %cases:
%plain = "foobar".[1, %len - 1] %plain = "foobar".[1, %len - 1]
assume (base64 %plain) == %encoded assume (base64 %plain) == %encoded
assume (base64 decode %encoded) == %plain assume (base64 decode %encoded) == %plain
externally [base64 %str, base64 encode %str, %str base64] all mean: externally [base64 %str, base64 encode %str, %str base64] all mean:
%chars = [] %chars = []
for %i in 1 to (size of %str) via 3: for %i in 1 to (size of %str) via 3:
@ -33,18 +33,16 @@ externally [base64 %str, base64 encode %str, %str base64] all mean:
%chars::add %b64_str.(((%bytes.1 & 3) << 4) + 1) %chars::add %b64_str.(((%bytes.1 & 3) << 4) + 1)
%chars::add "=" %chars::add "="
%chars::add "=" %chars::add "="
return (%chars::joined) return (%chars::joined)
externally (chr %) means (=lua "string.char(\%)") externally (chr %) means (=lua "string.char(\%)")
externally [decode base64 %str, %str base64 decoded, base64 decode %str] all mean: externally [decode base64 %str, %str base64 decoded, base64 decode %str] all mean:
%chars = [] %chars = []
for %i in 1 to (size of %str) via 4: for %i in 1 to (size of %str) via 4:
%indices = (%reverse_b64.(%str.%) for % in %i to (%i + 3)) %indices = [: for % in %i to (%i + 3): add %reverse_b64.(%str.%)]
%chars::add (chr ((%indices.1 << 2) + ((%indices.2 & 48) >> 4))) %chars::add (chr ((%indices.1 << 2) + ((%indices.2 & 48) >> 4)))
if (%str.(%i + 2) == "="): stop if (%str.(%i + 2) == "="): stop
%chars::add (chr (((%indices.2 & 15) << 4) + ((%indices.3 & 60) >> 2))) %chars::add (chr (((%indices.2 & 15) << 4) + ((%indices.3 & 60) >> 2)))
if (%str.(%i + 3) == "="): stop if (%str.(%i + 3) == "="): stop
%chars::add (chr (((%indices.3 & 3) << 6) + %indices.4)) %chars::add (chr (((%indices.3 & 3) << 6) + %indices.4))
return (%chars::joined) return (%chars::joined)

19
lib/consolecolor.nom
View File

@ -1,23 +1,26 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines actions for ANSI console color escape codes. This file defines actions for ANSI console color escape codes.
test: test:
% = (bright "\(green)Color test passed.") % = (bright "\(green)Color test passed.")
%colors = {..} %colors = {..}
normal:0, "reset color":0, bright:1, bold:1, dim:2, italic:3, underscore:4 normal: 0, "reset color": 0, bright: 1, bold: 1, dim: 2, italic: 3, underscore: 4
"slow blink":5, "fast blink":6, reverse:7, inverse:7, inverted:7, hidden:8 "slow blink": 5, "fast blink": 6, reverse: 7, inverse: 7, inverted: 7
# There's some other codes, but they're not currently implemented hidden: 8, # There's some other codes, but they're not currently implemented
black:30, red:31, green:32, yellow:33, blue:34, magenta:35, cyan:36, white:37 black: 30, red: 31, green: 32, yellow: 33, blue: 34, magenta: 35, cyan: 36
"on black":40, "on red":41, "on green":42, "on yellow":43, "on blue":44 white: 37, "on black": 40, "on red": 41, "on green": 42, "on yellow": 43
"on magenta":45, "on cyan":46, "on white":47 "on blue": 44, "on magenta": 45, "on cyan": 46, "on white": 47
for %name = %colornum in %colors: for %name = %colornum in %colors:
%colornum = "\%colornum" %colornum = "\%colornum"
#(=lua "COMPILE_ACTIONS").%name = (..) #(=lua "COMPILE_ACTIONS").%name = (..)
[%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'") [%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'")
%compile.action.%name = (..) %compile.action.%name = (..)
[%nomsu, %text] ->: [%nomsu, %text] ->:
if %text: if %text:
return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')") return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
..else: return (Lua "'\\027[\(%colornum)m'") ..else:
return (Lua "'\\027[\(%colornum)m'")

11
lib/file_hash.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines some actions for hashing files and looking up files by hash. This file defines some actions for hashing files and looking up files by hash.
@ -8,7 +8,6 @@ use "lib/base64.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lua> "local \%use_sha1, \%hashlib = pcall(require, 'openssl.digest')" lua> "local \%use_sha1, \%hashlib = pcall(require, 'openssl.digest')"
test: test:
assume (hash "hello world") == (hash "hello world") assume (hash "hello world") == (hash "hello world")
assume ((hash "hello world") != (hash "goodbye")) or barf "\ assume ((hash "hello world") != (hash "goodbye")) or barf "\
@ -25,16 +24,17 @@ test:
assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf "\ assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf "\
..Incorrect hashing of null strings" ..Incorrect hashing of null strings"
if %use_sha1: if %use_sha1:
assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=") assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
if %use_sha1: if %use_sha1:
externally (hash %) means: externally (hash %) means:
%hash = (=lua "\%hashlib.new('sha1'):final(\%)") %hash = (=lua "\%hashlib.new('sha1'):final(\%)")
return (base64 %hash) return (base64 %hash)
..else: ..else:
# TODO: remove warning? # TODO: remove warning?
say "\ say "\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m"
..\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m"
externally (hash %) means: externally (hash %) means:
%bytes = (%::bytes) %bytes = (%::bytes)
%hash = (%bytes.1 << 7) %hash = (%bytes.1 << 7)
@ -47,6 +47,7 @@ externally (file with hash %hash) means:
for file %filename in ".": for file %filename in ".":
%contents = (read file %filename) %contents = (read file %filename)
%file_hash = (hash %contents) %file_hash = (hash %contents)
if (%file_hash == %hash): return %filename if (%file_hash == %hash):
return %filename
(hash of file %filename) parses as (hash (read file %filename)) (hash of file %filename) parses as (hash (read file %filename))

40
lib/object.nom
View File

@ -1,25 +1,27 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains the implementation of an Object-Oriented programming system. This file contains the implementation of an Object-Oriented programming system.
%globals.METAMETHOD_MAP = {..} %globals.METAMETHOD_MAP = {..}
"as text":"__tostring", "clean up":"__gc", "+ 1":"__add", "- 1":"__sub" "as text": "__tostring", "clean up": "__gc", "+ 1": "__add", "- 1": "__sub"
"* 1":"__mul", "/ 1":"__div", "-":"__unm", "// 1":"__idiv", "mod 1":"__mod" "* 1": "__mul", "/ 1": "__div", "-": "__unm", "// 1": "__idiv", "mod 1": "__mod"
"^ 1":"__pow", "& 1":"__band", "| 1":"__bor", "~ 1":"__bxor", "~":"__bnot" "^ 1": "__pow", "& 1": "__band", "| 1": "__bor", "~ 1": "__bxor", "~": "__bnot"
"<< 1":"__bshl", ">> 1":"__bshr", "== 1":"__eq", "< 1":"__lt", "<= 1":"__le" "<< 1": "__bshl", ">> 1": "__bshr", "== 1": "__eq", "< 1": "__lt", "<= 1": "__le"
"set 1 = 2":"__newindex", size:"__len", iterate:"__ipairs", "iterate all":"__pairs" "set 1 = 2": "__newindex", size: "__len", iterate: "__ipairs"
"iterate all": "__pairs"
test: test:
object (Dog): object (Dog):
(Dog).genus = "Canus" (Dog).genus = "Canus"
my action [set up]: %me.barks or= 0 my action [set up]:
%me.barks or= 0
my action [bark, woof]: my action [bark, woof]:
%barks = ("Bark!" for % in 1 to %me.barks) %barks = [: for % in 1 to %me.barks: add "Bark!"]
return (%barks::joined with " ") return (%barks::joined with " ")
my action [get pissed off]: %me.barks += 1 my action [get pissed off]: %me.barks += 1
%d = (Dog {barks: 2})
%d = (Dog {barks:2})
assume (type of %d) == "Dog" assume (type of %d) == "Dog"
assume (%d is a "Dog") assume (%d is a "Dog")
assume %d.barks == 2 assume %d.barks == 2
@ -34,31 +36,31 @@ test:
assume (%d.barks == 3) assume (%d.barks == 3)
%d2 = (Dog {}) %d2 = (Dog {})
assume (%d2.barks == 0) or barf "Default initializer failed" assume (%d2.barks == 0) or barf "Default initializer failed"
with {%d:Dog {barks:1}}: with {%d: Dog {barks: 1}}:
assume ((%d::bark) == "Bark!") assume ((%d::bark) == "Bark!")
object (Corgi) extends (Dog): object (Corgi) extends (Dog):
my action [sploot] "splooted" my action [sploot] "splooted"
my action [bark, woof]: my action [bark, woof]:
%barks = ("Yip!" for % in 1 to %me.barks) %barks = [: for % in 1 to %me.barks: add "Yip!"]
return (%barks::joined with " ") return (%barks::joined with " ")
%corg = (Corgi {}) %corg = (Corgi {})
assume (%corg.barks == 0) assume (%corg.barks == 0)
with {%d:Corgi {barks:1}}: with {%d: Corgi {barks: 1}}:
assume ((%d::sploot) == "splooted") or barf "subclass method failed" assume ((%d::sploot) == "splooted") or barf "subclass method failed"
assume ((%d::bark) == "Yip!") or barf "inheritance failed" assume ((%d::bark) == "Yip!") or barf "inheritance failed"
assume ((%d::woof) == "Yip!") assume ((%d::woof) == "Yip!")
with {%d:Dog {barks:2}}: with {%d: Dog {barks: 2}}:
assume ((%d::bark) == "Bark! Bark!") assume ((%d::bark) == "Bark! Bark!")
(my action %actions %body) compiles to: (my action %actions %body) compiles to:
lua> "\ lua> "\
..local fn_name = \%actions[1].stub:as_lua_id() ..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = List(\%actions[1]:get_args()) local \%args = List(\%actions[1]:get_args())
table.insert(\%args, 1, \(\%me)) table.insert(\%args, 1, \(\%me))
local lua = LuaCode("class.", fn_name, " = ", \(..) local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to))
what (%args -> %body) compiles to
..)
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id() local alias_name = alias.stub:as_lua_id()
@ -75,7 +77,9 @@ test:
(object %classname extends %parent %class_body) compiles to: (object %classname extends %parent %class_body) compiles to:
unless (%classname.type == "Action"): unless (%classname.type == "Action"):
compile error at %classname "Expected this to be an action, not a \(%classname.type)" compile error at %classname "\
..Expected this to be an action, not a \%classname.type"
for % in %classname: for % in %classname:
unless (% is text): unless (% is text):
compile error at % "Class names should not have arguments." compile error at % "Class names should not have arguments."

17
lib/os.nom
View File

@ -1,9 +1,10 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file defines some actions that interact with the operating system and filesystem. This file defines some actions that interact with the operating system and filesystem.
test: test:
path of Nomsu file "lib/os.nom" path of Nomsu file "lib/os.nom"
externally (path of Nomsu file %filename) means: externally (path of Nomsu file %filename) means:
lua> "for i,f in Files.walk(\%filename) do return f end" lua> "for i,f in Files.walk(\%filename) do return f end"
barf "Could not find file: \%filename" barf "Could not find file: \%filename"
@ -17,10 +18,11 @@ externally (sh> %cmd) means:
test: test:
read file "lib/os.nom" read file "lib/os.nom"
externally (read file %filename) means (=lua "Files.read(\%filename)")
externally (read file %filename) means (=lua "Files.read(\%filename)")
test: test:
for file %f in "core": do nothing for file %f in "core": do nothing
(for file %f in %path %body) compiles to "\ (for file %f in %path %body) compiles to "\
..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
\(%body as lua) \(%body as lua)
@ -49,23 +51,28 @@ externally [..]
test: test:
assume (line number of 3 in "x\ny") == 2 assume (line number of 3 in "x\ny") == 2
externally (line number of %pos in %str) means (..) externally (line number of %pos in %str) means (..)
=lua "Files.get_line_number(\%str, \%pos)" =lua "Files.get_line_number(\%str, \%pos)"
test: test:
assume (line 2 in "one\ntwo\nthree") == "two" assume (line 2 in "one\ntwo\nthree") == "two"
externally (line %line_num in %str) means (..) externally (line %line_num in %str) means (..)
=lua "Files.get_line(\%str, \%line_num)" =lua "Files.get_line(\%str, \%line_num)"
test: test:
assume (source lines of \(this)) assume (source lines of \(this))
externally (source lines of %tree) means: externally (source lines of %tree) means:
%source = (%tree.source if (%tree is syntax tree) else %tree) %source = (%tree.source if (%tree is syntax tree) else %tree)
%file = (read file %source.filename) %file = (read file %source.filename)
return (..) return (..)
(..) [..]
(line % in %file) for % in (line number of %source.start in %file) to (..) :
line number of %source.stop in %file for % in (line number of %source.start in %file) to (..)
line number of %source.stop in %file
..: add (line % in %file)
..::joined with "\n" ..::joined with "\n"
externally (spoof file %text) means (%Files.spoof %text) externally (spoof file %text) means (%Files.spoof %text)

62
lib/things.nom
View File

@ -1,28 +1,26 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
A library for simple object oriented programming. A library for simple object oriented programming.
%globals.METAMETHOD_MAP = {..} %globals.METAMETHOD_MAP = {..}
"as text": "__tostring", "clean up": "__gc", "as text": "__tostring", "clean up": "__gc", "+": "__add", "-": "__sub"
"+": "__add", "-": "__sub", "*": "__mul", "/": "__div", "*": "__mul", "/": "__div", negative: "__unm", "//": "__idiv", mod: "__mod"
"negative": "__unm", "//": "__idiv", "mod": "__mod", "^": "__pow", "^": "__pow", "&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot"
"&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot", "<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", "<=": "__le"
"<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", "set 1 =": "__newindex", size: "__len", iterate: "__ipairs", "iterate all": "__pairs"
"<=": "__le", "set 1 =": "__newindex", "size": "__len",
"iterate": "__ipairs", "iterate all": "__pairs",
test: test:
a (Dog) is a thing: a (Dog) is a thing:
that can (set up) by: that can (set up) by:
%its.barks or= 0 %its.barks or= 0
whose [bark, woof] all mean:
%barks = ("Bark!" for % in 1 to %its.barks)
return (%barks::joined with " ")
that can (get pissed off) by:
%its.barks += 1
(Dog).genus = "Canus"
%d = (a Dog with {barks:2}) whose [bark, woof] all mean:
%barks = [: for % in 1 to %its.barks: add "Bark!"]
return (%barks::joined with " ")
that can (get pissed off) by: %its.barks += 1
(Dog).genus = "Canus"
%d = (a Dog with {barks: 2})
assume (type of %d) == "Dog" assume (type of %d) == "Dog"
assume (%d is a "Dog") assume (%d is a "Dog")
assume %d.barks == 2 assume %d.barks == 2
@ -37,36 +35,37 @@ test:
assume (%d.barks == 3) assume (%d.barks == 3)
%d2 = (a Dog) %d2 = (a Dog)
assume (%d2.barks == 0) or barf "Default initializer failed" assume (%d2.barks == 0) or barf "Default initializer failed"
with {%d:a Dog with {barks:1}}: with {%d: a Dog with {barks: 1}}:
assume ((%d::bark) == "Bark!") assume ((%d::bark) == "Bark!")
a (Corgi) is a thing: a (Corgi) is a thing:
that can [set up, get pissed off] like a (Dog) that can [set up, get pissed off] like a (Dog)
whose (sploot) means "splooted" whose (sploot) means "splooted"
whose [bark, woof] all mean: whose [bark, woof] all mean:
%barks = ("Yip!" for % in 1 to %its.barks) %barks = [: for % in 1 to %its.barks: add "Yip!"]
return (%barks::joined with " ") return (%barks::joined with " ")
%corg = (a Corgi) %corg = (a Corgi)
assume (%corg.barks == 0) assume (%corg.barks == 0)
with {%d:a Corgi with {barks:1}}: with {%d: a Corgi with {barks: 1}}:
assume ((%d::sploot) == "splooted") or barf "subclass method failed" assume ((%d::sploot) == "splooted") or barf "subclass method failed"
assume ((%d::bark) == "Yip!") or barf "inheritance failed" assume ((%d::bark) == "Yip!") or barf "inheritance failed"
assume ((%d::woof) == "Yip!") assume ((%d::woof) == "Yip!")
with {%d:a Dog with {barks:2}}: with {%d: a Dog with {barks: 2}}:
assume ((%d::bark) == "Bark! Bark!") assume ((%d::bark) == "Bark! Bark!")
[..] [..]
that can %actions by %body, that can %actions by %body, whose %actions means %body
whose %actions means %body, whose %actions all mean %body, whose %actions all mean %body
..all compile to: ..all compile to:
unless (%actions.type == "List"): %actions = [%actions] unless (%actions.type == "List"):
%actions = [%actions]
lua> "\ lua> "\
..local fn_name = \%actions[1].stub:as_lua_id() ..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = List{\(\%its), unpack(\%actions[1]:get_args())} local \%args = List{\(\%its), unpack(\%actions[1]:get_args())}
local lua = LuaCode("class.", fn_name, " = ", \(..) local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to))
what (%args -> %body) compiles to
..)
for i=2,#\%actions do for i=2,#\%actions do
local alias = \%actions[i] local alias = \%actions[i]
local alias_name = alias.stub:as_lua_id() local alias_name = alias.stub:as_lua_id()
@ -85,8 +84,8 @@ test:
return lua" return lua"
[..] [..]
that can %actions like a %class, that can %actions like an %class, that can %actions like a %class, that can %actions like an %class
that has %actions like a %class, that has %actions like an %class, that has %actions like a %class, that has %actions like an %class
..all compile to: ..all compile to:
%lua = (Lua "") %lua = (Lua "")
%class_expr = (%class as lua expr) %class_expr = (%class as lua expr)
@ -96,13 +95,15 @@ test:
%lua::add %lines joined with "\n" %lua::add %lines joined with "\n"
return %lua return %lua
(a %classname is a thing with %members %class_body) compiles to: (a %classname is a thing with %members %class_body) compiles to:
unless (%classname.type == "Action"): unless (%classname.type == "Action"):
compile error at %classname "Expected this to be an action, not a \(%classname.type)" compile error at %classname "\
..Expected this to be an action, not a \%classname.type"
for % in %classname: for % in %classname:
unless (% is text): unless (% is text):
compile error at % "Class names should not have arguments." compile error at % "Class names should not have arguments."
return (..) return (..)
Lua "\ Lua "\
..do ..do
@ -142,4 +143,5 @@ test:
end end
end" end"
(a %classname is a thing %class_body) parses as (a %classname is a thing with (nil) %class_body) (a %classname is a thing %class_body) parses as (..)
a %classname is a thing with (nil) %class_body

9
lib/training_wheels.nom
View File

@ -1,13 +1,12 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
This file contains a set of definitions that bring some familiar language features This file contains a set of definitions that bring some familiar language features
from other languages into nomsu (e.g. "||" and "continue") from other languages into nomsu (e.g. "||" and "continue")
(%a === %b) parses as ((%a 's id) is (%b 's id)) (%a === %b) parses as ((%a's id) is (%b's id))
(%a !== %b) parses as ((%a 's id) is not (%b 's id)) (%a !== %b) parses as ((%a's id) is not (%b's id))
[function %names %body, def %names %body] all parse as (..) [function %names %body, def %names %body] all parse as (..)
externally %names means %body externally %names means %body
(switch %branch_value %body) parses as (if %branch_value is %body) (switch %branch_value %body) parses as (if %branch_value is %body)
[None, Null] all parse as (nil) [None, Null] all parse as (nil)
[True, true] all parse as (yes) [True, true] all parse as (yes)
@ -17,7 +16,7 @@
(%a && %b) parses as (%a and %b) (%a && %b) parses as (%a and %b)
(continue) parses as (do next) (continue) parses as (do next)
(break) parses as (stop) (break) parses as (stop)
(let %thing = %value in %action) parses as (with local {%thing:%value}) (let %thing = %value in %action) parses as (with local {%thing: %value})
[print %, println %] all parse as (say %) [print %, println %] all parse as (say %)
[error!, panic!, fail!, abort!] all parse as (barf!) [error!, panic!, fail!, abort!] all parse as (barf!)
[error %, panic %, fail %, abort %] all parse as (barf %) [error %, panic %, fail %, abort %] all parse as (barf %)

2
lib/version.nom
View File

@ -1,3 +1,3 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# This file sets the current library version. # This file sets the current library version.
lua> "NOMSU_LIB_VERSION = 7" lua> "NOMSU_LIB_VERSION = 7"

5
tools/autoformat.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
Auto-format Nomsu code. Usage: Auto-format Nomsu code. Usage:
nomsu tools/autoformat.nom [-i] file1 file2 directory1 ... nomsu tools/autoformat.nom [-i] file1 file2 directory1 ...
@ -24,4 +24,5 @@ for %path in %args:
if %inplace: if %inplace:
write %formatted to file %filename write %formatted to file %filename
..else: say %formatted ..else:
say %formatted

17
tools/find_action.nom
View File

@ -22,19 +22,20 @@ for %path in %files:
..and if it barfs %msg: ..and if it barfs %msg:
say (red "\%filename failed to parse:\n\%msg") say (red "\%filename failed to parse:\n\%msg")
%tree = (nil) %tree = (nil)
unless %tree: do next %filename
unless %tree:
do next %filename
%results = [] %results = []
for %t in recursive %tree: for %t in recursive %tree:
if ((%t is "Action" syntax tree) and (%t.stub is %stub)): if ((%t is "Action" syntax tree) and (%t.stub is %stub)):
%line_num = (line number of %t.source.start in %file) %line_num = (line number of %t.source.start in %file)
%results::add {..} %results::add {..}
line: %line_num line: %line_num, text: "\(blue "\%filename:\%line_num:")\n\(yellow (source lines of %t))"
text: "\
..\(blue "\%filename:\%line_num:")
\(yellow (source lines of %t))"
if (%t is syntax tree): if (%t is syntax tree):
for %sub in %t: recurse %t on %sub for %sub in %t:
recurse %t on %sub
sort %results by % -> %.line sort %results by % -> %.line
for % in %results: say %.text for % in %results:
say %.text

7
tools/parse.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
Tool to print out a parse tree of files in an easy-to-read format. Usage: Tool to print out a parse tree of files in an easy-to-read format. Usage:
nomsu tools/parse.nom file1 file2 directory1 ... nomsu tools/parse.nom file1 file2 directory1 ...
@ -21,14 +21,17 @@ externally (print tree %t at indent %indent) means:
"Number": "Number":
say "\%indent\(%t.1)" say "\%indent\(%t.1)"
"Var": "Var":
say "\(%indent)%\(%t.1)" say "\(%indent)%\(%t.1)"
else: else:
say "\%indent\(%t.type):" say "\%indent\(%t.type):"
for %arg in %t: for %arg in %t:
if: when:
(%arg is syntax tree): (%arg is syntax tree):
print tree %arg at indent "\%indent " print tree %arg at indent "\%indent "
else: else:
say "\%indent \(quote %arg)" say "\%indent \(quote %arg)"

20
tools/repl.nom
View File

@ -1,12 +1,13 @@
#!/usr/bin/env nomsu -V4 #!/usr/bin/env nomsu -V4.10.12.7
use "lib/consolecolor.nom" use "lib/consolecolor.nom"
use "lib/os.nom" use "lib/os.nom"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[quit, exit] all mean: lua> "os.exit(0)" externally [quit, exit] all mean:
lua> "os.exit(0)"
(help) means: externally (help) means:
say "\ say "\
..This is the Nomsu v\(Nomsu version) interactive console. ..This is the Nomsu v\(Nomsu version) interactive console.
You can type in Nomsu code here and hit 'enter' twice to run it. You can type in Nomsu code here and hit 'enter' twice to run it.
@ -15,7 +16,7 @@ use "lib/os.nom"
say "\ say "\
.. ..
\(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color) \(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color)
press 'enter' twice to run a command press 'enter' twice to run a command
" "
%repl_line = 0 %repl_line = 0
@ -33,29 +34,28 @@ repeat:
go to (run buffer) go to (run buffer)
%buff::add (%line::with "\t" -> " ") %buff::add (%line::with "\t" -> " ")
%io.write (dim (yellow ".. ")) %io.write (dim (yellow ".. "))
=== (run buffer) === === (run buffer) ===
if ((size of %buff) == 0): if ((size of %buff) == 0): stop
stop
%buff = (%buff::joined) %buff = (%buff::joined)
# TODO: support local variables # TODO: support local variables
spoof file %buff spoof file %buff
try: try:
%ret = (run %buff) %ret = (run %buff)
..and if it barfs %err: ..and if it barfs %err: say %err
say %err
..or if it succeeds: ..or if it succeeds:
if (type of %ret) is: if (type of %ret) is:
"nil": "nil":
do nothing do nothing
"boolean": "boolean":
say "= \("yes" if %ret else "no")" say "= \("yes" if %ret else "no")"
"table": "table":
if %ret.as_nomsu: if %ret.as_nomsu:
say "= \(%ret::as nomsu)" say "= \(%ret::as nomsu)"
..else: ..else:
say "= \%ret" say "= \%ret"
else: else:
say "= \%ret" say "= \%ret"

7
tools/replace.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
Tool to find and replace one tree with another. Tool to find and replace one tree with another.
nomsu tools/replace.nom [-i] tree_to_replace replacement file1 file2 directory1 ... nomsu tools/replace.nom [-i] tree_to_replace replacement file1 file2 directory1 ...
@ -35,9 +35,10 @@ for %path in %args:
..#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version)) ..#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version))
\(%tree2 as nomsu)" \(%tree2 as nomsu)"
if: when:
%inplace: %inplace:
say "Replaced in \%filename" say "Replaced in \%filename"
write %text to file %filename write %text to file %filename
else: say %text else:
say %text

10
tools/test.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
Tool to run all tests in a file (i.e. the code block inside a call to 'test %'). Usage: Tool to run all tests in a file (i.e. the code block inside a call to 'test %'). Usage:
nomsu tools/test.nom file1 file2 directory1 ... nomsu tools/test.nom file1 file2 directory1 ...
@ -17,16 +17,15 @@ if (%args.1 == "-v"):
for %path in (command line args): for %path in (command line args):
for file %filename in %path: for file %filename in %path:
if (%filename::matches "%.nom$"): use %filename if (%filename::matches "%.nom$"): use %filename
for %path in (command line args): use %path for %path in (command line args): use %path
%tests = ((=lua "Source:from_string(\%s)") = %t for %s = %t in (tests)) %tests = {: for %s = %t in (tests): add (=lua "Source:from_string(\%s)") = %t}
for %path in (command line args): for %path in (command line args):
for file %filename in %path: for file %filename in %path:
unless (%filename::matches "%.nom$"): do next %filename unless (%filename::matches "%.nom$"): do next %filename
%file_tests = [] %file_tests = []
for %src = %test in %tests: for %src = %test in %tests:
if (%src.filename == %filename): if (%src.filename == %filename):
%file_tests::add {test:%test, source:%src} %file_tests::add {test: %test, source: %src}
unless (%file_tests is empty): unless (%file_tests is empty):
sort %file_tests by % -> %.source sort %file_tests by % -> %.source
@ -37,6 +36,7 @@ for %path in (command line args):
say " \(yellow (%.test::with "\n" -> "\n "))" say " \(yellow (%.test::with "\n" -> "\n "))"
run %.test run %.test
if %verbose: say (green "PASS") if %verbose:
say (green "PASS")
..else: ..else:
say "\r[\(green "PASS")" say "\r[\(green "PASS")"

9
tools/upgrade.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V4.8.10 #!/usr/bin/env nomsu -V4.10.12.7
# #
Tool to automatically update code from old versions of Nomsu. Usage: Tool to automatically update code from old versions of Nomsu. Usage:
nomsu tools/upgrade.nom [-i] file1 file2 directory1 ... nomsu tools/upgrade.nom [-i] file1 file2 directory1 ...
@ -44,9 +44,9 @@ for %path in %args:
%code = (%NomsuCode::from (%Source %filename 1 (size of %file)) %file) %code = (%NomsuCode::from (%Source %filename 1 (size of %file)) %file)
%tree = (%code parsed) %tree = (%code parsed)
%uptree = (..) %uptree = (..)
%tree upgraded from (%start_version or (%tree.version or (Nomsu version))) to %version %tree upgraded from (%start_version or (%tree.version or (Nomsu version))) to \
..%version
%text = ((%uptree as nomsu)::text) %text = ((%uptree as nomsu)::text)
when: when:
%inplace: %inplace:
say "Upgraded \%filename" say "Upgraded \%filename"
@ -58,4 +58,5 @@ for %path in %args:
..else: ..else:
say (bright "\%filename will be changed") say (bright "\%filename will be changed")
else: say %text else:
say %text