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

Auto-upgraded everything.

Browse Source
This commit is contained in:
Bruce Hill 2018-09-14 19:17:09 -07:00
parent 7112af7cb6
commit e22c35681f
44 changed files with 414 additions and 428 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compatibility/2.3.nom
View File

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

2
compatibility/2.4.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines upgrades from Nomsu <2.4 to Nomsu 2.4

6
compatibility/2.5.5.5.nom
View File

@ -1,12 +1,12 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
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 (..)

2
compatibility/2.5.nom
View File

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

2
compatibility/2.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines upgrades from Nomsu 1 to Nomsu 2

2
compatibility/3.5.5.6.nom
View File

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

2
compatibility/3.6.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines upgrades from Nomsu <3.6 to 3.6

2
compatibility/3.7.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines upgrades from Nomsu <3.7 to 3.7

6
compatibility/3.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines upgrades from Nomsu <=2 to Nomsu 3
@ -9,5 +9,5 @@ upgrade action (me) to "3" as %me
upgrade action (@) to "3" as %me
upgrade action "as 1 2" to "3" via (..)
[] -> (..)
barf ".."
Object API has changed. Use (%obj::action 1 2) instead of (as %obj: action 1 2)
barf "\
..Object API has changed. Use (%obj::action 1 2) instead of (as %obj: action 1 2)"

8
compatibility/compatibility.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains code for defining ways to upgrade code between different versions
of Nomsu.
@ -51,12 +51,12 @@ compile [upgrade action %actions to %version as %body] to:
unless ("\%lua" == ""): %lua::append "\n"
%retval = (make tree %body)
%lua::append (..)
Lua ".."
upgrade_action_1_to_2_via_3(\(quote %action.stub), \(%version as lua expr), function(\(..)
Lua "\
..upgrade_action_1_to_2_via_3(\(quote %action.stub), \(%version as lua expr), function(\(..)
\%tree as lua id
..)
return \%retval
end)
end)"
return %lua

8
core/collections.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains code that supports manipulating and using collections like lists
and dictionaries.
@ -154,8 +154,8 @@ compile [set %dict 's metatable to %metatable] to (..)
test:
assume (({} with fallback % -> (% + 1)).10 == 11)
compile [%dict with fallback %key -> %value] to (..)
Lua value ".."
(function(d)
Lua value "\
..(function(d)
local mt = {}
for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
mt.__index = function(self, \(%key as lua expr))
@ -164,7 +164,7 @@ compile [%dict with fallback %key -> %value] to (..)
return value
end
return setmetatable(d, mt)
end)(\(%dict as lua expr))
end)(\(%dict as lua expr))"
# Sorting
test:

