diff --git a/compatibility/2.3.nom b/compatibility/2.3.nom index df3c619..7d8fae0 100644 --- a/compatibility/2.3.nom +++ b/compatibility/2.3.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compatibility/2.4.nom b/compatibility/2.4.nom index 2b39dd5..ef78a89 100644 --- a/compatibility/2.4.nom +++ b/compatibility/2.4.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -10,60 +10,65 @@ upgrade %tree to "2.4" as: unless (%tree is "Action" syntax tree): return if %tree.stub is: "when" "if": - if ((size of %tree) == 3): - return %tree + if ((size of %tree) == 3): return %tree %conditions = [] %new_lines = [] - %body = (..) - (%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded] + %body = ((%tree.2 upgraded) if (%tree.2 is "Block" syntax tree) else [%tree.2 upgraded]) for %line in %body: when: (not (%line is "Action" syntax tree)): %new_lines::add %line + (%line.stub is "*"): if ((size of %line) == 2): %conditions::add %line.2 ..else: %new_lines::add %line + (%line.stub == "* else"): - %new_lines::add (\(else %block) with vars {block:%line.3}) + %new_lines::add (\(else %block) with vars {block: %line.3}) + else: %conditions::add %line.2 %action = %line.3 unless (%action is "Block" syntax tree): %action = (=lua "SyntaxTree{type='Block', source=\%action.source, \%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 = [] 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 = ?": %values = [] %new_lines = [] - %body = (..) - (%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded] + %body = ((%tree.5 upgraded) if (%tree.5 is "Block" syntax tree) else [%tree.5 upgraded]) for %line in %body: when: (not (%line is "Action" syntax tree)): %new_lines::add %line + (%line.stub is "*"): if ((size of %line) == 2): %values::add %line.2 ..else: %new_lines::add %line + (%line.stub == "* else"): - %new_lines::add (\(else %block) with vars {block:%line.3}) + %new_lines::add (\(else %block) with vars {block: %line.3}) + else: %values::add %line.2 %action = %line.3 - unless (%action is "Block" syntax tree): - %action = \(: %action) + unless (%action is "Block" syntax tree): %action = \(: %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 = [] return (..) \(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)}" diff --git a/compatibility/2.5.5.5.nom b/compatibility/2.5.5.5.nom index b7a7b21..9bbee06 100644 --- a/compatibility/2.5.5.5.nom +++ b/compatibility/2.5.5.5.nom @@ -1,16 +1,14 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ upgrade action [hash %, sha1 %] to "2.5.5.5" as (..) - =lua "\ - ..\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)" + =lua "\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)" upgrade action [file with hash %] to "2.5.5.5" as (..) file with hash (..) - base64 (..) - =lua "\%:gsub('..', function(xx) return string.char(tonumber(xx, 16)) end)" + base64 (=lua "\%:gsub('..', function(xx) return string.char(tonumber(xx, 16)) end)") diff --git a/compatibility/2.5.nom b/compatibility/2.5.nom index 8c3f4d0..816691e 100644 --- a/compatibility/2.5.nom +++ b/compatibility/2.5.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compatibility/2.nom b/compatibility/2.nom index 84331a6..2ca4526 100644 --- a/compatibility/2.nom +++ b/compatibility/2.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -15,21 +15,22 @@ upgrade %tree to "2" as: %false_body = (%tree.5 upgraded) unless (%false_body is "Block" syntax tree): %false_body = (=lua "Block(\%false_body.source, \%false_body)") + return (..) \(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 = [..] - "if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1" - "repeat 1 times", "repeat", "repeat until 1", "for 1 in 2 to 3 by" - "for 1 in 2 to 3 via", "for 1 in 2 to", "for 1 2 in" - "do", "for 1 in recursive", "test", "with", "result of", "when" + "if", "unless", "for 1 in", "for 1 = 2 in", "repeat while 1", "repeat 1 times" + "repeat", "repeat until 1", "for 1 in 2 to 3 by", "for 1 in 2 to 3 via" + "for 1 in 2 to", "for 1 2 in", "do", "for 1 in recursive", "test", "with", "result of" + "when" for %n in %need_blocks: 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): %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)}") diff --git a/compatibility/3.5.5.6.nom b/compatibility/3.5.5.6.nom index ff69614..db7b3a0 100644 --- a/compatibility/3.5.5.6.nom +++ b/compatibility/3.5.5.6.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compatibility/3.6.nom b/compatibility/3.6.nom index b2fc5b4..1a9edb1 100644 --- a/compatibility/3.6.nom +++ b/compatibility/3.6.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -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 [remove index %index from %list] to "3.6" as (..) %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 joined by %3] to "3.6" as (..) %1::append %2 joined by %3 - upgrade action [declare locals in %lua] to "3.6" as (%lua::declare locals) upgrade action [declare locals %locs in %lua] to "3.6" as (..) %lua::declare locals %locs diff --git a/compatibility/3.7.nom b/compatibility/3.7.nom index 76a49e2..874b113 100644 --- a/compatibility/3.7.nom +++ b/compatibility/3.7.nom @@ -1,19 +1,27 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -upgrade action [%index st to last in %list] to "3.7" as (%list::%index st to 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 [%index st to last in %list] to "3.7" as (..) + %list::%index st to 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 [first in %list] to "3.7" as (%list::first) -upgrade action [%item is in %list, %list contains %item, %list has %item] -..to "3.7" as (%list::has %item) +upgrade action [%item is in %list, %list contains %item, %list has %item] to \ +.."3.7" as (%list::has %item) upgrade action [..] %item isn't in %list, %item is not in %list, %list doesn't contain %item diff --git a/compatibility/3.8.nom b/compatibility/3.8.nom index 0709688..583b52b 100644 --- a/compatibility/3.8.nom +++ b/compatibility/3.8.nom @@ -1,22 +1,19 @@ -#!/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) - + upgrade action [%texts joined with %glue] to "3.8" as (%texts::joined with %glue) upgrade action [%texts joined, joined %texts] to "3.8" as (%texts::joined) upgrade action [byte %i of %text] to "3.8" as (%text::byte %i) upgrade action [bytes %start to %stop of %text] to "3.8" as (..) %text::bytes %start to %stop - upgrade action [bytes of %text] to "3.8" as (%text::bytes) upgrade action [capitalized %text, %text capitalized] to "3.8" as (..) %text::capitalized - upgrade action [uppercase %text, %text uppercase] to "3.8" as (%text::uppercase) upgrade action [..] %text with %sub instead of %patt, %text with %patt replaced by %sub %text s/ %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 matching %pattern] to "3.8" as (%text::matching %pattern).1 diff --git a/compatibility/3.nom b/compatibility/3.nom index f97bb8b..1f23897 100644 --- a/compatibility/3.nom +++ b/compatibility/3.nom @@ -1,7 +1,7 @@ -#!/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 - + use "compatibility/compatibility.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -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 (@) to "3" as %me 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 ...)") diff --git a/compatibility/4.10.12.7.nom b/compatibility/4.10.12.7.nom index 4c363ab..982965b 100644 --- a/compatibility/4.10.12.7.nom +++ b/compatibility/4.10.12.7.nom @@ -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 (..) =lua "\%.type == 'Block' and \(% as lua) or 'return '..\(% as lua expr)" upgrade action (Lua value %) to "4.10.12.7" as (Lua %) +upgrade action (%e for % in %items) to "4.10.12.7" as [: for % in %items: add %e] +upgrade action (%e for %k = %v in %items) to "4.10.12.7" as [..] + : for %k = %v in %items: add %e -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 %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 (%e for %i in %start to %stop) to "4.10.12.7" as [..] + : for %i in %start to %stop: add %e -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 (%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 (%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 (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)): if %first_has_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): %chunk2.((size of %chunk2) + 1) = %first_chunk.%i.%j + for %j in %i to (size of %first_chunk.%i): %first_chunk.%i.%j = (nil) + %table.insert %tree 2 %chunk2 return %tree ..else: diff --git a/compatibility/4.8.10.nom b/compatibility/4.8.10.nom index 7ea95b0..c0c17dc 100644 --- a/compatibility/4.8.10.nom +++ b/compatibility/4.8.10.nom @@ -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") use "compatibility/compatibility.nom" @@ -15,6 +15,7 @@ upgrade action "local action" to "4.8.10" via (..) return \(%spec.1 means %body) ..else: return \(%spec all mean %body) + else: return \(%spec means %body) @@ -29,6 +30,7 @@ upgrade action "action" to "4.8.10" via (..) return \(externally %spec.1 means %body) ..else: return \(externally %spec all mean %body) + else: return \(externally %spec means %body) ..else: @@ -44,6 +46,7 @@ upgrade action "compile 1 to" to "4.8.10" via (..) return \(%spec.1 compiles to %body) ..else: return \(%spec all compile to %body) + else: 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) ..else: return \(%spec all parse as %body) + else: return \(%spec parse as %body) diff --git a/compatibility/4.9.nom b/compatibility/4.9.nom index 76df07b..e72b159 100644 --- a/compatibility/4.9.nom +++ b/compatibility/4.9.nom @@ -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 use "compatibility/compatibility.nom" diff --git a/compatibility/compatibility.nom b/compatibility/compatibility.nom index 1df91f1..68e12e5 100644 --- a/compatibility/compatibility.nom +++ b/compatibility/compatibility.nom @@ -1,8 +1,8 @@ -#!/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 of Nomsu. - + use "lib/os.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -10,7 +10,6 @@ use "lib/os.nom" %UPGRADES = {} externally (upgrade to %version via %upgrade_fn) means: %UPGRADES.%version = %upgrade_fn - %ACTION_UPGRADES = ({} with fallback % -> {}) externally (upgrade action %stub to %version via %upgrade_fn) means: %ACTION_UPGRADES.%version.%stub = %upgrade_fn @@ -27,7 +26,6 @@ externally (upgrade action %stub to %version via %upgrade_fn) means: for %i in 1 to (size of %action): if (%action.%i.type is "Var"): %replacements.(%action.%i.1) = "\(\%tree as lua id)[\%i]" - define mangler (make tree %t) means: when: @@ -45,21 +43,20 @@ externally (upgrade action %stub to %version via %upgrade_fn) means: %args::add (make tree %v) ..else: %args::add "\(%k)=\(make tree %v)" - 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) %lua::append (..) Lua "\ - ..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(..) - \%tree as lua id - ..) + ..upgrade_action_1_to_2_via(\(quote %action.stub), \(%version as lua expr), function(\(\%tree as lua id)) return \%retval end)" - return %lua externally [..] @@ -71,8 +68,10 @@ externally [..] %versions = {} for %v = % in %UPGRADES: %versions.%v = (yes) + for %v = % in %ACTION_UPGRADES: %versions.%v = (yes) + %versions = ((keys in %versions) sorted by % -> (% as list)) for %ver in %versions: if ((%ver as list) <= (%start_version as list)): do next %ver @@ -81,18 +80,18 @@ externally [..] %tree = (..) %tree with % ->: if ((% is "Action" syntax tree) and %ACTION_UPGRADES.%ver.(%.stub)): - %with_upgraded_args = (..) - %k = (%v upgraded from %start_version to %end_version) for %k = %v in % - set %with_upgraded_args 's metatable to (% 's metatable) - return (..) - %ACTION_UPGRADES.%ver.(%.stub) %with_upgraded_args %end_version + %with_upgraded_args = {..} + : for %k = %v in %: add %k = (%v upgraded from %start_version to %end_version) + set %with_upgraded_args's metatable to (%'s metatable) + return (%ACTION_UPGRADES.%ver.(%.stub) %with_upgraded_args %end_version) if %UPGRADES.%ver: - %with_upgraded_args = (..) - %k = (%v upgraded from %start_version to %end_version) for %k = %v in %tree - set %with_upgraded_args 's metatable to (%tree 's metatable) + %with_upgraded_args = {..} + : + for %k = %v in %tree: + add %k = (%v upgraded from %start_version to %end_version) + set %with_upgraded_args's metatable to (%tree's metatable) %tree = (call %UPGRADES.%ver with [%with_upgraded_args, %end_version]) - %tree.shebang = "#!/usr/bin/env nomsu -V\%end_version" return %tree @@ -107,7 +106,8 @@ externally (%tree upgraded) means (..) externally (use %path from version %version) means: for file %filename in %path: - if (=lua "LOADED[\%filename]"): do next %filename + if (=lua "LOADED[\%filename]"): + do next %filename %file = (read file %filename) %tree = (parse %file from %filename) %tree = (upgrade %tree from %version) diff --git a/core/collections.nom b/core/collections.nom index 9a7dbe4..e9457e6 100644 --- a/core/collections.nom +++ b/core/collections.nom @@ -1,8 +1,8 @@ -#!/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 and dictionaries. - + use "core/metaprogramming.nom" use "core/control_flow.nom" use "core/operators.nom" @@ -15,11 +15,11 @@ test: %visited = {} for %i = %x in %list: %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 = {} for %x in %list: %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::first) == 1) assume (%list::has 3) @@ -35,130 +35,53 @@ test: # Dict functionality test: - %dict = {x:1, y:2, z:3} - assume ((size of %dict) == 3) - assume ((% for % in {x:1}) == [{key:"x", value:1}]) - assume (({key:%k, value:%v} for %k = %v in {x:1}) == [{key:"x", value:1}]) - assume (({x:1, y:1} + {y:10, z:10}) == {x:1, y:11, z:10}) - assume (({x:1, y:1} | {y:10, z:10}) == {x:1, y: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) + %dict = {x: 1, y: 2, z: 3} + assume (size of %dict) == 3 + assume [: for % in {x: 1}: add %] == [{key: "x", value: 1}] + assume [: for %k = %v in {x: 1}: add {key: %k, value: %v}] == [..] + {key: "x", value: 1} + assume ({x: 1, y: 1} + {y: 10, z: 10}) == {x: 1, y: 11, z: 10} + assume ({x: 1, y: 1} | {y: 10, z: 10}) == {x: 1, y: 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} test: assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4]) + externally (%lists flattened) means: %flat = [] - for %list in %lists: - for %item in %list: %flat::add %item + for %item in recursive %lists: + if (%item is a "List"): + for % in %item: + recurse %item on % + ..else: + %flat::add %item return %flat test: - assume ((entries in {x:1}) == [{key:"x", value:1}]) -(entries in %dict) parses as ({key:%k, value:%v} for %k = %v in %dict) + assume ((entries in {x: 1}) == [{key: "x", value: 1}]) +(entries in %dict) parses as [: for %k = %v in %dict: add {key: %k, value: %v}] test: - assume ((keys in {x:1}) == ["x"]) -[keys in %dict, keys of %dict] all parse as (%k for %k = %v in %dict) - + assume ((keys in {x: 1}) == ["x"]) +[keys in %dict, keys of %dict] all parse as [: for %k = %v in %dict: add %k] test: - assume ((values in {x:1}) == [1]) -[values in %dict, values of %dict] all parse as (%v for %k = %v in %dict) + assume ((values in {x: 1}) == [1]) +[values in %dict, values of %dict] all parse as [: for %k = %v in %dict: add %v] # Metatable stuff test: %t = {} - set %t 's metatable to {__tostring:[%] -> "XXX"} + set %t's metatable to {__tostring: [%] -> "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));" -[% 's metatable, % 'metatable] all compile to "\ - ..getmetatable(\(% as lua expr))" - +[%'s metatable, %'metatable] all compile to "getmetatable(\(% as lua expr))" test: assume (({} with fallback % -> (% + 1)).10 == 11) + (%dict with fallback %key -> %value) compiles to "\ ..(function(d) local mt = {} @@ -178,12 +101,11 @@ test: assume (%x == [1, 2, 3]) sort %x by % = (- %) assume (%x == [3, 2, 1]) - %keys = {1:999, 2:0, 3:50} + %keys = {1: 999, 2: 0, 3: 50} sort %x by % = %keys.% assume (%x == [2, 3, 1]) (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 (..) do: %keys = ({} with fallback %item -> %key_expr) @@ -193,19 +115,21 @@ test: test: assume ((sorted [3, 1, 2]) == [1, 2, 3]) + externally [%items sorted, sorted %items] all mean: - %copy = (% for % in %items) + %copy = [: for % in %items: add %] sort %copy return %copy [%items sorted by %item = %key, %items sorted by %item -> %key] all parse as (..) result of: - %copy = (% for % in %items) + %copy = [: for % in %items: add %] sort %copy by %item = %key return %copy test: assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3]) + externally (unique %items) means: %unique = [] %seen = {} @@ -213,5 +137,4 @@ externally (unique %items) means: unless %seen.%: %unique::add % %seen.% = (yes) - return %unique diff --git a/core/control_flow.nom b/core/control_flow.nom index ff1a7c1..d96e916 100644 --- a/core/control_flow.nom +++ b/core/control_flow.nom @@ -1,8 +1,8 @@ -#!/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 like "if" statements and loops. - + use "core/metaprogramming.nom" use "core/operators.nom" use "core/errors.nom" @@ -10,13 +10,15 @@ use "core/errors.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # No-Op -test: do nothing +test: + do nothing (do nothing) compiles to "" # Conditionals test: if (no): barf "conditional fail" + (if %condition %if_body) compiles to "\ ..if \(%condition as lua expr) then \(%if_body as lua) @@ -25,9 +27,9 @@ test: test: unless (yes): barf "conditional fail" + (unless %condition %unless_body) parses as (if (not %condition) %unless_body) -[..] - if %condition %if_body else %else_body, unless %condition %else_body else %if_body +[if %condition %if_body else %else_body, unless %condition %else_body else %if_body] \ ..all compile to "\ ..if \(%condition as lua expr) then \(%if_body as lua) @@ -43,6 +45,7 @@ test: test: assume ((1 if (yes) else 2) == 1) assume ((1 if (no) else 2) == 2) + [..] %when_true_expr if %condition else %when_false_expr %when_true_expr if %condition otherwise %when_false_expr @@ -51,12 +54,8 @@ test: ..all compile to: # If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic equivalent of a conditional expression: (cond and if_true or if_false) - if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type): - return (..) - Lua "\ - ..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..) - %when_false_expr as lua expr - ..)" + if {Text: yes, List: yes, Dict: yes, Number: yes}.(%when_true_expr.type): + return (Lua "(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr))") ..else: # Otherwise, need to do an anonymous inline function (yuck, too bad lua doesn't have a proper ternary operator!) @@ -78,35 +77,37 @@ test: %i = 0 === %loop === %i += 1 - unless (%i == 10): go to %loop + unless (%i == 10): + go to %loop assume (%i == 10) === (Loop) === %i -= 1 - unless (%i == 0): go to (Loop) + unless (%i == 0): + go to (Loop) assume (%i == 0) + [=== %label ===, --- %label ---, *** %label ***] all compile to "\ - ..::label_\(..) - (%label.stub if (%label.type == "Action") else %label) as lua identifier - ..::" + ..::label_\((%label.stub if (%label.type == "Action") else %label) as lua identifier)::" (go to %label) compiles to "\ - ..goto label_\(..) - (%label.stub if (%label.type == "Action") else %label) as lua identifier - .." + ..goto label_\((%label.stub if (%label.type == "Action") else %label) as lua identifier)" # Basic loop control (stop %var) compiles to: if %var: - return (..) - Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)" - ..else: return (Lua "break") + return (Lua "goto stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)") + ..else: + return (Lua "break") + (do next %var) compiles to: if %var: - return (..) - Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)" - ..else: return (Lua "goto continue") + return (Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)") + ..else: + return (Lua "goto continue") + [===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\ ..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::" + [===next %var ===, ---next %var ---, ***next %var ***] all compile to "\ ..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::" @@ -116,32 +117,31 @@ test: repeat while (%x < 10): %x += 1 assume (%x == 10) repeat while (%x < 20): stop - repeat while (%x < 20): stop repeating + repeat while (%x < 20): + stop repeating assume (%x == 10) repeat while (%x < 20): %x += 1 - if (yes): do next + if (yes): + do next barf "Failed to 'do next'" - assume (%x == 20) repeat while (%x < 30): %x += 1 - if (yes): do next repeat + if (yes): + do next repeat barf "Failed to 'do next repeat'" - assume (%x == 30) (do next repeat) compiles to "goto continue_repeat" (stop repeating) compiles to "goto stop_repeat" (repeat while %condition %body) compiles to: - %lua = (..) - Lua "\ - ..while \(%condition as lua expr) do - \(%body as lua)" - + %lua = (Lua "while \(%condition as lua expr) do\n \(%body as lua)") if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next repeat)): %lua::append "\n ::continue_repeat::" + %lua::append "\nend --while-loop" if (%body has subtree \(stop repeating)): %inner_lua = %lua @@ -150,25 +150,24 @@ test: .. ::stop_repeat:: end -- end of 'stop repeating' label scope" - return %lua - (repeat %body) parses as (repeat while (yes) %body) (repeat until %condition %body) parses as (repeat while (not %condition) %body) - test: %x = 0 repeat 10 times: %x += 1 assume (%x == 10) + (repeat %n times %body) compiles to: define mangler - %lua = (..) - Lua "for \(mangle "i")=1,\(%n as lua expr) do\n " + %lua = (Lua "for \(mangle "i")=1,\(%n as lua expr) do\n ") %lua::append (%body as lua) if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next repeat)): %lua::append "\n ::continue_repeat::" + %lua::append "\nend --numeric for-loop" if (%body has subtree \(stop repeating)): %inner_lua = %lua @@ -177,17 +176,18 @@ test: .. ::stop_repeat:: end -- end of 'stop repeating' label scope" - return %lua ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test: %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]) %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]) %nums = [] for %outer in 1 to 100: @@ -195,10 +195,9 @@ test: if (%inner == 2): %nums::add -2 do next %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]) # Numeric range for loops @@ -209,15 +208,11 @@ test: # This uses Lua's approach of only allowing loop-scoped variables in a loop unless (%var.type is "Var"): compile error at %var "Expected a variable here, not a \(%var.type)" - %lua = (..) - Lua "\ - ..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..) - %step as lua expr - .. do" - + %lua = (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) if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next %var)): %lua::append "\n " (what (===next %var ===) compiles to) @@ -228,7 +223,6 @@ test: %lua::append %inner_lua "\n " %lua::append (what (===stop %var ===) compiles to) %lua::append "\nend -- end of scope for stopping for-loop" - return %lua ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -239,25 +233,33 @@ test: test: %a = [10, 20, 30, 40, 50] %b = [] - for %x in %a: %b::add %x + for %x in %a: + %b::add %x assume (%a == %b) %b = [] for %x in %a: - if (%x == 10): do next %x - if (%x == 50): stop %x + if (%x == 10): + do next %x + + if (%x == 50): + stop %x + %b::add %x - assume (%b == [20, 30, 40]) # For-each loop (lua's "ipairs()") (for %var in %iterable %body) compiles to: define mangler + # This uses Lua's approach of only allowing loop-scoped variables in a loop %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) if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next %var)): %lua::append "\n " (what (===next %var ===) compiles to) @@ -268,17 +270,19 @@ test: %lua::append %inner_lua "\n " %lua::append (what (===stop %var ===) compiles to) %lua::append "\nend -- end of scope for stopping for-loop" - return %lua # TODO: reduce code duplication (for %var in %iterable at %i %body) compiles to: # This uses Lua's approach of only allowing loop-scoped variables in a loop %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) if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next %var)): %lua::append "\n " (what (===next %var ===) compiles to) @@ -289,37 +293,36 @@ test: %lua::append %inner_lua "\n " %lua::append (what (===stop %var ===) compiles to) %lua::append "\nend -- end of scope for stopping for-loop" - return %lua test: - %d = {a:10, b:20, c:30, d:40, e:50} + %d = {a: 10, b: 20, c: 30, d: 40, e: 50} %result = [] for %k = %v in %d: - if (%k == "a"): do next %k - if (%v == 20): do next %v + if (%k == "a"): + do next %k + + if (%v == 20): + do next %v + %result::add "\%k = \%v" - assume ((%result sorted) == ["c = 30", "d = 40", "e = 50"]) # 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: # This uses Lua's approach of only allowing loop-scoped variables in a loop unless (%key.type is "Var"): compile error at %key "Expected a variable here, not a \(%key.type)" + unless (%value.type is "Var"): 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) if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next %key)): %lua::append "\n " (what (===next %key ===) compiles to) @@ -350,8 +353,10 @@ test: (1 == 0) (1 == 1) %not_a_variable.x: do nothing (1 == 1): barf "bad conditional" + (1 == 2): barf "bad conditional" + else: barf "bad conditional" @@ -361,30 +366,29 @@ test: %clause = "if" %else_allowed = (yes) unless (%body.type is "Block"): - compile error at %body "'if' expected a Block, but got a \(%body.type)." - ..hint "Perhaps you forgot to put a ':' after 'if'?" + compile error at %body "'if' expected a Block, but got a \(%body.type)." "\ + ..Perhaps you forgot to put a ':' after 'if'?" for %line in %body: unless (..) ((%line.type is "Action") and ((size of %line) >= 2)) and (..) %line.(size of %line) is "Block" syntax tree ..: - compile error at %line "Invalid line for the body of an 'if' block." - ..hint "Each line should contain one or more conditional expressions \ - ..followed by a block, or "else" followed by a block." - + compile error at %line "Invalid line for the body of an 'if' block." "\ + ..Each line should contain one or more conditional expressions followed by a block, or "else" followed \ + ..by a block." %action = %line.(size of %line) if ((%line.1 is "else") and ((size of %line) == 2)): unless %else_allowed: - compile error at %line "You can't have two 'else' blocks." - ..hint "Merge all of the 'else' blocks together." + compile error at %line "You can't have two 'else' blocks." "\ + ..Merge all of the 'else' blocks together." unless ((size of "\%code") > 0): compile error at %line "\ ..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' \ - ..block comes last." + .."\ + ..If you want the code in this block to always execute, you don't need a conditional block around it. \ + ..Otherwise, make sure the 'else' block comes last." %code::append "\nelse\n " (%action as lua) %else_allowed = (no) @@ -394,13 +398,13 @@ test: if (%i > 1): %code::append " or " %code::append (%line.%i as lua expr) - %code::append " then\n " (%action as lua) %clause = "\nelseif" if ((size of "\%code") == 0): - compile error at %body "'if' block has an empty body." - ..hint "This means nothing would happen, so the 'if' block should be deleted." + compile error at %body "'if' block has an empty body." "\ + ..This means nothing would happen, so the 'if' block should be deleted." + %code::append "\nend --when" return %code @@ -408,9 +412,13 @@ test: if 5 is: 1 2 3: barf "bad switch statement" - 4 5: do nothing + + 4 5: + do nothing + 5 6: barf "bad switch statement" + else: barf "bad switch statement" @@ -421,28 +429,28 @@ test: %else_allowed = (yes) define mangler unless (%body.type is "Block"): - compile error at %body "'if' expected a Block, but got a \(%body.type)" - ..hint "Perhaps you forgot to put a ':' after the 'is'?" + compile error at %body "'if' expected a Block, but got a \(%body.type)" "\ + ..Perhaps you forgot to put a ':' after the 'is'?" + for %line in %body: unless (..) ((%line.type is "Action") and ((size of %line) >= 2)) and (..) %line.(size of %line) is "Block" syntax tree ..: - compile error at %line "Invalid line for 'if' block." - ..hint "Each line should contain expressions \ - ..followed by a block, or "else" followed by a block" - + compile error at %line "Invalid line for 'if' block." "\ + ..Each line should contain expressions followed by a block, or "else" followed by a block" %action = %line.(size of %line) if ((%line.1 is "else") and ((size of %line) == 2)): unless %else_allowed: - compile error at %line "You can't have two 'else' blocks." - ..hint "Merge all of the 'else' blocks together." + compile error at %line "You can't have two 'else' blocks." "\ + ..Merge all of the 'else' blocks together." + unless ((size of "\%code") > 0): compile error at %line "\ ..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' \ - ..block comes last." + .."\ + ..If you want the code in this block to always execute, you don't need a conditional block around it. \ + ..Otherwise, make sure the 'else' block comes last." %code::append "\nelse\n " (%action as lua) %else_allowed = (no) @@ -452,13 +460,13 @@ test: if (%i > 1): %code::append " or " %code::append "\(mangle "branch value") == " (%line.%i as lua expr) - %code::append " then\n " (%action as lua) %clause = "\nelseif" if ((size of "\%code") == 0): - compile error at %body "'if' block has an empty body." - ..hint "This means nothing would happen, so the 'if' block should be deleted." + compile error at %body "'if' block has an empty body." "\ + ..This means nothing would happen, so the 'if' block should be deleted." + %code::append "\nend --when" return (..) Lua "\ @@ -468,19 +476,17 @@ test: end -- if % is..." # Do/finally -(do %action) compiles to "\ - ..do - \(%action as lua) - end -- do" - +(do %action) compiles to "do\n \(%action as lua)\nend -- do" test: %d = {} try: do: %d.x = "bad" barf - ..then always: %d.x = "good" + ..then always: + %d.x = "good" assume (%d.x == "good") + (do %action then always %final_action) compiles to: define mangler return (..) @@ -497,19 +503,19 @@ test: end" test: - assume ((result of (: return 99)) == 99) + assume ((result of: return 99) == 99) # Inline thunk: (result of %body) compiles to "\(what ([] -> %body) compiles to)()" - test: %t = [1, [2, [[3], 4], 5, [[[6]]]]] %flat = [] for % in recursive %t: if ((lua type of %) is "table"): - for %2 in %: recurse % on %2 - ..else: %flat::add % - + for %2 in %: + recurse % on %2 + ..else: + %flat::add % assume (sorted %flat) == [1, 2, 3, 4, 5, 6] # Recurion control flow @@ -518,6 +524,7 @@ test: define mangler (recurse %v on %x) compiles to (..) Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))" + %lua = (..) Lua "\ ..do @@ -525,10 +532,13 @@ test: while #\(mangle "stack \(%var.1)") > 0 do \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1) \(%body as lua)" + if (%body has subtree \(do next)): %lua::append "\n ::continue::" + if (%body has subtree \(do next %var)): %lua::append "\n \(what (===next %var ===) compiles to)" + %lua::append "\n end -- Recursive loop" if (%body has subtree \(stop %var)): %lua::append "\n \(what (===stop %var ===) compiles to)" diff --git a/core/coroutines.nom b/core/coroutines.nom index 27797fa..7d17d63 100644 --- a/core/coroutines.nom +++ b/core/coroutines.nom @@ -1,7 +1,7 @@ -#!/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 - + use "core/metaprogramming.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -14,8 +14,11 @@ test: -> 5 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" + [coroutine %body, generator %body] all compile to "\ ..(function() \(%body as lua) diff --git a/core/errors.nom b/core/errors.nom index e254209..12a5b29 100644 --- a/core/errors.nom +++ b/core/errors.nom @@ -1,16 +1,16 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # This file contains basic error reporting code - + 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: - lua> "\ - ..local \%assumption = 'Assumption failed: '..tostring((\%condition):get_source_code())" + lua> "local \%assumption = 'Assumption failed: '..tostring((\%condition):get_source_code())" return (..) Lua "\ ..if not \(%condition as lua expr) then @@ -18,17 +18,14 @@ use "core/metaprogramming.nom" end" (assume %a == %b) compiles to: - lua> "\ - ..local \%assumption = 'Assumption failed: '..tostring(\(\(%a == %b) as nomsu))" + lua> "local \%assumption = 'Assumption failed: '..tostring(\(\(%a == %b) as nomsu))" define mangler return (..) Lua "\ ..do local \(mangle "a"), \(mangle "b") = \(%a as lua expr), \(%b as lua expr) if \(mangle "a") ~= \(mangle "b") then - error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(..) - mangle "b" - ..), 0) + error(\(quote "\%assumption").."\\n"..tostring(\(mangle "a")).." != "..tostring(\(mangle "b")), 0) end end" @@ -38,16 +35,18 @@ use "core/metaprogramming.nom" end" test: - try (barf) and if it succeeds: barf "try failed." + try (barf) and if it succeeds: + barf "try failed." %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" %x = 1 try: %x = 2 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" # Try/except @@ -81,19 +80,19 @@ test: # [..] - 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 succeeds %success or if it barfs %fallback + try %action and if it barfs %fallback or if it succeeds %success ..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 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - + (try %action) parses as (..) try %action and if it succeeds (do nothing) or if it barfs (do nothing) #(try %action and if it barfs %fallback) parses as (..) try %action and if it succeeds (do nothing) or if it barfs %fallback - + (try %action and if it barfs %msg %fallback) parses as (..) try %action and if it succeeds (do nothing) or if it barfs %msg %fallback diff --git a/core/id.nom b/core/id.nom index 8875696..9cf5820 100644 --- a/core/id.nom +++ b/core/id.nom @@ -1,7 +1,7 @@ -#!/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 - + use "core/metaprogramming.nom" use "core/operators.nom" use "core/math.nom" @@ -13,21 +13,22 @@ use "core/control_flow.nom" %NaN_surrogate = {} %nil_surrogate = {} %obj_by_id = {} -set %obj_by_id's metatable to {__mode:"v"} +set %obj_by_id's metatable to {__mode: "v"} %id_by_obj = {} -set %id_by_obj 's metatable to {..} - __mode:"k", __index: (..) - [%self, %key] ->: - if (%key == (nil)): - return %self.%nil_surrogate - if (%key != %key): - return %self.%NaN_surrogate - --- (retry) --- - %id = (uuid) - if (%obj_by_id.%id != (nil)): go to (retry) - %self.%key = %id - %obj_by_id.%id = %key - return %id +set %id_by_obj's metatable to {..} + __mode: "k", __index: [%self, %key] ->: + if (%key == (nil)): + return %self.%nil_surrogate + + if (%key != %key): + return %self.%NaN_surrogate + + --- (retry) --- + %id = (uuid) + if (%obj_by_id.%id != (nil)): go to (retry) + %self.%key = %id + %obj_by_id.%id = %key + return %id externally (uuid) means: # Set all the other bits to randomly (or pseudo-randomly) chosen values. diff --git a/core/io.nom b/core/io.nom index 2df0999..d9dbdd3 100644 --- a/core/io.nom +++ b/core/io.nom @@ -1,7 +1,7 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # This file contains basic input/output code - + use "core/metaprogramming.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -19,7 +19,5 @@ use "core/metaprogramming.nom" ..if \%prompt.type == "Text" then return LuaCode("(io.write(", \(%prompt as lua expr), ") and io.read())"); else - return LuaCode("(io.write(tostring(", \(..) - %prompt as lua expr - .., ")) and io.read())"); + return LuaCode("(io.write(tostring(", \(%prompt as lua expr), ")) and io.read())"); end" diff --git a/core/math.nom b/core/math.nom index 8951721..583cc8c 100644 --- a/core/math.nom +++ b/core/math.nom @@ -1,7 +1,7 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # This file defines some common math literals and functions - + use "core/metaprogramming.nom" use "core/text.nom" use "core/operators.nom" @@ -28,7 +28,6 @@ test: assume (("5" as a number) == 5) ((% as a number)'s meaning) = ((tonumber %)'s meaning) ((% as number)'s meaning) = ((tonumber %)'s meaning) - test: assume (..) all of [..] @@ -36,101 +35,108 @@ test: 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 ..or barf "math functions failed" -[absolute value %, | % |, abs %] all compile to (..) - "math.abs(\(% as lua expr))" - -[square root %, square root of %, √ %, sqrt %] all compile to (..) - "math.sqrt(\(% as lua expr))" - +[absolute value %, | % |, abs %] all compile to "math.abs(\(% 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))" [cosine %, cos %] all compile to "math.cos(\(% 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 cosine %, acos %] all compile to "math.acos(\(% as lua expr))" [arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))" -[arc tangent %y / %x, atan2 %y %x] all compile to (..) - "math.atan2(\(%y as lua expr), \(%x as lua expr))" - -[hyperbolic sine %, sinh %] all compile to (..) - "math.sinh(\(% 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))" - +[arc tangent %y / %x, atan2 %y %x] all compile to "\ + ..math.atan2(\(%y as lua expr), \(%x as lua expr))" +[hyperbolic sine %, sinh %] all compile to "math.sinh(\(% 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))" -[natural log %, ln %, log %] all compile to (..) - "math.log(\(% as lua expr))" - -[log % base %base, log base %base of %] all compile to (..) - "math.log(\(% as lua expr), \(%base as lua expr))" - +[natural log %, ln %, log %] all compile to "math.log(\(% 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))" [ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))" -[round %, % rounded] all compile to (..) - "math.floor(\(% as lua expr) + .5)" - +[round %, % rounded] all compile to "math.floor(\(% as lua expr) + .5)" test: 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" + externally (%n to the nearest %rounder) means (..) =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)" # Any/all externally [all of %items, all %items] all mean: for % in %items: - unless %: return (no) + unless %: + return (no) return (yes) + [all of %items, all %items] all compile to: unless (%items.type is "List"): return \(all of %items) - if ((size of %items) == 0): return (Lua "true") + + if ((size of %items) == 0): + return (Lua "true") + %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 ")" 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: for % in %items: - if %: return (yes) + if %: + return (yes) return (no) + [any of %items, any %items] all compile to: unless (%items.type is "List"): return \(any of %items) - if ((size of %items) == 0): return (Lua "false") + + if ((size of %items) == 0): + return (Lua "false") + %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 ")" return %lua + [none of %items, none %items] all parse as (not (any of %items)) # Sum/product externally [sum of %items, sum %items] all mean: %total = 0 - for % in %items: %total += % + for % in %items: + %total += % return %total + [sum of %items, sum %items] all compile to: unless (%items.type is "List"): return \(sum of %items) - if ((size of %items) == 0): return (Lua "0") + + if ((size of %items) == 0): + return (Lua "0") + %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 ")" return %lua externally [product of %items, product %items] all mean: %prod = 1 - for % in %items: %prod *= % + for % in %items: + %prod *= % return %prod + [product of %items, product %items] all compile to: unless (%items.type is "List"): return \(product of %items) - if ((size of %items) == 0): return (Lua "1") + + if ((size of %items) == 0): + return (Lua "1") + %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 ")" 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 (..) if (any of %items) %body -[if all of %items %body else %else, if all of %items then %body else %else] all parse \ -..as (if (all of %items) %body else %else) +[if all of %items %body else %else, if all of %items then %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) -[if any of %items %body else %else, if any of %items then %body else %else] all parse \ -..as (if (any of %items) %body else %else) +[if any of %items %body else %else, if any of %items then %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) -[if none of %items %body else %else, if none of %items then %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 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) # Min/max externally [min of %items, smallest of %items, lowest of %items] all mean: %best = (nil) for % in %items: - if ((%best == (nil)) or (% < %best)): - %best = % + if ((%best == (nil)) or (% < %best)): %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) for % in %items: - if ((%best == (nil)) or (% > %best)): - %best = % + if ((%best == (nil)) or (% > %best)): %best = % return %best test: assume ((min of [3, -4, 1, 2] by % = (% * %)) == 1) assume ((max of [3, -4, 1, 2] by % = (% * %)) == -4) + (min of %items by %item = %value_expr) parses as (..) result of: %best = (nil) @@ -219,17 +223,14 @@ test: # Random functions externally (seed random with %) means: - lua> "\ - ..math.randomseed(\%); - for i=1,20 do math.random(); end" - + lua> "math.randomseed(\%);\nfor i=1,20 do math.random(); end" (seed random) parses as (seed random with (=lua "os.time()")) [random number, random, rand] all compile to "math.random()" -[random int %n, random integer %n, randint %n] all compile to (..) - "math.random(\(%n as lua expr))" +[random int %n, random integer %n, randint %n] all compile to "\ + ..math.random(\(%n as lua expr))" -[random from %low to %high, random number from %low to %high, rand %low %high] all \ -..compile to "math.random(\(%low as lua expr), \(%high as lua expr))" +[random from %low to %high, random number from %low to %high, rand %low %high] \ +..all compile to "math.random(\(%low as lua expr), \(%high as lua expr))" externally [..] random choice from %elements, random choice %elements, random %elements diff --git a/core/metaprogramming.nom b/core/metaprogramming.nom index b27147d..944dc34 100644 --- a/core/metaprogramming.nom +++ b/core/metaprogramming.nom @@ -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 functions to make that easier. - -lua> "\ - ..NOMSU_CORE_VERSION = 10 - NOMSU_LIB_VERSION = 7" + +lua> "NOMSU_CORE_VERSION = 10\nNOMSU_LIB_VERSION = 7" lua> "\ ..do local mangle_index = 0 @@ -25,7 +23,8 @@ lua> "\ ..compile.action["1 ->"] = function(compile, \%args, \%body) local lua = LuaCode("(function(") 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, ", ") 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 @@ -49,9 +48,11 @@ lua> "\ test: (five) compiles to "5" + test: assume ((five) == 5) or barf "Compile to expression failed." (loc x) compiles to "local x = 99;" + test: lua> "do" loc x @@ -61,9 +62,11 @@ test: (asdf) compiles to: %tmp = "" return (Lua %tmp) + test: asdf assume (%tmp is (nil)) or barf "compile to is leaking variables" + lua> "\ ..compile.action["1 compiles to"] = function(compile, \%action, \%body) local \%args = List{\(\%compile), unpack(\%action:get_args())} @@ -114,11 +117,9 @@ test: (foo %x) means: %y = (%x + 1) return %y - assume ((foo 10) == 11) or barf "Action didn't work." assume (%y is (nil)) or barf "Action leaked a local into globals." (baz %) parses as (foo %) - assume ((foo 1) == "outer") (%action means %body) compiles to: @@ -128,6 +129,7 @@ test: local lua = LuaCode(fn_name, " = ", \(what (%args -> %body) compiles to)) lua:add_free_vars({fn_name}) return lua" + (%actions all mean %body) compiles to: lua> "\ ..local fn_name = \%actions[1].stub:as_lua_id() @@ -148,16 +150,20 @@ test: return lua" test: - externally (baz1) means: return "baz1" + externally (baz1) means: + return "baz1" externally (baz2) means "baz2" + test: assume ((baz1) == "baz1") assume ((baz2) == "baz2") + (externally %action means %body) compiles to: lua> "\ ..local lua = \(what (%action means %body) compiles to) lua:remove_free_vars({\%action.stub:as_lua_id()}) return lua" + (externally %actions all mean %body) compiles to: lua> "\ ..local lua = \(what (%actions all mean %body) compiles to) @@ -166,23 +172,25 @@ test: test: 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: (swap %x and %y) parses as (..) do: %tmp = %x %x = %y %y = %tmp + test: - set {%1:1, %2:2} + set {%1: 1, %2: 2} swap %1 and %2 assume ((%1 == 2) and (%2 == 1)) or barf "\ ..'parse % as %' failed on 'swap % and %'" - set {%tmp:1, %tmp2:2} + set {%tmp: 1, %tmp2: 2} swap %tmp and %tmp2 assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\ ..'parse % as %' variable mangling failed." + (%actions all parse as %body) compiles to: lua> "\ ..local replacements = {} @@ -197,7 +205,8 @@ test: if replacements[t[1]] then return replacements[t[1]] 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 elseif SyntaxTree:is_instance(t) then local ret = {} @@ -227,12 +236,10 @@ test: local ret = \(what (%actions all compile to %new_body) compiles to) return ret" -~~~~~~~~~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [%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 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)" externally (%tree with vars %replacements) means (..) @@ -317,14 +327,9 @@ externally (%tree with %patt ~> %replacement) means: end)" test: - assume (..) - (..) - quote "\ - ..one - "two"" - ..== "\"one\\n\\\"two\\\"\"" -(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()" + assume ((quote "one\n\"two\"") == "\"one\\n\\\"two\\\"\"") +(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()" test: assume (lua type of {}) == "table" assume (type of {}) == "Dict" @@ -346,8 +351,8 @@ externally (type of %) means: return lua_type" [% is a %type, % is an %type] all parse as ((type of %) == %type) -[% isn't a %type, % isn't an %type, % is not a %type, % is not an %type] 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 ((type of %) != %type) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -357,18 +362,14 @@ test: run "external %passed = (yes)" assume %passed assume (run \(return \(\(5) + \(5)))) == 10 -(run %nomsu_code) compiles to "\ - ..run_1_in(\(%nomsu_code as lua expr), _ENV)" - +(run %nomsu_code) compiles to "run_1_in(\(%nomsu_code as lua expr), _ENV)" [compile %block, compiled %block, %block compiled] all compile to "\ ..compile(\(%block as lua))" # 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. (return %return_value) compiles to "\ - ..do return \(..) - =lua "\%return_value and \(%return_value as lua expr) or ''" - .. end" + ..do return \(=lua "\%return_value and \(%return_value as lua expr) or ''") end" # Literals (yes) compiles to "true" @@ -392,5 +393,4 @@ test: end" externally (Nomsu version) means: - return "\ - ..\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)" + return "\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)" diff --git a/core/operators.nom b/core/operators.nom index 19a61d7..cc86398 100644 --- a/core/operators.nom +++ b/core/operators.nom @@ -1,7 +1,7 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # This file contains definitions of operators like "+" and "and". - + use "core/metaprogramming.nom" use "core/errors.nom" @@ -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))" [%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 as lua expr) ~= \(%b as lua expr))" @@ -38,9 +37,9 @@ test: return lua" test: - set {%x:10, %y:20} + set {%x: 10, %y: 20} 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." # Simultaneous mutli-assignments like: x,y,z = 1,x,3; @@ -48,6 +47,7 @@ test: (set %assignments) compiles to: assume (%assignments.type is "Dict") or barf "\ ..Expected a Dict for the assignments part of '<- %' statement, not \%assignments" + lua> "\ ..local lhs, rhs = LuaCode(), LuaCode() for i, item in ipairs(\%assignments) do @@ -74,40 +74,37 @@ test: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test: - set {%foozle:"outer", %y:"outer"} + set {%foozle: "outer", %y: "outer"} externally (set global x local y) means: external %foozle = "inner" %y = "inner" - set global x local y assume ((%foozle == "inner") and (%y == "outer")) or barf "external failed." (external %var = %value) compiles to "\(%var as lua) = \(%value as lua)" - test: - set {%foozle:"outer", %y:"outer"} + set {%foozle: "outer", %y: "outer"} externally (set global x local y) means: with external [%foozle]: %foozle = "inner" %y = "inner" - set global x local y assume ((%foozle == "inner") and (%y == "outer")) or barf "\ ..'with external' failed." + (with external %externs %body) compiles to: %body_lua = (%body as lua) - lua> "\ - ..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return compile(v):text() end))" + lua> "\%body_lua:remove_free_vars(table.map(\%externs, function(v) return compile(v):text() end))" return %body_lua test: - set {%x:1, %y:2} - with {%z:nil, %x:999}: + set {%x: 1, %y: 2} + with {%z: nil, %x: 999}: %z = 999 assume (%z == 999) or barf "'with' failed." assume (%x == 999) or barf "'with' assignment failed." - assume (%x == 1) or barf "'with' scoping failed" assume (%z == (nil)) or barf "'with' scoping failed" + (with %assignments %body) compiles to: %lua = (%body as lua) lua> "\ @@ -132,18 +129,14 @@ test: end \%lua:remove_free_vars(vars) \%lua:prepend("local ", lhs, " = ", rhs, ";\\n")" - - return (..) - Lua "\ - ..do - \%lua - end -- 'with' block" + return (Lua "do\n \%lua\nend -- 'with' block") # Math Operators test: 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 # (uses a lambda to avoid re-evaluating middle value, while still being an expression) @@ -152,10 +145,10 @@ test: (one) means: external %calls = (%calls + 1) return 1 - assume (0 <= (one) <= 2) or barf "Three-way chained comparison failed." assume (%calls == 1) or barf "\ ..Three-way comparison evaluated middle value multiple times" + (%x < %y < %z) parses as (..) 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. lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then" [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 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 OR %y, %x | %y] all compile to "\ + ..bit.bor(\(%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 "\ ..bit.lshift(\(%x as lua expr), \(%shift as lua expr))" + [%x RSHIFT %shift, %x >> %shift] all compile to "\ ..bit.rshift(\(%x as lua expr), \(%shift as lua expr))" + lua> "else" [NOT %, ~ %] all compile to "~(\(% 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 LSHIFT %shift, %x << %shift] all compile to "\ ..(\(%x as lua expr) << \(%shift as lua expr))" + [%x RSHIFT %shift, %x >> %shift] all compile to "\ ..(\(%x as lua expr) >> \(%shift as lua expr))" + lua> "end" # Unary operators @@ -230,11 +233,9 @@ test: assume ((not (yes)) == (no)) (- %) compiles to "(- \(% as lua expr))" (not %) compiles to "(not \(% as lua expr))" - test: assume ((size of [1, 2, 3]) == 3) (size of %list) compiles to "(#\(%list as lua expr))" - (%list is empty) compiles to "(#\(%list as lua expr) == 0)" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/core/scopes.nom b/core/scopes.nom index bd8b8a6..009728b 100644 --- a/core/scopes.nom +++ b/core/scopes.nom @@ -1,7 +1,7 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # This file contains definitions pertaining to variable scoping - + use "core/metaprogramming.nom" use "core/operators.nom" use "core/collections.nom" @@ -14,34 +14,26 @@ test: with local %x: %x = "inner" assume (%x == "inner") - assume (%x == "outer") externally (foo) means "outer foo" with local [(foo)'s meaning]: externally (foo) means "inner foo" assume ((foo) == "inner foo") - assume ((foo) == "outer foo") + [with local %locals %body, with local %locals do %body] all compile to: %body_lua = (%body as lua) if %locals.type is: "Dict": - %body_lua = (..) - Lua "\ - ..\(what (<- %locals) compiles to) - \%body_lua" - - %body_lua::declare locals ("\(%.1 as lua)" for % in %locals) + %body_lua = (Lua "\(what (<- %locals) compiles to)\n\%body_lua") + %body_lua::declare locals [: for % in %locals: add "\(%.1 as lua)"] "List": - %body_lua::declare locals ("\(% as lua)" for % in %locals) + %body_lua::declare locals [: for % in %locals: add "\(% as lua)"] + "Var" "Action": %body_lua::declare locals ["\(%locals as lua)"] + else: compile error at %locals "Unexpected local value" - - return (..) - Lua "\ - ..do - \%body_lua - end" + return (Lua "do\n \%body_lua\nend") diff --git a/core/text.nom b/core/text.nom index 28944dd..86d8d45 100644 --- a/core/text.nom +++ b/core/text.nom @@ -1,8 +1,8 @@ -#!/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 color codes. - + use "core/metaprogramming.nom" use "core/operators.nom" use "core/control_flow.nom" @@ -27,19 +27,19 @@ test: assume ("asdf"::with "s" -> "X") == "aXdf" assume ("one\ntwo\n"::lines) == ["one", "two", ""] (%spec とは %body) parses as (%spec means %body) + test: %こんにちは = "こんにちは" (% と言う) とは "\(%)世界" assume (%こんにちは と言う) == "こんにちは世界" + (%expr for %match in %text matching %patt) compiles to: define mangler return (..) Lua "\ ..(function() local \(mangle "comprehension") = List{} - for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..) - %patt as lua expr - ..) do + for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(%patt as lua expr)) do \(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua) end return \(mangle "comprehension") @@ -50,8 +50,9 @@ test: # Text literals %escapes = {..} - nl:"\n", newline:"\n", tab:"\t", bell:"\a", cr:"\r", "carriage return":"\r", - backspace:"\b", "form feed":"\f", formfeed:"\f", "vertical tab":"\v" + nl: "\n", newline: "\n", tab: "\t", bell: "\a", cr: "\r", "carriage return": "\r" + backspace: "\b", "form feed": "\f", formfeed: "\f", "vertical tab": "\v" + for %name = %str in %escapes: with {%lua: Lua (quote %str)}: - %compile.action.%name = ([]-> %lua) + %compile.action.%name = ([] -> %lua) diff --git a/examples/how_do_i.nom b/examples/how_do_i.nom index 4dba722..3f816d1 100644 --- a/examples/how_do_i.nom +++ b/examples/how_do_i.nom @@ -1,4 +1,4 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # How do I... # Write a comment? Put a # and go till the end of the line # How do I write a multi-line comment? @@ -65,7 +65,7 @@ say "\ Similarly, you can put a long interpolated indented value like: \(..) 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 .. between a backslash and two periods." - + say "Single-line text can contain escape sequences like \", \\, \000, and \n" # How do I define a list? @@ -91,7 +91,7 @@ say %my_list.1 # How do I define a dictionary/hash map? 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: -%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? # 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: (3 > 3): say "this won't print" + (3 > 6) (3 > 5) (3 > 4): say "this won't print because none of the conditions on the line above are true" + (3 > 2): say "this will print" + else: say "this is the default case" @@ -124,8 +127,10 @@ when: if (1 + 2) is: 0 1: say "this won't print" + 2 3: say "this will print" + else: say "this won't print" @@ -140,7 +145,9 @@ for %i in 1 to 3: say "For %i in 1 to 3 loop #\%i" # 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: say "Backwards #\%backwards" @@ -149,7 +156,6 @@ for %backwards in 3 to 1 by -1: repeat while (%x <= 3): say "repeat while loop #\%x" %x += 1 - %x = 1 repeat until (%x > 3): say "repeat until loop #\%x" @@ -160,7 +166,8 @@ repeat until (%x > 3): repeat: say "repeat loop #\%x" %x += 1 - if (%x > 3): stop repeating + if (%x > 3): + stop repeating # How do I do a 'goto'? do: @@ -168,7 +175,8 @@ do: === (my loop) === say "GOTO loop #\%x" %x += 1 - if (%x <= 3): go to (my loop) + if (%x <= 3): + go to (my loop) say "finished going to" # How do I define a function/method/procedure? @@ -189,8 +197,8 @@ say both "Hello" and also "world!" %tmp = (%f1 + %f2) %f1 = %f2 %f2 = %tmp - if (%f2 > %n): return %f2 - + if (%f2 > %n): + return %f2 say (first fibonacci above 10) # 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 ..all mean: say "\(%better_things::capitalized) rule and \%worse_things drool!" - I like "dogs" more than "cats" 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: say %what_she_said say "-- she said" - "Howdy pardner" is what she said # The language only reserves []{}().,:;%#\ as special characters, so actions @@ -217,7 +223,6 @@ I think "chihuahuas" are worse than "corgis" say %foo_bar say % say %1 - >> "wow" $@&' --> "so flexible!" @&_~-^-~_~-^ "even numbers can be variables!" ! # 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 ".." say both "Very long first argument that needs its own line" and also "\ ..short second arg" - (my favorite number) means (21 + 2) # 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: (say the time) means: lua> "io.write(\"The OS time is: \", os.time(), \"\\n\");" - say the time 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)") ..else: return (Lua "-- (debug code removed for production)") - %DEBUG_ENABLED = (yes) # Constants can be defined as macros @@ -301,7 +303,6 @@ debug only: if ((%best is (nil)) or (%key > %best_key)): %best = %item %best_key = %key - return %best # 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)): %best = %item %best_key = %key - return %best ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/lib/base64.nom b/lib/base64.nom index 2091615..01d4f2f 100644 --- a/lib/base64.nom +++ b/lib/base64.nom @@ -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: https://tools.ietf.org/html/rfc4648 - + %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 - test: %cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"] for %len = %encoded in %cases: %plain = "foobar".[1, %len - 1] assume (base64 %plain) == %encoded assume (base64 decode %encoded) == %plain + externally [base64 %str, base64 encode %str, %str base64] all mean: %chars = [] for %i in 1 to (size of %str) via 3: @@ -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 "=" %chars::add "=" - return (%chars::joined) externally (chr %) means (=lua "string.char(\%)") externally [decode base64 %str, %str base64 decoded, base64 decode %str] all mean: %chars = [] for %i in 1 to (size of %str) via 4: - %indices = (%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))) if (%str.(%i + 2) == "="): stop %chars::add (chr (((%indices.2 & 15) << 4) + ((%indices.3 & 60) >> 2))) if (%str.(%i + 3) == "="): stop %chars::add (chr (((%indices.3 & 3) << 6) + %indices.4)) - return (%chars::joined) diff --git a/lib/consolecolor.nom b/lib/consolecolor.nom index 1016c0b..aabb740 100644 --- a/lib/consolecolor.nom +++ b/lib/consolecolor.nom @@ -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. - + test: % = (bright "\(green)Color test passed.") + %colors = {..} - 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 - # 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 - "on black":40, "on red":41, "on green":42, "on yellow":43, "on blue":44 - "on magenta":45, "on cyan":46, "on white":47 + 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, # 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, "on black": 40, "on red": 41, "on green": 42, "on yellow": 43 + "on blue": 44, "on magenta": 45, "on cyan": 46, "on white": 47 for %name = %colornum in %colors: %colornum = "\%colornum" + #(=lua "COMPILE_ACTIONS").%name = (..) [%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'") %compile.action.%name = (..) [%nomsu, %text] ->: if %text: return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')") - ..else: return (Lua "'\\027[\(%colornum)m'") + ..else: + return (Lua "'\\027[\(%colornum)m'") diff --git a/lib/file_hash.nom b/lib/file_hash.nom index ba2f95c..547afb5 100644 --- a/lib/file_hash.nom +++ b/lib/file_hash.nom @@ -1,14 +1,13 @@ -#!/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. - + use "lib/os.nom" use "lib/base64.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ lua> "local \%use_sha1, \%hashlib = pcall(require, 'openssl.digest')" - test: assume (hash "hello world") == (hash "hello world") assume ((hash "hello world") != (hash "goodbye")) or barf "\ @@ -25,16 +24,17 @@ test: assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf "\ ..Incorrect hashing of null strings" + if %use_sha1: assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=") + if %use_sha1: externally (hash %) means: %hash = (=lua "\%hashlib.new('sha1'):final(\%)") return (base64 %hash) ..else: # TODO: remove warning? - say "\ - ..\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m" + say "\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m" externally (hash %) means: %bytes = (%::bytes) %hash = (%bytes.1 << 7) @@ -47,6 +47,7 @@ externally (file with hash %hash) means: for file %filename in ".": %contents = (read file %filename) %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)) diff --git a/lib/object.nom b/lib/object.nom index d8c7f5e..103f2d7 100644 --- a/lib/object.nom +++ b/lib/object.nom @@ -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. - + %globals.METAMETHOD_MAP = {..} - "as text":"__tostring", "clean up":"__gc", "+ 1":"__add", "- 1":"__sub" - "* 1":"__mul", "/ 1":"__div", "-":"__unm", "// 1":"__idiv", "mod 1":"__mod" - "^ 1":"__pow", "& 1":"__band", "| 1":"__bor", "~ 1":"__bxor", "~":"__bnot" - "<< 1":"__bshl", ">> 1":"__bshr", "== 1":"__eq", "< 1":"__lt", "<= 1":"__le" - "set 1 = 2":"__newindex", size:"__len", iterate:"__ipairs", "iterate all":"__pairs" + "as text": "__tostring", "clean up": "__gc", "+ 1": "__add", "- 1": "__sub" + "* 1": "__mul", "/ 1": "__div", "-": "__unm", "// 1": "__idiv", "mod 1": "__mod" + "^ 1": "__pow", "& 1": "__band", "| 1": "__bor", "~ 1": "__bxor", "~": "__bnot" + "<< 1": "__bshl", ">> 1": "__bshr", "== 1": "__eq", "< 1": "__lt", "<= 1": "__le" + "set 1 = 2": "__newindex", size: "__len", iterate: "__ipairs" + "iterate all": "__pairs" test: object (Dog): (Dog).genus = "Canus" - my action [set up]: %me.barks or= 0 + my action [set up]: + %me.barks or= 0 + 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 " ") my action [get pissed off]: %me.barks += 1 - - %d = (Dog {barks:2}) + %d = (Dog {barks: 2}) assume (type of %d) == "Dog" assume (%d is a "Dog") assume %d.barks == 2 @@ -34,31 +36,31 @@ test: assume (%d.barks == 3) %d2 = (Dog {}) assume (%d2.barks == 0) or barf "Default initializer failed" - with {%d:Dog {barks:1}}: + with {%d: Dog {barks: 1}}: assume ((%d::bark) == "Bark!") + object (Corgi) extends (Dog): my action [sploot] "splooted" 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 " ") %corg = (Corgi {}) 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::bark) == "Yip!") or barf "inheritance failed" assume ((%d::woof) == "Yip!") - with {%d:Dog {barks:2}}: + with {%d: Dog {barks: 2}}: assume ((%d::bark) == "Bark! Bark!") + (my action %actions %body) compiles to: lua> "\ ..local fn_name = \%actions[1].stub:as_lua_id() local \%args = List(\%actions[1]:get_args()) table.insert(\%args, 1, \(\%me)) - local lua = LuaCode("class.", fn_name, " = ", \(..) - what (%args -> %body) compiles to - ..) + local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to)) for i=2,#\%actions do local alias = \%actions[i] local alias_name = alias.stub:as_lua_id() @@ -75,7 +77,9 @@ test: (object %classname extends %parent %class_body) compiles to: 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: unless (% is text): compile error at % "Class names should not have arguments." diff --git a/lib/os.nom b/lib/os.nom index fb705dc..c165e5a 100644 --- a/lib/os.nom +++ b/lib/os.nom @@ -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. - + test: path of Nomsu file "lib/os.nom" + externally (path of Nomsu file %filename) means: lua> "for i,f in Files.walk(\%filename) do return f end" barf "Could not find file: \%filename" @@ -17,10 +18,11 @@ externally (sh> %cmd) means: test: read file "lib/os.nom" -externally (read file %filename) means (=lua "Files.read(\%filename)") +externally (read file %filename) means (=lua "Files.read(\%filename)") test: for file %f in "core": do nothing + (for file %f in %path %body) compiles to "\ ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do \(%body as lua) @@ -49,23 +51,28 @@ externally [..] test: assume (line number of 3 in "x\ny") == 2 + externally (line number of %pos in %str) means (..) =lua "Files.get_line_number(\%str, \%pos)" test: assume (line 2 in "one\ntwo\nthree") == "two" + externally (line %line_num in %str) means (..) =lua "Files.get_line(\%str, \%line_num)" test: assume (source lines of \(this)) + externally (source lines of %tree) means: %source = (%tree.source if (%tree is syntax tree) else %tree) %file = (read file %source.filename) 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" externally (spoof file %text) means (%Files.spoof %text) diff --git a/lib/things.nom b/lib/things.nom index 11863de..bf4ac3b 100644 --- a/lib/things.nom +++ b/lib/things.nom @@ -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. - + %globals.METAMETHOD_MAP = {..} - "as text": "__tostring", "clean up": "__gc", - "+": "__add", "-": "__sub", "*": "__mul", "/": "__div", - "negative": "__unm", "//": "__idiv", "mod": "__mod", "^": "__pow", - "&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot", - "<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", - "<=": "__le", "set 1 =": "__newindex", "size": "__len", - "iterate": "__ipairs", "iterate all": "__pairs", + "as text": "__tostring", "clean up": "__gc", "+": "__add", "-": "__sub" + "*": "__mul", "/": "__div", negative: "__unm", "//": "__idiv", mod: "__mod" + "^": "__pow", "&": "__band", "|": "__bor", "~": "__bxor", "~": "__bnot" + "<<": "__bshl", ">>": "__bshr", "==": "__eq", "<": "__lt", "<=": "__le" + "set 1 =": "__newindex", size: "__len", iterate: "__ipairs", "iterate all": "__pairs" test: a (Dog) is a thing: that can (set up) by: %its.barks or= 0 + whose [bark, woof] all mean: - %barks = ("Bark!" for % in 1 to %its.barks) + %barks = [: for % in 1 to %its.barks: add "Bark!"] return (%barks::joined with " ") - that can (get pissed off) by: - %its.barks += 1 + + that can (get pissed off) by: %its.barks += 1 (Dog).genus = "Canus" - - %d = (a Dog with {barks:2}) + %d = (a Dog with {barks: 2}) assume (type of %d) == "Dog" assume (%d is a "Dog") assume %d.barks == 2 @@ -37,36 +35,37 @@ test: assume (%d.barks == 3) %d2 = (a Dog) 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!") + a (Corgi) is a thing: that can [set up, get pissed off] like a (Dog) whose (sploot) means "splooted" 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 " ") %corg = (a Corgi) 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::bark) == "Yip!") or barf "inheritance failed" assume ((%d::woof) == "Yip!") - with {%d:a Dog with {barks:2}}: + with {%d: a Dog with {barks: 2}}: assume ((%d::bark) == "Bark! Bark!") [..] - that can %actions by %body, - whose %actions means %body, whose %actions all mean %body, + that can %actions by %body, whose %actions means %body + whose %actions all mean %body ..all compile to: - unless (%actions.type == "List"): %actions = [%actions] + unless (%actions.type == "List"): + %actions = [%actions] + lua> "\ ..local fn_name = \%actions[1].stub:as_lua_id() local \%args = List{\(\%its), unpack(\%actions[1]:get_args())} - local lua = LuaCode("class.", fn_name, " = ", \(..) - what (%args -> %body) compiles to - ..) + local lua = LuaCode("class.", fn_name, " = ", \(what (%args -> %body) compiles to)) for i=2,#\%actions do local alias = \%actions[i] local alias_name = alias.stub:as_lua_id() @@ -85,8 +84,8 @@ test: return lua" [..] - 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 can %actions like a %class, that can %actions like an %class + that has %actions like a %class, that has %actions like an %class ..all compile to: %lua = (Lua "") %class_expr = (%class as lua expr) @@ -96,13 +95,15 @@ test: %lua::add %lines joined with "\n" return %lua - (a %classname is a thing with %members %class_body) compiles to: 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: unless (% is text): compile error at % "Class names should not have arguments." + return (..) Lua "\ ..do @@ -142,4 +143,5 @@ test: 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 diff --git a/lib/training_wheels.nom b/lib/training_wheels.nom index f16b700..00ad64b 100644 --- a/lib/training_wheels.nom +++ b/lib/training_wheels.nom @@ -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 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 not (%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)) [function %names %body, def %names %body] all parse as (..) externally %names means %body - (switch %branch_value %body) parses as (if %branch_value is %body) [None, Null] all parse as (nil) [True, true] all parse as (yes) @@ -17,7 +16,7 @@ (%a && %b) parses as (%a and %b) (continue) parses as (do next) (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 %) [error!, panic!, fail!, abort!] all parse as (barf!) [error %, panic %, fail %, abort %] all parse as (barf %) diff --git a/lib/version.nom b/lib/version.nom index ee9ac92..e4a29e4 100644 --- a/lib/version.nom +++ b/lib/version.nom @@ -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. lua> "NOMSU_LIB_VERSION = 7" diff --git a/tools/autoformat.nom b/tools/autoformat.nom index fed611d..f236ca4 100755 --- a/tools/autoformat.nom +++ b/tools/autoformat.nom @@ -1,10 +1,10 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # Auto-format Nomsu code. Usage: nomsu tools/autoformat.nom [-i] file1 file2 directory1 ... If the first argument is "-i", modifications will be performed in-place. Otherwise, the formatted code will be printed. - + use "lib/os.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -24,4 +24,5 @@ for %path in %args: if %inplace: write %formatted to file %filename - ..else: say %formatted + ..else: + say %formatted diff --git a/tools/find_action.nom b/tools/find_action.nom index 5885793..a6be84f 100755 --- a/tools/find_action.nom +++ b/tools/find_action.nom @@ -3,7 +3,7 @@ Find an action by its stub. Usage: nomsu tools/find_action.nom "foo %" file1 file2 directory1 ... Will print all the code locations and code that uses the stub. - + use "lib/os.nom" use "lib/consolecolor.nom" @@ -22,19 +22,20 @@ for %path in %files: ..and if it barfs %msg: say (red "\%filename failed to parse:\n\%msg") %tree = (nil) - unless %tree: do next %filename + + unless %tree: + do next %filename + %results = [] for %t in recursive %tree: if ((%t is "Action" syntax tree) and (%t.stub is %stub)): %line_num = (line number of %t.source.start in %file) %results::add {..} - line: %line_num - text: "\ - ..\(blue "\%filename:\%line_num:") - \(yellow (source lines of %t))" + line: %line_num, text: "\(blue "\%filename:\%line_num:")\n\(yellow (source lines of %t))" 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 - for % in %results: say %.text + for % in %results: + say %.text diff --git a/tools/parse.nom b/tools/parse.nom index 1465bb3..6f88179 100755 --- a/tools/parse.nom +++ b/tools/parse.nom @@ -1,8 +1,8 @@ -#!/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: nomsu tools/parse.nom file1 file2 directory1 ... - + use "lib/os.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -21,14 +21,17 @@ externally (print tree %t at indent %indent) means: "Number": say "\%indent\(%t.1)" + "Var": say "\(%indent)%\(%t.1)" + else: say "\%indent\(%t.type):" for %arg in %t: - if: + when: (%arg is syntax tree): print tree %arg at indent "\%indent " + else: say "\%indent \(quote %arg)" diff --git a/tools/repl.nom b/tools/repl.nom index 00efd77..9d9e88d 100644 --- a/tools/repl.nom +++ b/tools/repl.nom @@ -1,12 +1,13 @@ -#!/usr/bin/env nomsu -V4 +#!/usr/bin/env nomsu -V4.10.12.7 use "lib/consolecolor.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 "\ ..This is the Nomsu v\(Nomsu version) interactive console. You can type in Nomsu code here and hit 'enter' twice to run it. @@ -15,7 +16,7 @@ use "lib/os.nom" say "\ .. \(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 @@ -33,29 +34,28 @@ repeat: go to (run buffer) %buff::add (%line::with "\t" -> " ") %io.write (dim (yellow ".. ")) - === (run buffer) === - if ((size of %buff) == 0): - stop - + if ((size of %buff) == 0): stop %buff = (%buff::joined) - + # TODO: support local variables spoof file %buff try: %ret = (run %buff) - ..and if it barfs %err: - say %err + ..and if it barfs %err: say %err ..or if it succeeds: if (type of %ret) is: "nil": do nothing + "boolean": say "= \("yes" if %ret else "no")" + "table": if %ret.as_nomsu: say "= \(%ret::as nomsu)" ..else: say "= \%ret" + else: say "= \%ret" diff --git a/tools/replace.nom b/tools/replace.nom index a0391d6..ffd96c1 100755 --- a/tools/replace.nom +++ b/tools/replace.nom @@ -1,10 +1,10 @@ -#!/usr/bin/env nomsu -V4.8.10 +#!/usr/bin/env nomsu -V4.10.12.7 # Tool to find and replace one tree with another. nomsu tools/replace.nom [-i] tree_to_replace replacement file1 file2 directory1 ... If "-i" is the first argument, replacements will be performed in-place. Otherwise, the upgraded code will be printed. - + use "lib/os.nom" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -35,9 +35,10 @@ for %path in %args: ..#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version)) \(%tree2 as nomsu)" - if: + when: %inplace: say "Replaced in \%filename" write %text to file %filename - else: say %text + else: + say %text diff --git a/tools/test.nom b/tools/test.nom index 6e74aa6..f9ed2cb 100755 --- a/tools/test.nom +++ b/tools/test.nom @@ -1,8 +1,8 @@ -#!/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: nomsu tools/test.nom file1 file2 directory1 ... - + use "lib/os.nom" use "lib/consolecolor.nom" @@ -17,16 +17,15 @@ if (%args.1 == "-v"): for %path in (command line args): for file %filename in %path: if (%filename::matches "%.nom$"): use %filename - 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 file %filename in %path: unless (%filename::matches "%.nom$"): do next %filename %file_tests = [] for %src = %test in %tests: if (%src.filename == %filename): - %file_tests::add {test:%test, source:%src} + %file_tests::add {test: %test, source: %src} unless (%file_tests is empty): sort %file_tests by % -> %.source @@ -37,6 +36,7 @@ for %path in (command line args): say " \(yellow (%.test::with "\n" -> "\n "))" run %.test - if %verbose: say (green "PASS") + if %verbose: + say (green "PASS") ..else: say "\r[\(green "PASS")" diff --git a/tools/upgrade.nom b/tools/upgrade.nom index 88057eb..469a127 100755 --- a/tools/upgrade.nom +++ b/tools/upgrade.nom @@ -1,10 +1,10 @@ -#!/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: nomsu tools/upgrade.nom [-i] file1 file2 directory1 ... If "-i" is the first argument, upgrades will be performed in-place. Otherwise, the upgraded code will be printed. - + use "compatibility" use "lib/os.nom" @@ -44,9 +44,9 @@ for %path in %args: %code = (%NomsuCode::from (%Source %filename 1 (size of %file)) %file) %tree = (%code parsed) %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) - when: %inplace: say "Upgraded \%filename" @@ -58,4 +58,5 @@ for %path in %args: ..else: say (bright "\%filename will be changed") - else: say %text + else: + say %text