166
core/control_flow.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains compile-time actions that define basic control flow structures
like "if" statements and loops.
@ -17,10 +17,10 @@ test:
if (no):
barf "conditional fail"
compile [if %condition %if_body] to (..)
Lua ".."
if \(%condition as lua expr) then
Lua "\
..if \(%condition as lua expr) then
\(%if_body as lua statements)
end
end"
test:
unless (yes):
@ -29,12 +29,12 @@ parse [unless %condition %unless_body] as (if (not %condition) %unless_body)
compile [..]
if %condition %if_body else %else_body, unless %condition %else_body else %if_body
..to (..)
Lua ".."
if \(%condition as lua expr) then
Lua "\
..if \(%condition as lua expr) then
\(%if_body as lua statements)
else
\(%else_body as lua statements)
end
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -54,23 +54,23 @@ compile [..]
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 value ".."
(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
Lua value "\
..(\(%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!)
To see why this is necessary consider: (random()<.5 and false or 99)
return (..)
Lua value ".."
((function()
Lua value "\
..((function()
if \(%condition as lua expr) then
return \(%when_true_expr as lua expr)
else
return \(%when_false_expr as lua expr)
end
end)())
end)())"
# GOTOs
test:
@ -112,9 +112,9 @@ compile [do next repeat] to (Lua "goto continue_repeat")
compile [stop repeating] to (Lua "goto stop_repeat")
compile [repeat while %condition %body] to:
%lua = (..)
Lua ".."
while \(%condition as lua expr) do
\(%body as lua statements)
Lua "\
..while \(%condition as lua expr) do
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
@ -123,11 +123,11 @@ compile [repeat while %condition %body] to:
%lua::append "\nend --while-loop"
if (%body has subtree \(stop repeating)):
%lua = (..)
Lua ".."
do -- scope of "stop repeating" label
Lua "\
..do -- scope of "stop repeating" label
\%lua
::stop_repeat::
end -- end of "stop repeating" label scope
end -- end of "stop repeating" label scope"
return %lua
@ -141,9 +141,9 @@ test:
compile [repeat %n times %body] to:
define mangler
%lua = (..)
Lua ".."
for \(mangle "i")=1,\(%n as lua expr) do
\(%body as lua statements)
Lua "\
..for \(mangle "i")=1,\(%n as lua expr) do
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
@ -152,11 +152,11 @@ compile [repeat %n times %body] to:
%lua::append "\nend --numeric for-loop"
if (%body has subtree \(stop repeating)):
%lua = (..)
Lua ".."
do -- scope of "stop repeating" label
Lua "\
..do -- scope of "stop repeating" label
\%lua
::stop_repeat::
end -- end of "stop repeating" label scope
end -- end of "stop repeating" label scope"
return %lua
@ -199,11 +199,11 @@ compile [..]
unless (%var.type is "Var"):
compile error at %var.source "Loop expected variable, not: %s"
%lua = (..)
Lua ".."
for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
Lua "\
..for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(..)
%step as lua expr
.. do
\(%body as lua statements)
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
@ -212,11 +212,11 @@ compile [..]
%lua::append "\nend --numeric for-loop"
if (%body has subtree \(stop %var)):
%lua = (..)
Lua ".."
do -- scope for stopping for-loop
Lua "\
..do -- scope for stopping for-loop
\%lua
\(compile as (===stop %var ===))
end -- end of scope for stopping for-loop
end -- end of scope for stopping for-loop"
return %lua
@ -245,9 +245,9 @@ compile [for %var in %iterable %body] to:
compile error at %var.source "Loop expected variable, not: %s"
define mangler
%lua = (..)
Lua ".."
for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
\(%body as lua statements)
Lua "\
..for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
@ -256,11 +256,11 @@ compile [for %var in %iterable %body] to:
%lua::append "\nend --foreach-loop"
if (%body has subtree \(stop %var)):
%lua = (..)
Lua ".."
do -- scope for stopping for-loop
Lua "\
..do -- scope for stopping for-loop
\%lua
\(compile as (===stop %var ===))
end -- end of scope for stopping for-loop
end -- end of scope for stopping for-loop"
return %lua
@ -284,11 +284,11 @@ compile [..]
unless (%value.type is "Var"):
compile error at %value.source "Loop expected variable, not: %s"
%lua = (..)
Lua ".."
for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
Lua "\
..for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(..)
%iterable as lua expr
..) do
\(%body as lua statements)
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"
@ -304,10 +304,10 @@ compile [..]
%stop_labels::append "\n\(compile as (===stop %value ===))"
if ((size of "\%stop_labels") > 0):
%lua = (..)
Lua ".."
do -- scope for stopping for % = % loop
Lua "\
..do -- scope for stopping for % = % loop
\%lua\%stop_labels
end
end"
return %lua
@ -337,39 +337,39 @@ compile [if %body, when %body] to:
((%line.type is "Action") and ((size of %line) >= 2)) and (..)
%line.(size of %line) is "Block" syntax tree
..:
compile error at %line.source ".."
Invalid line for 'if', each line should contain conditional expressions followed by a block, or "else" followed by a block:
%s
compile error at %line.source "\
..Invalid line for 'if', each line should contain conditional expressions followed by a block, or "else" followed by a block:
%s"
%action = %line.(size of %line)
if ((%line.1 is "else") and ((size of %line) == 2)):
unless %else_allowed:
compile error at %line.source "Can't have two 'else' blocks"
unless ((size of "\%code") > 0):
compile error at %line.source ".."
Can't have an 'else' block without a preceeding condition
compile error at %line.source "\
..Can't have an 'else' block without a preceeding condition"
%code::append ".."
%code::append "\
..
else
\(%action as lua statements)
\(%action as lua statements)"
%else_allowed = (no)
..else:
%code::append "\%clause "
for %i in 1 to ((size of %line) - 1):
unless (%line.%i is syntax tree):
compile error at %line.source ".."
Invalid condition for 'if' statement:
%s
compile error at %line.source "\
..Invalid condition for 'if' statement:
%s"
if (%i > 1):
%code::append " or "
%code::append (%line.%i as lua expr)
%code::append ".."
then
\(%action as lua statements)
%code::append "\
.. then
\(%action as lua statements)"
%clause = "\nelseif"
@ -401,39 +401,39 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
((%line.type is "Action") and ((size of %line) >= 2)) and (..)
%line.(size of %line) is "Block" syntax tree
..:
compile error at %line.source ".."
Invalid line for 'if % is % %', each line should contain expressions followed by a block, or "else" followed by a block:
%s
compile error at %line.source "\
..Invalid line for 'if % is % %', each line should contain expressions followed by a block, or "else" followed by a block:
%s"
%action = %line.(size of %line)
if ((%line.1 is "else") and ((size of %line) == 2)):
unless %else_allowed:
compile error at %line.source "Can't have two 'else' blocks"
unless ((size of "\%code") > 0):
compile error at %line.source ".."
Can't have an 'else' block without a preceeding condition
compile error at %line.source "\
..Can't have an 'else' block without a preceeding condition"
%code::append ".."
%code::append "\
..
else
\(%action as lua statements)
\(%action as lua statements)"
%else_allowed = (no)
..else:
%code::append "\%clause "
for %i in 1 to ((size of %line) - 1):
unless (%line.%i is syntax tree):
compile error at %line.source ".."
Invalid condition for 'if' statement:
%s
compile error at %line.source "\
..Invalid condition for 'if' statement:
%s"
if (%i > 1):
%code::append " or "
%code::append "\(mangle "branch value") == \(%line.%i as lua expr)"
%code::append ".."
then
\(%action as lua statements)
%code::append "\
.. then
\(%action as lua statements)"
%clause = "\nelseif"
@ -441,18 +441,18 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
compile error at %body.source "'if % is % %' block has an empty body"
%code::append "\nend --when"
return (..)
Lua ".."
do --if % is
Lua "\
..do --if % is
local \(mangle "branch value") = \(%branch_value as lua expr)
\%code
end --if % is
end --if % is"
# Do/finally
compile [do %action] to (..)
Lua ".."
do
Lua "\
..do
\(%action as lua statements)
end --do
end --do"
test:
%d = {}
@ -467,8 +467,8 @@ test:
compile [do %action then always %final_action] to:
define mangler
return (..)
Lua ".."
do
Lua "\
..do
local \(mangle "fell_through") = false
local \(mangle "ok"), \(mangle "ret") = pcall(function()
\(%action as lua statements)
@ -477,7 +477,7 @@ compile [do %action then always %final_action] to:
\(%final_action as lua statements)
if not \(mangle "ok") then error(ret, 0) end
if not \(mangle "fell_through") then return ret end
end
end"
test:
assume ((result of (: return 99)) == 99)
@ -502,12 +502,12 @@ compile [for %var in recursive %structure %body] to (..)
compile [recurse %v on %x] to (..)
Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))"
%lua = (..)
Lua ".."
do
Lua "\
..do
local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)}
while #\(mangle "stack \(%var.1)") > 0 do
\(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
\(%body as lua statements)
\(%body as lua statements)"
if (%body has subtree \(do next)):
%lua::append "\n ::continue::"

14
core/coroutines.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines the code that creates and manipulates coroutines
@ -15,15 +15,15 @@ test:
for % in coroutine %co: %nums::add %
assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
compile [coroutine %body, generator %body] to (..)
Lua value ".."
(function()
Lua value "\
..(function()
\(%body as lua statements)
end)
end)"
compile [->] to (Lua value "coroutine.yield(true)")
compile [-> %] to (Lua value "coroutine.yield(true, \(% as lua expr))")
compile [for % in coroutine %co %body] to (..)
Lua ".."
for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
Lua "\
..for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
\(%body as lua statements)
end
end"

34
core/errors.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains basic error reporting code
@ -10,34 +10,34 @@ compile [compile error at %source %msg] to (..)
Lua "nomsu:compile_error(\(%source as lua expr), \(%msg as lua expr))"
compile [assume %condition] to:
lua> ".."
local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))
lua> "\
..local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition))"
return (..)
Lua ".."
if not \(%condition as lua expr) then
Lua "\
..if not \(%condition as lua expr) then
error(\(quote "\%assumption"), 0)
end
end"
compile [assume %a == %b] to:
lua> ".."
local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\(\(%a == %b))))
lua> "\
..local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\(\(%a == %b))))"
define mangler
return (..)
Lua ".."
do
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)
end
end
end"
compile [assume %condition or barf %message] to (..)
Lua ".."
if not \(%condition as lua expr) then
Lua "\
..if not \(%condition as lua expr) then
error(\(%message as lua expr), 0)
end
end"
test:
try (barf) and if it succeeds: barf "try failed."
@ -57,8 +57,8 @@ compile [..]
try %action and if it succeeds %success or if it barfs %msg %fallback
try %action and if it barfs %msg %fallback or if it succeeds %success
..to (..)
Lua ".."
do
Lua "\
..do
local fell_through = false
local err, erred = nil, false
local ok, ret = xpcall(function()
@ -78,7 +78,7 @@ compile [..]
elseif erred then
error(err, 0)
end
end
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

5
core/id.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
@ -13,8 +13,7 @@ use "core/control_flow.nom"
set %obj_by_id's metatable to {__mode:"v"}
%id_by_obj = {}
set %id_by_obj 's metatable to {..}
__mode:"k"
__index: (..)
__mode:"k", __index: (..)
[%self, %key] ->:
if (%key == (nil)):
return %self.%nil_surrogate

14
core/io.nom
View File

@ -1,23 +1,23 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains basic input/output code
use "core/metaprogramming.nom"
compile [say %message] to (..)
lua> ".."
if \%message.type == "Text" then
lua> "\
..if \%message.type == "Text" then
return LuaCode(tree.source, "print(", \(%message as lua expr), ");");
else
return LuaCode(tree.source, "print(tostring(", \(%message as lua expr), "));");
end
end"
compile [ask %prompt] to (..)
lua> ".."
if \%prompt.type == "Text" then
lua> "\
..if \%prompt.type == "Text" then
return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
else
return LuaCode.Value(tree.source, "(io.write(tostring(", \(..)
%prompt as lua expr
.., ")) and io.read())");
end
end"

12
core/math.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines some common math literals and functions
@ -10,8 +10,8 @@ use "core/collections.nom"
# Literals:
test:
assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf ".."
math constants failed
assume (all of [inf, NaN, pi, tau, golden ratio, e]) or barf "\
..math constants failed"
%nan = (NaN)
assume (%nan != %nan) or barf "NaN failed"
compile [infinity, inf] to (Lua value "math.huge")
@ -127,9 +127,9 @@ parse [max of %items by %item = %value_expr] as (..)
# Random functions
action [seed random with %] (..)
lua> ".."
math.randomseed(\%);
for i=1,20 do math.random(); end
lua> "\
..math.randomseed(\%);
for i=1,20 do math.random(); end"
parse [seed random] as (seed random with (=lua "os.time()"))
compile [random number, random, rand] to (Lua value "math.random()")

138
core/metaprogramming.nom
View File

@ -1,11 +1,11 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This File contains actions for making actions and compile-time actions and some helper
functions to make that easier.
lua> "NOMSU_CORE_VERSION = 8"
lua> ".."
do
lua> "\
..do
local mangle_index = 0
function mangler()
local my_mangle_index = mangle_index
@ -17,10 +17,10 @@ lua> ".."
end
COMPILE_ACTIONS["define mangler"] = function(nomsu, tree)
return LuaCode(tree.source, "local mangle_1 = mangler()")
end
end"
lua> ".."
COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
lua> "\
..COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
local lua = LuaCode.Value(tree.source, "(function(")
if AST.is_syntax_tree(\%args, "Action") then \%args = \%args:get_args() end
local lua_args = table.map(\%args, function(a) return AST.is_syntax_tree(a) and tostring(nomsu:compile(a)) or a end)
@ -30,10 +30,10 @@ lua> ".."
body_lua:declare_locals()
lua:append(")\\n ", body_lua, "\\nend)")
return lua
end
end"
lua> ".."
COMPILE_ACTIONS["compile as 1"] = function(nomsu, tree, \%action)
lua> "\
..COMPILE_ACTIONS["compile as 1"] = function(nomsu, tree, \%action)
local lua = LuaCode.Value(tree.source, "COMPILE_ACTIONS[", repr(\%action.stub), "](")
local lua_args = table.map(\%action:get_args(), function(a) return nomsu:compile(a) end)
table.insert(lua_args, 1, "nomsu")
@ -41,7 +41,7 @@ lua> ".."
lua:concat_append(lua_args, ", ")
lua:append(")")
return lua
end
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -62,8 +62,8 @@ test:
test:
asdf
assume (%tmp is (nil)) or barf "compile to is leaking variables"
lua> ".."
COMPILE_ACTIONS["compile 1 to 2"] = function(nomsu, tree, \%actions, \%body)
lua> "\
..COMPILE_ACTIONS["compile 1 to 2"] = function(nomsu, tree, \%actions, \%body)
local \%args = {"nomsu", "tree", unpack(table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(\
..a)) end))}
local lua = LuaCode(tree.source, "COMPILE_ACTIONS[", repr(\%actions[1].stub),
@ -84,16 +84,16 @@ lua> ".."
end
end
return lua
end
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [call %fn with %args] to:
lua> ".."
local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(")
lua> "\
..local lua = LuaCode.Value(tree.source, nomsu:compile(\%fn), "(")
lua:concat_append(table.map(\%args, function(a) return nomsu:compile(a) end), ", ")
lua:append(")")
return lua
return lua"
test:
local action [foo %x]: return "outer"
@ -108,8 +108,8 @@ test:
assume ((foo 1) == "outer")
compile [local action %actions %body] to:
lua> ".."
local fn_name = \%actions[1].stub:as_lua_id()
lua> "\
..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end)
local lua = LuaCode(tree.source, fn_name, " = ", \(compile as (%args -> %body)))
lua:add_free_vars({fn_name})
@ -129,7 +129,7 @@ compile [local action %actions %body] to:
lua:append(")\\nend")
end
end
return lua
return lua"
test:
action [baz1]: return "baz1"
@ -138,10 +138,10 @@ test:
assume ((baz1) == "baz1")
assume ((baz2) == "baz2")
compile [action %actions %body] to (..)
lua> ".."
local lua = \(compile as (local action %actions %body))
lua> "\
..local lua = \(compile as (local action %actions %body))
lua:remove_free_vars(table.map(\%actions, function(a) return a.stub:as_lua_id() end))
return lua
return lua"
test:
assume ((action (say %)) == (=lua "say_1"))
@ -156,15 +156,15 @@ test:
test:
set {%1:1, %2:2}
swap %1 and %2
assume ((%1 == 2) and (%2 == 1)) or barf ".."
'parse % as %' failed on 'swap % and %'
assume ((%1 == 2) and (%2 == 1)) or barf "\
..'parse % as %' failed on 'swap % and %'"
set {%tmp:1, %tmp2:2}
swap %tmp and %tmp2
assume ((%tmp == 2) and (%tmp2 == 1)) or barf ".."
'parse % as %' variable mangling failed.
assume ((%tmp == 2) and (%tmp2 == 1)) or barf "\
..'parse % as %' variable mangling failed."
compile [parse %actions as %body] to (..)
lua> ".."
local replacements = {}
lua> "\
..local replacements = {}
for i,arg in ipairs(\%actions[1]:get_args()) do
replacements[arg[1]] = tostring(nomsu:compile(arg))
end
@ -201,18 +201,18 @@ compile [parse %actions as %body] to (..)
"\\nlocal lua = nomsu:compile(tree)",
"\\nreturn lua")
local ret = \(compile as (compile %actions to %new_body))
return ret
return ret"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
action [%tree as lua expr]:
lua> ".."
\%tree_lua = nomsu:compile(\%tree)
lua> "\
..\%tree_lua = nomsu:compile(\%tree)
if not \%tree_lua.is_value then
nomsu:compile_error(\%tree.source, "Could not convert %s to a Lua expression",
nomsu:tree_to_nomsu(\%tree))
end
return \%tree_lua
return \%tree_lua"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -227,8 +227,8 @@ compile [remove action %action] to (..)
Lua "\(=lua "(\(%action.stub)):as_lua_id()") = nil"
test:
assume ("\(\(foo \%x) as nomsu)" == "foo %x") or barf ".."
action source code failed.
assume ("\(\(foo \%x) as nomsu)" == "foo %x") or barf "\
..action source code failed."
compile [%tree as nomsu] to (..)
Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr))"
@ -236,12 +236,12 @@ compile [%tree as inline nomsu] to (..)
Lua value "nomsu:tree_to_nomsu(\(%tree as lua expr), true)"
action [%var as lua identifier, %var as lua id] (..)
lua> ".."
if type(\%var) == 'string' then return \%var:as_lua_id()
lua> "\
..if type(\%var) == 'string' then return \%var:as_lua_id()
elseif AST.is_syntax_tree(\%var, 'Var') then return \%var[1]:as_lua_id()
elseif AST.is_syntax_tree(\%var, 'Action') then return \%var.stub:as_lua_id()
else error("Unknown type: "..tostring(\%var))
end
end"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -250,39 +250,39 @@ compile [% is %kind syntax tree] to (..)
Lua value "AST.is_syntax_tree(\(% as lua expr), \(%kind as lua expr))"
compile [%tree with %t -> %replacement] to (..)
Lua value ".."
\(%tree as lua expr):map(function(\(%t as lua expr))
Lua value "\
..\(%tree as lua expr):map(function(\(%t as lua expr))
\(%replacement as lua return)
end)
end)"
action [%tree with vars %replacements] (..)
=lua ".."
\%tree:map(function(\%t)
=lua "\
..\%tree:map(function(\%t)
if \%t.type == "Var" then
return \%replacements[\%t[1]]
end
end)
end)"
compile [tree %tree with vars %replacements] to (..)
Lua value ".."
\(=lua "repr(\%tree)"):map(function(t)
Lua value "\
..\(=lua "repr(\%tree)"):map(function(t)
if t.type == "Var" then
return \(%replacements as lua expr)[t[1]]
end
end)
end)"
compile [%tree has subtree %match_tree] to (..)
Lua value ".."
(function()
Lua value "\
..(function()
local match_tree = \(%match_tree as lua expr)
for subtree in coroutine.wrap(function() \(%tree as lua expr):map(coroutine.yield) end) do
if subtree == match_tree then return true end
end
end)()
end)()"
action [match %tree with %patt]:
lua> ".."
if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
lua> "\
..if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
if \%patt.type == "Action" and \%patt.stub ~= \%tree.stub then return nil end
if #\%patt ~= #\%tree then return nil end
local matches = _Dict{}
@ -296,11 +296,11 @@ action [match %tree with %patt]:
end
end
end
return matches
return matches"
action [%tree with %patt ~> %replacement]:
lua> ".."
return \%tree:map(function(\%t)
lua> "\
..return \%tree:map(function(\%t)
local \%vars = \(match %t with %patt)
if not \%vars then return nil end
for \%k,\%v in pairs(\%vars) do
@ -311,14 +311,14 @@ action [%tree with %patt ~> %replacement]:
return \%vars[\%t[1]]
end
end)
end)
end)"
test:
assume (..)
(..)
quote ".."
one
"two"
quote "\
..one
"two""
..== "\"one\\n\\\"two\\\"\""
compile [quote %s] to (Lua value "repr(\(%s as lua expr))")
@ -335,10 +335,10 @@ test:
assume ((parse "\\1") == \(\(1)))
compile [parse %text] to (Lua value "nomsu:parse(\(%text as lua expr))")
compile [parse %text from %filename] to (..)
Lua value ".."
nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..)
Lua value "\
..nomsu:parse(NomsuCode(Source(\(%filename as lua expr), 1, #\(%text as lua expr)), \(..)
%text as lua expr
..))
..))"
test:
assume ((run "return (2 + 99)") == 101)
@ -347,10 +347,10 @@ test:
\(external \%passed = \(yes))
assume %passed
compile [run %nomsu_code] to (..)
Lua value ".."
nomsu:run(\(%nomsu_code as lua expr), \(..)
Lua value "\
..nomsu:run(\(%nomsu_code as lua expr), \(..)
=lua "repr(tostring(\(%nomsu_code.source)))"
..)
..)"
test:
assume ((\(\(5) + \(5)) as value) == 10) or barf "%tree as value failed."
@ -377,13 +377,13 @@ compile [command line args] to (Lua value "arg")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compile [with local compile actions %body] to (..)
Lua ".."
do
Lua "\
..do
local nomsu = table.fork(nomsu, {COMPILE_ACTIONS=table.fork(COMPILE_ACTIONS)})
\(%body as lua statements)
end
end"
action [Nomsu version]:
use "lib/version.nom"
return ".."
\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)
return "\
..\(Nomsu syntax version).\(core version).\(Nomsu compiler version).\(lib version)"

68
core/operators.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains definitions of operators like "+" and "and".
@ -29,21 +29,21 @@ test:
compile [%var = %value] to:
lua> "local \%var_lua = \(%var as lua)"
assume %var_lua.is_value or barf "Invalid target for assignment: \%var"
lua> ".."
\%value = \%value:map(function(t)
lua> "\
..\%value = \%value:map(function(t)
if Action:is_instance(t) and t.stub == "?" then
return \%var
end
end)
local \%value_lua = \(%value as lua)
local \%value_lua = \(%value as lua)"
assume %value_lua.is_value or barf "Invalid value for assignment: \%value"
lua> ".."
local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
lua> "\
..local lua = LuaCode(tree.source, \%var_lua, ' = ', \%value_lua, ';')
if \%var.type == 'Var' then
lua:add_free_vars({tostring(nomsu:compile(\%var))})
end
return lua
return lua"
test:
set {%x:10, %y:20}
@ -53,10 +53,10 @@ test:
# Simultaneous mutli-assignments like: x,y,z = 1,x,3;
compile [set %assignments] to:
assume (%assignments.type is "Dict") or barf ".."
Expected a Dict for the assignments part of '<- %' statement, not \%assignments
lua> ".."
local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
assume (%assignments.type is "Dict") or barf "\
..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
lua> "\
..local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
for i, item in ipairs(\%assignments) do
local \%target, \%value = item[1], item[2]
\%value = \%value:map(function(t)
@ -82,7 +82,7 @@ compile [set %assignments] to:
lhs:append(target_lua)
rhs:append(value_lua)
end
return LuaCode(tree.source, lhs, " = ", rhs, ";")
return LuaCode(tree.source, lhs, " = ", rhs, ";")"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -109,12 +109,12 @@ test:
%y = "inner"
set global x local y
assume ((%foozle == "inner") and (%y == "outer")) or barf ".."
'with external' failed.
assume ((%foozle == "inner") and (%y == "outer")) or barf "\
..'with external' failed."
compile [with external %externs %body] to:
%body_lua = (%body as lua statements)
lua> ".."
\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))
lua> "\
..\%body_lua:remove_free_vars(table.map(\%externs, function(v) return tostring(nomsu:compile(v)) end))"
return %body_lua
test:
@ -128,8 +128,8 @@ test:
assume (%z == (nil)) or barf "'with' scoping failed"
compile [with %assignments %body] to:
%lua = (%body as lua statements)
lua> ".."
local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
lua> "\
..local lhs, rhs = LuaCode(tree.source), LuaCode(tree.source)
local vars = {}
for i, item in ipairs(\%assignments) do
local \%target, \%value = item[1], item[2]
@ -152,13 +152,13 @@ compile [with %assignments %body] to:
end
end
\%lua:remove_free_vars(vars)
\%lua:prepend("local ", lhs, " = ", rhs, ";\\n")
\%lua:prepend("local ", lhs, " = ", rhs, ";\\n")"
return (..)
Lua ".."
do
Lua "\
..do
\%lua
end -- 'with' block
end -- 'with' block"
# Math Operators
test:
@ -175,8 +175,8 @@ test:
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
assume (%calls == 1) or barf "\
..Three-way comparison evaluated middle value multiple times"
parse [%x < %y < %z] as (..)
call ([%a, %b, %c] -> ((%a < %b) and (%b < %c))) with [%x, %y, %z]
@ -232,28 +232,28 @@ compile [NOT %, ~ %] to (..)
compile [%a OR %b, %a | %b] to (..)
Lua value (..)
(%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or ".."
(\(%a as lua expr) | \(%b as lua expr))
(%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or "\
..(\(%a as lua expr) | \(%b as lua expr))"
compile [%a XOR %b, %a ~ %b] to (..)
Lua value (..)
(%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or ".."
(\(%a as lua expr) ~ \(%b as lua expr))
(%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or "\
..(\(%a as lua expr) ~ \(%b as lua expr))"
compile [%a AND %b, %a & %b] to (..)
Lua value (..)
(%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or ".."
(\(%a as lua expr) & \(%b as lua expr))
(%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or "\
..(\(%a as lua expr) & \(%b as lua expr))"
compile [%x LSHIFT %shift, %x << %shift] to (..)
Lua value (..)
(%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or ".."
(\(%x as lua expr) << \(%shift as lua expr))
(%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or "\
..(\(%x as lua expr) << \(%shift as lua expr))"
compile [%x RSHIFT %shift, %x >> %shift] to (..)
Lua value (..)
(%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or ".."
(\(%x as lua expr) >> \(%shift as lua expr))
(%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or "\
..(\(%x as lua expr) >> \(%shift as lua expr))"
# Unary operators
test:

14
core/scopes.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains definitions pertaining to variable scoping
@ -25,9 +25,9 @@ compile [with local %locals %body, with local %locals do %body] to:
if %locals.type is:
"Dict":
%body_lua = (..)
Lua ".."
\(compile as (<- %locals))
\%body_lua
Lua "\
..\(compile as (<- %locals))
\%body_lua"
%body_lua::declare locals ("\(%.1 as lua)" for % in %locals)
@ -39,7 +39,7 @@ compile [with local %locals %body, with local %locals do %body] to:
compile error at %locals.source "Unexpected locals: %s"
return (..)
Lua ".."
do
Lua "\
..do
\%body_lua
end
end"

31
core/text.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains some definitions of text escape sequences, including ANSI console
color codes.
@ -8,16 +8,12 @@ use "core/metaprogramming.nom"
test:
assume "\[1, 2, 3]" == "[1, 2, 3]"
assume "foo = \(1 + 2)!" == "foo = 3!"
assume (..)
".."
one
two
..== "one\ntwo"
assume (..)
".."
no\
..gap
..== "nogap"
assume "one\ntwo" == "\
..one
two"
assume "nogap" == "\
..no\
..gap"
assume (["x", "y"]::joined with ",") == "x,y"
assume (["x", "y"]::joined) == "xy"
assume ("BAR"::byte 2) == 65
@ -31,10 +27,9 @@ test:
%こんにちは = "こんにちは"
アクション [% と言う] "\(%)世界"
assume (%こんにちは と言う) == "こんにちは世界"
compile [%expr for %match in %text matching %patt] to (..)
Lua value ".."
(function()
Lua value "\
..(function()
local ret = _List{}
for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
%patt as lua expr
@ -42,14 +37,14 @@ compile [%expr for %match in %text matching %patt] to (..)
ret[#ret+1] = \(%expr as lua statements)
end
return ret
end)()
end)()"
test:
assume "\n" == (newline)
# Text literals
lua> ".."
do
lua> "\
..do
local escapes = {
nl="\\\\n", newline="\\\\n", tab="\\\\t", bell="\\\\a", cr="\\\\r",
["carriage return"]="\\\\r", backspace="\\\\b", ["form feed"]="\\\\f",
@ -61,4 +56,4 @@ lua> ".."
return LuaCode.Value(tree.source, lua)
end
end
end
end"

29
examples/how_do_i.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
# How do I...
# Write a comment? Put a # and go till the end of the line
# How do I write a multi-line comment?
@ -32,18 +32,19 @@ say %one_two
# How do I define a mutli-line string?
# In Nomsu, "strings" are called "text", and multi-line text looks like:
%mutli_text = ".."
Start with "..", then put indented lines below it. The indented lines will not include
the indentation, except when the lines are indented more than 4 spaces relative
to the "..".
%mutli_text = "\
..Start with a quote mark and a backslash and an indented "..", then put indented
lines below it. The indented lines will not include the indentation, except when
the lines are indented more than 4 spaces relative to the original quote mark.
<- E.g. the 2 spaces here will be included as part of the text.
But this line will have no leading spaces.
The text will continue until the indentation ends, skipping trailing newlines.
The text will continue until a closing quotation at the end of the text's
indentation level."
# How do I put values inside text? (AKA string formatting, string interpolation)
say ".."
Text can contain a backslash followed by a variable, list, dict, or parenthesized
say "\
..Text can contain a backslash followed by a variable, list, dict, or parenthesized
expression. This escaped value will be converted to readable text, like so:
The value of %foobar is \%foobar, isn't that nice?
These are some numbers: \[1 + 1, 2 + 1, 3 + 1]
@ -60,7 +61,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.
.. between a backslash and two periods."
say "Single-line text can contain escape sequences like \", \\, \000, and \n"
@ -236,8 +237,8 @@ say (2 + 3)
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
say both "Very long first argument that needs its own line" and also "\
..short second arg"
action [my favorite number] (21 + 2)
@ -259,10 +260,10 @@ parse [if %condition is untrue %body] as (if (not %condition) %body)
# Or to transform nomsu code into custom lua code using "compile % to %"
compile [if %condition on opposite day %body] to (..)
Lua ".."
if not \(%condition as lua expr) then
Lua "\
..if not \(%condition as lua expr) then
\(%body as lua statements)
end
end"
# Constants can be defined as macros
parse [TWENTY] as 20

11
lib/base64.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines actions for encoding/decoding base 64, as specified in:
https://tools.ietf.org/html/rfc4648
@ -11,13 +11,8 @@ test:
%cases = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"]
for %len = %encoded in %cases:
%plain = "foobar".[1, %len - 1]
assume ((base64 %plain) == %encoded) or barf ".."
\(quote %plain) base64 encoded to \(quote (base64 %plain)) \
..instead of \(quote %encoded)
assume ((base64 decode %encoded) == %plain) or barf ".."
\(quote %encoded) base64 decoded to \(quote (base64 decode %encoded)) \
..instead of \(quote %plain)
assume (base64 %plain) == %encoded
assume (base64 decode %encoded) == %plain
action [base64 %str, base64 encode %str, %str base64]:
%chars = []
for %i in 1 to (size of %str) via 3:

10
lib/consolecolor.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines actions for ANSI console color escape codes.
@ -14,9 +14,9 @@ test:
for %name = %colornum in %colors:
with {%escapecode:"\027[\(%colornum)m"}:
run ".."
compile [\%name] to (..)
run "\
..compile [\%name] to (..)
Lua value (quote \(quote %escapecode))
compile [\%name %text] to (..)
Lua value ".."
(\\(quote \(quote %escapecode))..\\(%text as lua expr).."\\27[0m")
Lua value "\\
..(\\(quote \(quote %escapecode))..\\(%text as lua expr).."\\27[0m")""

24
lib/file_hash.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines some actions for hashing files and looking up files by hash.
@ -8,21 +8,21 @@ 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 ".."
Hash collision:
assume (hash "hello world") == (hash "hello world")
assume ((hash "hello world") != (hash "goodbye")) or barf "\
..Hash collision:
(hash "hello world") = \(hash "hello world")
(hash "goodbye") = \(hash "goodbye")
(hash "goodbye") = \(hash "goodbye")"
assume (..)
(..)
hash ".."
This is a really long string meant to stress test the hashing function and
ensure that it's not overflowing with long inputs.
hash "\
..This is a really long string meant to stress test the hashing function and
ensure that it's not overflowing with long inputs."
..!= "inf"
assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf ".."
Incorrect hashing of null strings
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:
@ -31,8 +31,8 @@ if %use_sha1:
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"
action [hash %]:
%bytes = (%::bytes)
%hash = (%bytes.1 << 7)

14
lib/object.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains the implementation of an Object-Oriented programming system.
@ -43,8 +43,8 @@ test:
with {%d:new Dog {barks:2}}:
assume ((%d::bark) == "Bark! Bark!")
compile [my action %actions %body] to:
lua> ".."
local fn_name = \%actions[1].stub:as_lua_id()
lua> "\
..local fn_name = \%actions[1].stub:as_lua_id()
local \%args = table.map(\%actions[1]:get_args(), function(a) return tostring(nomsu:compile(a)) end)
table.insert(\%args, \(\%me as lua id))
local lua = LuaCode(tree.source, "class.", fn_name, " = ", \(..)
@ -66,12 +66,12 @@ compile [my action %actions %body] to:
lua:append(")\\nend")
end
end
return lua
return lua"
compile [object %classname extends %parent %class_body] to:
return (..)
Lua ".."
do
Lua "\
..do
local class = {name=\(%classname as lua expr)}
setmetatable(class, {
__index=\(%parent as lua expr),
@ -106,7 +106,7 @@ compile [object %classname extends %parent %class_body] to:
for stub,metamethod in pairs(metamethod_map) do
class[metamethod] = class[stub:as_lua_id()]
end
end
end"
parse [object %classname %class_body] as (..)
object %classname extends (nil) %class_body

30
lib/os.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file defines some actions that interact with the operating system and filesystem.
@ -9,11 +9,11 @@ action [path of Nomsu file %filename]:
barf "Could not find file: \%filename"
action [sh> %cmd]:
lua> ".."
local result = io.popen(\%cmd)
lua> "\
..local result = io.popen(\%cmd)
local contents = result:read("*a")
result:close()
return contents
return contents"
test:
read file "lib/os.nom"
@ -22,39 +22,39 @@ action [read file %filename] (=lua "Files.read(\%filename)")
test:
for file %f in "core": do nothing
compile [for file %f in %path %body] to (..)
Lua ".."
for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
Lua "\
..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
\(%body as lua statements)
\(compile as (===next %f ===))
end
\(compile as (===stop %f ===))
\(compile as (===stop %f ===))"
compile [%expr for file %f in %path] to (..)
Lua value ".."
(function()
Lua value "\
..(function()
local ret = _List{}
for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
ret[#ret+1] = \(%expr as lua statements)
end
return ret
end)()
end)()"
action [..]
write to file %filename %text, to file %filename write %text
write %text to file %filename
..:
assume (%filename != "stdin") or barf "Cannot write to stdin"
lua> ".."
local file = io.open(\%filename, 'w')
lua> "\
..local file = io.open(\%filename, 'w')
file:write(\%text)
file:close()
file:close()"
test:
assume ((line number of 3 in "x\ny") == 2)
assume (line number of 3 in "x\ny") == 2
action [line number of %pos in %str] (=lua "Files.get_line_number(\%str, \%pos)")
test:
assume ((line 2 in "one\ntwo\nthree") == "two")
assume (line 2 in "one\ntwo\nthree") == "two"
action [line %line_num in %str] (=lua "Files.get_line(\%str, \%line_num)")
test:

2
lib/training_wheels.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
This file contains a set of definitions that bring some familiar language features
from other languages into nomsu (e.g. "||" and "continue")

2
lib/version.nom
View File

@ -1,3 +1,3 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
# This file sets the current library version.
lua> "NOMSU_LIB_VERSION = 6"

41
nomsu.4.peg
View File

@ -63,6 +63,9 @@ disallowed_interpolation (Error):
{:error: {~ ("\" ('\:' / '(..)' / '[..]' / '{..}') (%nl (&(%nl) / =curr_indent ' ' [^%nl]*))*) ->
"Sorry, indented text interpolations are not currently supported on the first line of multi-line text." ~} :}
{:hint: {~ '' -> 'Move the code for the first line of text to the next line by ending this line with "\" and starting the next line indented with "..", followed by the code for the first line.' ~} :}
expected_dotdot (Error):
{:error: {~ '' -> 'Expected to see a ".." here' ~} :}
{:hint: {~ '' -> 'Add a ".." here.' ~} :}
section_division: ("~")^+3 eol
@ -89,7 +92,7 @@ noindex_inline_expression:
)
inline_expression: index_chain / noindex_inline_expression
indented_expression:
cool_indented_text / indented_text / indented_nomsu / indented_list / indented_dict / ({|
indented_text / indented_nomsu / indented_list / indented_dict / ({|
"(..)" nl_indent
(action / expression) (eol / unexpected_code)
(%nl (ws* %nl)* nodent (comment / eol / unexpected_code))*
@ -125,45 +128,39 @@ word: !number { operator_char+ / ident_char+ }
text_word (Text): word
inline_text (Text):
!(cool_indented_text / indented_text)
('"' _inline_text* ('"' / missing_quote_err / unexpected_code))
!(indented_text)
'"' _inline_text* ('"' / missing_quote_err / unexpected_code)
_inline_text:
{~ (('\"' -> '"') / ('\\' -> '\') / escaped_char / [^%nl\"]+)+ ~}
/ inline_text_interpolation
inline_text_interpolation:
"\" (
variable / inline_list / inline_dict / inline_text
variable / inline_list / inline_dict
/ ("("
ws* (inline_action / inline_expression) ws*
(ws* ',' ws* (inline_action / inline_expression) ws*)*
(")" / missing_paren_err / unexpected_code))
(")" / missing_paren_err / unexpected_code))
)
indented_text (Text):
'".."' eol %nl {%nl+}? {:curr_indent: indent :}
(indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
unexpected_code?
{:curr_indent: %nil :}
cool_quote:
nonterminal_quote:
'"' &([^%nl] / %nl+ =curr_indent)
cool_indented_text (Text):
indented_text (Text):
'"'
_inline_text*
(('\' %nl+ {:curr_indent: indent :} '..')
(('\' %nl+ {:curr_indent: indent :} ('..' / expected_dotdot))
/ disallowed_interpolation? {%nl+} {:curr_indent: indent :})
(indented_cool_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
(indented_plain_text / text_interpolation / {~ %nl+ (=curr_indent -> "") ~})*
('"' eol / missing_quote_err)
{:curr_indent: %nil :}
indented_cool_plain_text (Text):
{~ ((("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation ((!("\n") escaped_char) / ('\\' -> '\') / '\')) / (cool_quote / [^%nl"\])+)+
(%nl+ (=curr_indent -> ""))* ~}
-- Tracking text-lines-within-indented-text as separate objects allows for better debugging line info
indented_plain_text (Text):
{~ (("\\" -> "\") / (("\" blank_lines =curr_indent "..") -> "") / (!text_interpolation "\") / [^%nl\]+)+
(%nl+ (=curr_indent -> ""))* ~}
{~
((("\" blank_lines =curr_indent "..") -> "") / ('\\' -> '\')
/ (!text_interpolation ((!("\n") escaped_char) / '\'))
/ (nonterminal_quote / [^%nl"\])+)+
(%nl+ (=curr_indent -> ""))*
~}
text_interpolation:
inline_text_interpolation / ("\" indented_expression (blank_lines =curr_indent "..")?)

14
nomsu.lua
View File

@ -280,20 +280,20 @@ run = function()
end
end
if not (args.primary_file or args.exec_strings) then
nomsu:run([[#!/usr/bin/env nomsu -V2
nomsu:run([[#!/usr/bin/env nomsu -V4
use "lib/consolecolor.nom"
action [quit, exit]: lua> "os.exit(0)"
action [help]:
say ".."
This is the Nomsu v\(Nomsu version) interactive console.
say "\
..This is the Nomsu v\(Nomsu version) interactive console.
You can type in Nomsu code here and hit 'enter' twice to run it.
To exit, type 'exit' or 'quit' and hit enter twice.
say ".."
To exit, type 'exit' or 'quit' and hit enter twice."
say "\
..
\(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color)
press 'enter' twice to run a command
\("")]])
"]])
for repl_line = 1, math.huge do
io.write(colored.bright(colored.yellow(">> ")))
local buff = { }

14
nomsu.moon
View File

@ -184,20 +184,20 @@ run = ->
unless args.primary_file or args.exec_strings
-- Run in interactive mode (REPL)
nomsu\run [[
#!/usr/bin/env nomsu -V2
#!/usr/bin/env nomsu -V4
use "lib/consolecolor.nom"
action [quit, exit]: lua> "os.exit(0)"
action [help]:
say ".."
This is the Nomsu v\(Nomsu version) interactive console.
say "\
..This is the Nomsu v\(Nomsu version) interactive console.
You can type in Nomsu code here and hit 'enter' twice to run it.
To exit, type 'exit' or 'quit' and hit enter twice.
say ".."
To exit, type 'exit' or 'quit' and hit enter twice."
say "\
..
\(bright)\(underscore)Welcome to the Nomsu v\(Nomsu version) interactive console!\(reset color)
press 'enter' twice to run a command
\("")]]
"]]
for repl_line=1,math.huge
io.write(colored.bright colored.yellow ">> ")
buff = {}

40
nomsu_compiler.lua
View File

@ -214,37 +214,29 @@ do
end
errs = _accum_0
end
if #errs > 4 then
local num_errs = #errs
do
local _accum_0 = { }
local _len_0 = 1
for i = 1, 3 do
_accum_0[_len_0] = errs[i]
_len_0 = _len_0 + 1
end
errs = _accum_0
end
table.insert(errs, "\027[31;1m +" .. tostring(num_errs - #errs) .. " additional errors...\027[0m\n")
end
if #errs > 0 then
local num_errs = #errs
if num_errs > 0 then
local err_strings
do
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #errs do
local t = errs[_index_0]
_accum_0[_len_0] = pretty_error({
error = t.error,
hint = t.hint,
source = t:get_source_code(),
start = t.source.start,
stop = t.source.stop
})
_len_0 = _len_0 + 1
for i, t in ipairs(errs) do
if i <= 3 then
_accum_0[_len_0] = pretty_error({
error = t.error,
hint = t.hint,
source = t:get_source_code(),
start = t.source.start,
stop = t.source.stop
})
_len_0 = _len_0 + 1
end
end
err_strings = _accum_0
end
if num_errs > 3 then
table.insert(err_strings, "\027[31;1m +" .. tostring(num_errs - #errs) .. " additional errors...\027[0m\n")
end
error(table.concat(err_strings, '\n\n'), 0)
end
return tree

11
nomsu_compiler.moon
View File

@ -112,15 +112,14 @@ with NomsuCompiler
find_errors(v)
errs = [err for err in coroutine.wrap(-> find_errors(tree))]
if #errs > 4
num_errs = #errs
errs = [errs[i] for i=1,3]
table.insert(errs, "\027[31;1m +#{num_errs-#errs} additional errors...\027[0m\n")
if #errs > 0
num_errs = #errs
if num_errs > 0
err_strings = [pretty_error{
error:t.error, hint:t.hint, source:t\get_source_code!
start:t.source.start, stop:t.source.stop
} for t in *errs]
} for i, t in ipairs(errs) when i <= 3]
if num_errs > 3
table.insert(err_strings, "\027[31;1m +#{num_errs-#errs} additional errors...\027[0m\n")
error(table.concat(err_strings, '\n\n'), 0)
return tree
.can_optimize = -> false

2
pretty_errors.lua
View File

@ -25,7 +25,7 @@ format_error = function(err)
else
pointer = (" "):rep(err_linepos + #fmt_str:format(0) - 1) .. "⬆"
end
local err_msg = "\027[33;41;1mParse error at " .. tostring(err.filename) .. ":" .. tostring(err_linenum) .. "\027[0m"
local err_msg = "\027[33;41;1mParse error at " .. tostring(err.filename or '???') .. ":" .. tostring(err_linenum) .. "\027[0m"
for i = err_linenum - context, err_linenum - 1 do
do
local line = string2.line(err.source, i)

2
pretty_errors.moon
View File

@ -23,7 +23,7 @@ format_error = (err)->
(" ")\rep(err_linepos+#fmt_str\format(0)-1).."╚#{("═")\rep(err_size-2)}╝"
else
(" ")\rep(err_linepos+#fmt_str\format(0)-1).."⬆"
err_msg = "\027[33;41;1mParse error at #{err.filename}:#{err_linenum}\027[0m"
err_msg = "\027[33;41;1mParse error at #{err.filename or '???'}:#{err_linenum}\027[0m"
for i=err_linenum-context,err_linenum-1
if line = string2.line(err.source, i)
err_msg ..= "\n\027[2m#{fmt_str\format(i)}\027[0m#{line}\027[0m"

17
syntax_tree.lua
View File

@ -42,16 +42,19 @@ for _index_0 = 1, #types do
return getmetatable(x) == self
end
cls.__tostring = function(self)
return tostring(self.type) .. tostring(repr(self, (function(x)
return Source:is_instance(x) and repr(tostring(x)) or nil
end)))
return tostring(self.type) .. tostring(repr(self))
end
cls.__repr = function(self)
return tostring(self.type) .. tostring(repr(self, (function(x)
return Source:is_instance(x) and repr(tostring(x)) or nil
end)))
return tostring(self.type) .. tostring(repr(self))
end
cls.source_code_for_tree = { }
cls.source_code_for_tree = setmetatable({ }, {
__index = function(self, t)
local s = t.source
local Files = require('files')
local f = Files.read(s.filename)
return f
end
})
cls.get_source_code = function(self)
return self.source_code_for_tree[self]
end

11
syntax_tree.moon
View File

@ -19,9 +19,14 @@ for name in *types
.__name = name
.type = name
.is_instance = (x)=> getmetatable(x) == @
.__tostring = => "#{@type}#{repr @, ((x)-> Source\is_instance(x) and repr(tostring(x)) or nil)}"
.__repr = => "#{@type}#{repr @, ((x)-> Source\is_instance(x) and repr(tostring(x)) or nil)}"
.source_code_for_tree = {}
.__tostring = => "#{@type}#{repr @}"
.__repr = => "#{@type}#{repr @}"
.source_code_for_tree = setmetatable({}, {__index:(t)=>
s = t.source
Files = require 'files'
f = Files.read(s.filename)
return f
})
.get_source_code = => @source_code_for_tree[@]
.map = (fn)=>
replacement = fn(@)

8
tools/autoformat.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
Auto-format Nomsu code. Usage:
nomsu tools/autoformat.nom [-i] file1 file2 directory1 ...
@ -16,9 +16,9 @@ if (%args.1 is "-i"):
for %path in %args:
for file %filename in %path:
unless (%filename::matches "%.nom$"): do next %filename
%formatted = ".."
#!/usr/bin/env nomsu -V\(Nomsu version)
\((parse (read file %filename) from %filename) as nomsu)
%formatted = "\
..#!/usr/bin/env nomsu -V\(Nomsu version)
\((parse (read file %filename) from %filename) as nomsu)"
if %inplace:
write %formatted to file %filename

2
tools/find_action.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
Find an action by its stub. Usage:
nomsu tools/find_action.nom "foo %" file1 file2 directory1 ...

2
tools/parse.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
Tool to print out a parse tree of files in an easy-to-read format. Usage:
nomsu tools/parse.nom file1 file2 directory1 ...

8
tools/replace.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
Tool to find and replace one tree with another.
nomsu tools/replace.nom [-i] tree_to_replace replacement file1 file2 directory1 ...
@ -29,9 +29,9 @@ for %path in %args:
say "No changes in \%filename"
do next %filename
%text = ".."
#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version))
\(%tree2 as nomsu)
%text = "\
..#!/usr/bin/env nomsu -V\(%tree.version or (Nomsu version))
\(%tree2 as nomsu)"
if:
%inplace:

2
tools/test.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
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 ...

8
tools/upgrade.nom
View File

@ -1,4 +1,4 @@
#!/usr/bin/env nomsu -V3.8.7.6
#!/usr/bin/env nomsu -V4.8.8.6
#
Tool to automatically update code from old versions of Nomsu. Usage:
nomsu tools/upgrade.nom [-i] file1 file2 directory1 ...
@ -24,9 +24,9 @@ for %path in %args:
unless (%filename::matches "%.nom$"): do next %filename
%tree = (parse (read file %filename) from %filename)
%uptree = (%tree upgraded)
%text = ".."
#!/usr/bin/env nomsu -V\(Nomsu version)
\(%uptree as nomsu)
%text = "\
..#!/usr/bin/env nomsu -V\(Nomsu version)
\(%uptree as nomsu)"
if:
%inplace: