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

Major overhaul of how modules and environments work, along with some

Browse Source 
steamlining and tweaks to the makefile. Version bump: 6.14.13.8
This commit is contained in:
Bruce Hill 2019-01-10 16:33:37 -08:00
parent db552f56dc
commit 0f0fb2256a
59 changed files with 1294 additions and 1383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Makefile
View File

@ -7,15 +7,16 @@ LUA= lua
LUA_BIN= $(shell which $(LUA))
PREFIX=
PACKAGEPATH=
UNINSTALL_VERSION=
# ========= You shouldn't need to mess with any of these variables below ================
MOON_FILES= code_obj.moon error_handling.moon files.moon nomsu.moon nomsu_compiler.moon \
syntax_tree.moon containers.moon bitops.moon parser.moon pretty_errors.moon \
string2.moon nomsu_decompiler.moon nomsu_environment.moon importer.moon
string2.moon nomsu_decompiler.moon nomsu_environment.moon bootstrap.moon
LUA_FILES= code_obj.lua consolecolors.lua error_handling.lua files.lua nomsu.lua nomsu_compiler.lua \
syntax_tree.lua containers.lua bitops.lua parser.lua pretty_errors.lua \
string2.lua nomsu_decompiler.lua nomsu_environment.lua importer.lua
string2.lua nomsu_decompiler.lua nomsu_environment.lua bootstrap.lua
CORE_NOM_FILES= $(wildcard core/**.nom)
CORE_LUA_FILES= $(patsubst %.nom,%.lua,$(CORE_NOM_FILES))
LIB_NOM_FILES= $(wildcard lib/**.nom)
@ -30,7 +31,7 @@ test: lua optimize
@echo "\033[1;4mRunning unoptimized tests...\033[0m"
@$(LUA_BIN) nomsu.lua -O0 tools/test.nom $(CORE_NOM_FILES) $(LIB_NOM_FILES)
@echo "\n\033[1;4mRunning optimized tests...\033[0m"
@$(LUA_BIN) nomsu.lua -O1 tools/test.nom $(CORE_NOM_FILES) $(LIB_NOM_FILES)
@$(LUA_BIN) nomsu.lua -O1 tools/test.nom $(CORE_LUA_FILES) $(LIB_LUA_FILES)
%.lua: %.moon
@moonc $<
@ -58,9 +59,12 @@ install: lua version optimize
if [[ ! $$prefix ]]; then \
read -p $$'\033[1mWhere do you want to install Nomsu? (default: /usr/local) \033[0m' prefix; \
fi; \
if [[ ! $$prefix ]]; then \
prefix="/usr/local"; \
if [[ ! $$prefix ]]; then prefix="/usr/local"; fi; \
packagepath="$(PACKAGEPATH)"; \
if [[ ! $$packagepath ]]; then \
read -p $$'\033[1mWhere do you want Nomsu to put packages you install in the future? (default: /opt) \033[0m' packagepath; \
fi; \
if [[ ! $$packagepath ]]; then packagepath="/opt"; fi; \
if [[ $$prefix != "`realpath $$prefix`" ]]; then \
echo $$'\033[1;31mWarning: '$$prefix$$' is not an absolute path. This may cause problems.\033[0m'; \
read -p $$'\033[1mWould you rather use '`realpath $$prefix`$$' instead? (recommended)[Y/n]\033[0m ' use_real; \
@ -69,8 +73,9 @@ install: lua version optimize
fi; \
fi; \
version="`cat version`"; \
mkdir -pv $$prefix/bin $$prefix/lib/nomsu/$$version $$prefix/share/nomsu/$$version $$prefix/share/man/man1 \
&& echo "#!$(LUA_BIN)\\nlocal NOMSU_VERSION, NOMSU_PREFIX = [[$$version]], [[$$prefix]]" | cat - nomsu.lua > $$prefix/bin/nomsu$$version \
mkdir -pv $$prefix/bin $$prefix/lib/nomsu/$$version $$prefix/share/nomsu/$$version $$prefix/share/man/man1 $$packagepath/nomsu \
&& echo "#!$(LUA_BIN)\\nlocal NOMSU_VERSION, NOMSU_PREFIX, NOMSU_PACKAGEPATH = [[$$version]], [[$$prefix]], [[$$packagepath]]" \
| cat - nomsu.lua > $$prefix/bin/nomsu$$version \
&& chmod +x $$prefix/bin/nomsu$$version \
&& cp -v nomsu $$prefix/bin \
&& cp -v doc/nomsu.1 $$prefix/share/man/man1 \
@ -82,13 +87,18 @@ uninstall: version
if [[ ! $$prefix ]]; then \
read -p $$'\033[1mWhere do you want to uninstall Nomsu from? (default: /usr/local) \033[0m' prefix; \
fi; \
if [[ ! $$prefix ]]; then \
prefix="/usr/local"; \
if [[ ! $$prefix ]]; then prefix="/usr/local"; fi; \
packagepath="$(PACKAGEPATH)"; \
if [[ ! $$packagepath ]]; then \
read -p $$'\033[1mWhere have your Nomsu packages been installed? (default: /opt) \033[0m' packagepath; \
fi; \
if [[ ! $$packagepath ]]; then packagepath="/opt"; fi; \
echo "\033[1mNomsu will be uninstalled from:\033[0m"; \
echo " $$prefix/bin"; \
echo " $$prefix/lib"; \
echo " $$prefix/share"; \
echo "\033[1mNomsu packages will be uninstalled from:\033[0m"; \
echo " $$packagepath/nomsu"; \
read -p $$'\033[1mis this okay? [Y/n]\033[0m ' ans; \
if [[ $$ans =~ ^[Nn] ]]; then exit; fi; \
echo "\033[1mDeleting...\033[0m"; \
@ -108,6 +118,12 @@ uninstall: version
fi; \
if [ "`ls $$prefix/lib/nomsu 2>/dev/null`" == "" ]; then rm -rvf $$prefix/lib/nomsu; fi;\
if [ "`ls $$prefix/share/nomsu 2>/dev/null`" == "" ]; then rm -rvf $$prefix/share/nomsu; fi;\
if [ -d $$packagepath/nomsu ]; then \
read -p $$'\033[1mDo you want to delete all installed libraries from /opt? [y/n] \033[0m' confirm; \
if [[ $$confirm == "y" ]]; then \
rm -rvf $$packagepath/nomsu; \
fi; \
fi; \
echo $$'\033[1mDone.\033[0m';
# eof

163
bootstrap.lua Normal file
View File

@ -0,0 +1,163 @@
local match, sub, gsub, format, byte, find
do
local _obj_0 = string
match, sub, gsub, format, byte, find = _obj_0.match, _obj_0.sub, _obj_0.gsub, _obj_0.format, _obj_0.byte, _obj_0.find
end
local LuaCode, Source
do
local _obj_0 = require("code_obj")
LuaCode, Source = _obj_0.LuaCode, _obj_0.Source
end
local SyntaxTree = require("syntax_tree")
local Files = require("files")
local pretty_error = require("pretty_errors")
local compile_error
compile_error = function(source, err_msg, hint)
if hint == nil then
hint = nil
end
local file
if SyntaxTree:is_instance(source) then
file = source:get_source_file()
source = source.source
elseif type(source) == 'string' then
source = Source:from_string(source)
end
if source and not file then
file = Files.read(source.filename)
end
local err_str = pretty_error({
title = "Compile error",
error = err_msg,
hint = hint,
source = file,
start = source.start,
stop = source.stop,
filename = source.filename
})
return error(err_str, 0)
end
local MAX_LINE = 80
local ENVNAME = jit and "_G" or "_ENV"
local compile_actions = {
[""] = function(self, fn, ...)
local lua = LuaCode()
local fn_lua = self:compile(fn)
lua:add(fn_lua)
if not (fn_lua:text():match("^%(.*%)$") or fn_lua:text():match("^[_a-zA-Z][_a-zA-Z0-9.]*$")) then
lua:parenthesize()
end
lua:add("(")
for i = 1, select('#', ...) do
if i > 1 then
lua:add(", ")
end
lua:add(self:compile((select(i, ...))))
end
lua:add(")")
return lua
end,
["Lua"] = function(self, code)
if not code then
return LuaCode("LuaCode()")
end
if code.type ~= "Text" then
return LuaCode("LuaCode:from(", tostring(code.source):as_lua(), ", ", self:compile(code), ")")
end
local operate_on_text
operate_on_text = function(text)
local lua = LuaCode:from(text.source, "LuaCode:from(", tostring(text.source):as_lua())
for _index_0 = 1, #text do
local bit = text[_index_0]
local bit_lua
if type(bit) == "string" then
bit_lua = bit:as_lua()
elseif bit.type == "Text" then
bit_lua = operate_on_text(bit)
elseif bit.type == "Block" then
bit_lua = LuaCode:from(bit.source, "(function()", "\n local _lua = LuaCode:from(", tostring(bit.source):as_lua(), ")", "\n local function add(...) _lua:add(...) end", "\n local function join_with(glue)", "\n local old_bits = _lua.bits", "\n _lua = LuaCode:from(_lua.source)", "\n _lua:concat_add(old_bits, glue)", "\n end", "\n ", self:compile(bit), "\n return _lua", "\nend)()")
else
bit_lua = self:compile(bit)
end
local bit_leading_len = #(bit_lua:match("^[^\n]*"))
lua:add(lua:trailing_line_len() + bit_leading_len > MAX_LINE and ",\n " or ", ")
lua:add(bit_lua)
end
lua:add(")")
return lua
end
return operate_on_text(code)
end,
["lua >"] = function(self, code)
if code.type ~= "Text" then
return code
end
local operate_on_text
operate_on_text = function(text)
local lua = LuaCode:from(text.source)
for _index_0 = 1, #text do
local bit = text[_index_0]
if type(bit) == "string" then
lua:add(bit)
elseif bit.type == "Text" then
lua:add(operate_on_text(bit))
else
lua:add(self:compile(bit))
end
end
return lua
end
return operate_on_text(code)
end,
["= lua"] = function(self, code)
return self:compile(SyntaxTree({
type = "Action",
"lua",
">",
code
}))
end,
["1 as lua"] = function(self, code)
return LuaCode(tostring(ENVNAME) .. ":compile(", self:compile(code), ")")
end,
["use"] = function(self, path)
return LuaCode(tostring(ENVNAME) .. ":use(" .. tostring(self:compile(path)) .. ")")
end,
["export"] = function(self, path)
return LuaCode(tostring(ENVNAME) .. ":export(" .. tostring(self:compile(path)) .. ")")
end,
["run"] = function(self, path)
return LuaCode(tostring(ENVNAME) .. ":run(" .. tostring(self:compile(path)) .. ")")
end,
["test"] = function(self, body)
if not (body.type == 'Block') then
compile_error(body, "This should be a Block")
end
local test_nomsu = body:get_source_code():match(":[ ]*(.*)")
do
local indent = test_nomsu:match("\n([ ]*)")
if indent then
test_nomsu = test_nomsu:gsub("\n" .. indent, "\n")
end
end
local test_text = self:compile(SyntaxTree({
type = "Text",
source = body.source,
test_nomsu
}))
return LuaCode("TESTS[" .. tostring(tostring(body.source):as_lua()) .. "] = ", test_text)
end,
["is jit"] = function(self, code)
return LuaCode("jit")
end,
["Lua version"] = function(self, code)
return LuaCode("_VERSION")
end,
["nomsu environment"] = function(self)
return LuaCode(ENVNAME)
end,
["nomsu environment name"] = function(self)
return LuaCode(ENVNAME:as_lua())
end
}
return compile_actions

125
bootstrap.moon Normal file
View File

@ -0,0 +1,125 @@
-- This file contains a set of compile actions needed for bootstrapping
{:match, :sub, :gsub, :format, :byte, :find} = string
{:LuaCode, :Source} = require "code_obj"
SyntaxTree = require "syntax_tree"
Files = require "files"
-- TODO: de-duplicate this
pretty_error = require("pretty_errors")
compile_error = (source, err_msg, hint=nil)->
local file
if SyntaxTree\is_instance(source)
file = source\get_source_file!
source = source.source
elseif type(source) == 'string'
source = Source\from_string(source)
if source and not file
file = Files.read(source.filename)
err_str = pretty_error{
title: "Compile error"
error:err_msg, hint:hint, source:file
start:source.start, stop:source.stop, filename:source.filename
}
error(err_str, 0)
MAX_LINE = 80 -- For beautification purposes, try not to make lines much longer than this value
--ENVNAME = jit and "getfenv(1)" or "_ENV"
ENVNAME = jit and "_G" or "_ENV"
compile_actions = {
[""]: (fn, ...)=>
lua = LuaCode!
fn_lua = @compile(fn)
lua\add fn_lua
unless fn_lua\text!\match("^%(.*%)$") or fn_lua\text!\match("^[_a-zA-Z][_a-zA-Z0-9.]*$")
lua\parenthesize!
lua\add "("
for i=1,select('#',...)
lua\add(", ") if i > 1
lua\add @compile((select(i, ...)))
lua\add ")"
return lua
["Lua"]: (code)=>
if not code
return LuaCode("LuaCode()")
if code.type != "Text"
return LuaCode("LuaCode:from(", tostring(code.source)\as_lua!, ", ", @compile(code), ")")
operate_on_text = (text)->
lua = LuaCode\from(text.source, "LuaCode:from(", tostring(text.source)\as_lua!)
for bit in *text
local bit_lua
if type(bit) == "string"
bit_lua = bit\as_lua!
elseif bit.type == "Text"
bit_lua = operate_on_text(bit)
elseif bit.type == "Block"
bit_lua = LuaCode\from bit.source, "(function()",
"\n local _lua = LuaCode:from(", tostring(bit.source)\as_lua!, ")",
"\n local function add(...) _lua:add(...) end",
"\n local function join_with(glue)",
"\n local old_bits = _lua.bits",
"\n _lua = LuaCode:from(_lua.source)",
"\n _lua:concat_add(old_bits, glue)",
"\n end",
"\n ", @compile(bit),
"\n return _lua",
"\nend)()"
else
bit_lua = @compile(bit)
bit_leading_len = #(bit_lua\match("^[^\n]*"))
lua\add(lua\trailing_line_len! + bit_leading_len > MAX_LINE and ",\n " or ", ")
lua\add(bit_lua)
lua\add ")"
return lua
return operate_on_text code
["lua >"]: (code)=>
if code.type != "Text"
return code
operate_on_text = (text)->
lua = LuaCode\from(text.source)
for bit in *text
if type(bit) == "string"
lua\add bit
elseif bit.type == "Text"
lua\add(operate_on_text(bit))
else
lua\add @compile(bit)
return lua
return operate_on_text code
["= lua"]: (code)=>
@compile(SyntaxTree{type:"Action", "lua", ">", code})
["1 as lua"]: (code)=>
LuaCode("#{ENVNAME}:compile(", @compile(code), ")")
["use"]: (path)=>
LuaCode("#{ENVNAME}:use(#{@compile(path)})")
["export"]: (path)=>
LuaCode("#{ENVNAME}:export(#{@compile(path)})")
["run"]: (path)=>
LuaCode("#{ENVNAME}:run(#{@compile(path)})")
["test"]: (body)=>
unless body.type == 'Block'
compile_error(body, "This should be a Block")
test_nomsu = body\get_source_code!\match(":[ ]*(.*)")
if indent = test_nomsu\match("\n([ ]*)")
test_nomsu = test_nomsu\gsub("\n"..indent, "\n")
test_text = @compile(SyntaxTree{type:"Text", source:body.source, test_nomsu})
return LuaCode "TESTS[#{tostring(body.source)\as_lua!}] = ", test_text
["is jit"]: (code)=> LuaCode("jit")
["Lua version"]: (code)=> LuaCode("_VERSION")
["nomsu environment"]: ()=> LuaCode(ENVNAME)
["nomsu environment name"]: ()=> LuaCode(ENVNAME\as_lua!)
}
return compile_actions

3
code_obj.lua
View File

@ -163,6 +163,9 @@ do
repeat
local b = select(i, ...)
assert(b, "code bit is nil")
if b.Dict then
require('ldt').breakpoint()
end
assert(not Source:is_instance(b), "code bit is a Source")
if b == '' then
_continue_0 = true

2
code_obj.moon
View File

@ -98,6 +98,8 @@ class Code
for i=1,n
b = select(i, ...)
assert(b, "code bit is nil")
if b.Dict
require('ldt').breakpoint()
assert(not Source\is_instance(b), "code bit is a Source")
if b == '' then continue
bits[#bits+1] = b

2
compatibility/2.3.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <2.3 to Nomsu 2.3
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/2.4.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <2.4 to Nomsu 2.4
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/2.5.5.5.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/2.5.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <2.5 to Nomsu 2.5
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/2.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu 1 to Nomsu 2
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/3.5.5.6.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <3.5.5.6 to Nomsu 3.5.5.6
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/3.6.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <3.6 to 3.6
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/3.7.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <3.7 to 3.7
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/3.nom
View File

@ -2,7 +2,7 @@
#
This file defines upgrades from Nomsu <=2 to Nomsu 3
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/4.10.12.7.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V6.14
#
This file defines upgrades from Nomsu <4.10.12.7 to 4.10.12.7
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/4.11.nom
View File

@ -3,7 +3,7 @@
This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
(overhaul of function literals, deleting (if all of ...), etc. shorthand)
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/4.12.nom
View File

@ -3,7 +3,7 @@
This file defines upgrades from Nomsu <4.11 to Nomsu 4.11
(overhaul of function literals, deleting (if all of ...), etc. shorthand)
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/4.8.10.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V6.14
#
This file defines upgrades from Nomsu <4.8.10 to 4.8.10 (renaming "action" -> "means")
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/4.9.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V6.14
#
This file defines upgrades from Nomsu <4.9 to 4.9
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/5.13.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V5.13
#
This file defines upgrades from Nomsu <5.13 to 5.13
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/6.14.nom
View File

@ -1,7 +1,7 @@
#!/usr/bin/env nomsu -V6.14
#
This file defines upgrades from Nomsu <6.14 to 6.14
use "compatibility/compatibility.nom"
use "compatibility/compatibility"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
compatibility/compatibility.nom
View File

@ -3,7 +3,7 @@
This file contains code for defining ways to upgrade code between different versions
of Nomsu.
use "lib/os.nom"
use "lib/os"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

6
core/collections.nom
View File

@ -3,9 +3,9 @@
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"
use "core/metaprogramming"
use "core/control_flow"
use "core/operators"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

17
core/control_flow.nom
View File

@ -3,8 +3,8 @@
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/metaprogramming"
use "core/operators"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -464,18 +464,15 @@ test:
assume (sorted $flat) == [1, 2, 3, 4, 5, 6]
# Recurion control flow
(recurse $v on $x) compiles to
Lua "table.insert(_stack_\($v as lua expr), \($x as lua expr))"
(for $var in recursive $structure $body) compiles to:
with local compile actions:
define mangler
(recurse $v on $x) compiles to
Lua "table.insert(\(mangle "stack \($v.1)"), \($x as lua expr))"
$lua =
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)
local _stack_\($var as lua expr) = List{\($structure as lua expr)}
while #_stack_\($var as lua expr) > 0 do
\($var as lua expr) = table.remove(_stack_\($var as lua expr), 1)
\($body as lua)
")

6
core/coroutines.nom
View File

@ -2,9 +2,9 @@
#
This file defines the code that creates and manipulates coroutines
use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/control_flow.nom"
use "core/metaprogramming"
use "core/operators"
use "core/control_flow"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

4
core/errors.nom
View File

@ -2,8 +2,8 @@
#
This file contains basic error reporting code
use "core/metaprogramming.nom"
use "core/operators.nom"
use "core/metaprogramming"
use "core/operators"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

10
core/id.nom
View File

@ -2,11 +2,11 @@
#
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"
use "core/collections.nom"
use "core/control_flow.nom"
use "core/metaprogramming"
use "core/operators"
use "core/math"
use "core/collections"
use "core/control_flow"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

11
core/init.nom Normal file
View File

@ -0,0 +1,11 @@
# Export everything
export "core/metaprogramming"
export "core/operators"
export "core/control_flow"
export "core/errors"
export "core/collections"
export "core/coroutines"
export "core/math"
export "core/id"
export "core/io"
export "core/text"

2
core/io.nom
View File

@ -2,7 +2,7 @@
#
This file contains basic input/output code
use "core/metaprogramming.nom"
use "core/metaprogramming"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

10
core/math.nom
View File

@ -2,11 +2,11 @@
#
This file defines some common math literals and functions
use "core/metaprogramming.nom"
use "core/text.nom"
use "core/operators.nom"
use "core/control_flow.nom"
use "core/collections.nom"
use "core/metaprogramming"
use "core/text"
use "core/operators"
use "core/control_flow"
use "core/collections"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

73
core/metaprogramming.nom
View File

@ -16,15 +16,15 @@ lua> ("
end
end
end
compile.action["define mangler"] = function(compile)
COMPILE_RULES["define mangler"] = function(\(nomsu environment))
return LuaCode("local mangle = mangler()")
end
")
lua> ("
compile.action["1 ->"] = function(compile, \$args, \$body)
COMPILE_RULES["1 ->"] = function(\(nomsu environment), \$args, \$body)
if \$args and not \$body then \$args, \$body = {}, \$args end
local body_lua = SyntaxTree:is_instance(\$body) and compile(\$body) or \$body
local body_lua = SyntaxTree:is_instance(\$body) and \(nomsu environment):compile(\$body) or \$body
if SyntaxTree:is_instance(\$body) and \$body.type ~= "Block" then body_lua:prepend("\
..return ") end
local lua = LuaCode("(function(")
@ -32,7 +32,7 @@ lua> ("
\$args = \$args:get_args()
elseif SyntaxTree:is_instance(\$args) and \$args.type == "Var" then \$args = {\$args} end
for i, arg in ipairs(\$args) do
local arg_lua = SyntaxTree:is_instance(arg) and compile(arg):text() or arg
local arg_lua = SyntaxTree:is_instance(arg) and \(nomsu environment):compile(arg):text() or arg
if arg_lua == "..." then
if i < #\$args then
compile_error_at(SyntaxTree:is_instance(arg) and arg or nil,
@ -52,8 +52,8 @@ lua> ("
lua:add(")\\n ", body_lua, "\\nend)")
return lua
end
compile.action["->"] = compile.action["1 ->"]
compile.action["for"] = compile.action["1 ->"]
COMPILE_RULES["->"] = COMPILE_RULES["1 ->"]
COMPILE_RULES["for"] = COMPILE_RULES["1 ->"]
")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -85,12 +85,12 @@ test:
fail "compile to is leaking variables"
lua> ("
compile.action["1 compiles to"] = function(compile, \$action, \$body)
local \$args = List{\(\$compile), unpack(\$action:get_args())}
COMPILE_RULES["1 compiles to"] = function(env, \$action, \$body)
local \$args = List{"\(nomsu environment)", unpack(\$action:get_args())}
if \$body.type == "Text" then
\$body = SyntaxTree{source=\$body.source, type="Action", "Lua", \$body}
end
return LuaCode("compile.action[", \$action:get_stub():as_lua(),
return LuaCode("COMPILE_RULES[", \$action:get_stub():as_lua(),
"] = ", \(\($args -> $body) as lua))
end
")
@ -103,18 +103,21 @@ lua> ("
compile_error(\$actions, "This should be a list of actions.")
end
local lua = \(\($actions.1 compiles to $body) as lua)
local \$args = List{\(\$compile), unpack(\$actions[1]:get_args())}
local \$compiled_args = List(table.map(\$args, compile))
local \$args = List{"\(nomsu environment)", unpack(\$actions[1]:get_args())}
local \$compiled_args = List{"\(nomsu environment)"};
for i=2,#\$args do \$compiled_args[i] = \(nomsu environment):compile(\$args[i]) end
for i=2,#\$actions do
local alias = \$actions[i]
local \$alias_args = List{\(\$compile), unpack(alias:get_args())}
lua:add("\\ncompile.action[", alias:get_stub():as_lua(), "] = ")
local \$alias_args = List{"\(nomsu environment)", unpack(alias:get_args())}
lua:add("\\nCOMPILE_RULES[", alias:get_stub():as_lua(), "] = ")
if \$alias_args == \$args then
lua:add("compile.action[", \$actions[1]:get_stub():as_lua(), "]")
lua:add("COMPILE_RULES[", \$actions[1]:get_stub():as_lua(), "]")
else
lua:add("function(")
lua:concat_add(table.map(\$alias_args, compile), ", ")
lua:add(") return compile.action[", \$actions[1]:get_stub():as_lua(), "](")
local \$compiled_alias_args = List{"\(nomsu environment)"};
for i=2,#\$alias_args do \$compiled_alias_args[i] = \(nomsu environment):compile(\$alias_args[i]) end
lua:concat_add(\$compiled_alias_args, ", ")
lua:add(") return COMPILE_RULES[", \$actions[1]:get_stub():as_lua(), "](")
lua:concat_add(\$compiled_args, ", ")
lua:add(") end")
end
@ -145,7 +148,7 @@ test:
local lua = LuaCode()
if \$action.type == "MethodCall" then
lua:add(compile(\$action[1]), ".", \$action[2]:get_stub():as_lua_id())
lua:add(\(nomsu environment):compile(\$action[1]), ".", \$action[2]:get_stub():as_lua_id())
elseif \$action.type == "Action" then
lua:add(\$action:get_stub():as_lua_id())
lua:add_free_vars({\$action:get_stub():as_lua_id()})
@ -160,7 +163,7 @@ test:
lua> ("
local lua = \(\($actions.1 means $body) as lua)
local first_def = (\$actions[1].type == "MethodCall"
and LuaCode(compile(\$actions[1][1]), ".", \$actions[1]:get_stub():as_lua_id())
and LuaCode(\(nomsu environment):compile(\$actions[1][1]), ".", \$actions[1]:get_stub():as_lua_id())
or LuaCode(\$actions[1]:get_stub():as_lua_id()))
local \$args = List(\$actions[1]:get_args())
for i=2,#\$actions do
@ -168,7 +171,7 @@ test:
local \$alias_args = List(alias:get_args())
lua:add("\\n")
if alias.type == "MethodCall" then
lua:add(compile(alias[1]), ".", alias:get_stub():as_lua_id())
lua:add(\(nomsu environment):compile(alias[1]), ".", alias:get_stub():as_lua_id())
else
lua:add(alias:get_stub():as_lua_id())
lua:add_free_vars({alias_name})
@ -229,7 +232,7 @@ test:
compile_error(\$actions, "This should be a list.")
end
for i,arg in ipairs(\$actions[1]:get_args()) do
replacements[arg[1]] = compile(arg):text()
replacements[arg[1]] = \(nomsu environment):compile(arg):text()
end
local function make_tree(t)
if SyntaxTree:is_instance(t) and t.type == "Var" then
@ -273,7 +276,7 @@ test:
[$action parses as $body] all parse as ([$action] all parse as $body)
externally ($tree as lua expr) means:
lua> ("
local tree_lua = compile(\$tree)
local tree_lua = \(nomsu environment):compile(\$tree)
if \$tree.type == 'Block' then
tree_lua = LuaCode:from(\$tree.source, '(function()\\n ', tree_lua, '\\nend)()')
elseif \$tree.type == 'MethodCall' and #\$tree > 2 then
@ -403,18 +406,6 @@ externally (type of $) means:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test:
assume ((run "return (2 + 99)") == 101)
$x = 0
externally (set to $) means:
external $x = $
run "set to 1"
assume $x == 1
assume (run \(return \(\(5) + \(5)))) == 10
(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))"
test:
(foo) means:
return 100 200 300
@ -427,7 +418,7 @@ test:
local lua = \(Lua "do return ")
for i=1,select('#',...) do
if i > 1 then lua:add(", ") end
lua:add(_1_as_lua((select(i, ...))))
lua:add(\(nomsu environment):compile((select(i, ...))))
end
lua:add(" end")
return lua
@ -445,15 +436,17 @@ test:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(with local compile actions $body) compiles to ("
#
(with local compile actions $body) compiles to ("
do
--local compile = _1_forked(compile)
local old_action = compile.action
compile.action = _1_forked(old_action)
local OLD_RULES = COMPILE_RULES
local OLD_ENV = \(nomsu environment)
local \(nomsu environment) = setmetatable({
COMPILE_RULES=setmetatable({}, {__index=OLD_RULES})
}, {__index=OLD_ENV})
\($body as lua)
compile.action = old_action
end
")
")
externally (Nomsu version) means:
return ("

4
core/operators.nom
View File

@ -2,7 +2,7 @@
#
This file contains definitions of operators like "+" and "and".
use "core/metaprogramming.nom"
use "core/metaprogramming"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -101,7 +101,7 @@ test:
(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))
\$body_lua:remove_free_vars(table.map(\$externs, function(v) return \(nomsu environment):compile(v):text() end))
")
return $body_lua

8
core/text.nom
View File

@ -3,9 +3,9 @@
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"
use "core/metaprogramming"
use "core/operators"
use "core/control_flow"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -75,4 +75,4 @@ $escapes = {
for $name = $str in $escapes:
with [$lua = (Lua (quote $str))]:
$compile.action.$name = (-> $lua)
$(COMPILE RULES).$name = (-> $lua)

7
doc/nomsu.1
View File

@ -15,8 +15,7 @@ nomsu \- run a Nomsu program
|
.I -e nomsu_code
|
.I -m nomsu_files...
[--]
.I nomsu_files... --
]
[
.I args
@ -35,7 +34,7 @@ If no input files are provided, \fBnomsu\fR will run in interactive mode.
.BI \-t " tool"
Run the specified Nomsu tool (one of the tools/*.nom files provided with the compiler).
.TP
.BI \-m " file1 file2... " [--]
.BI " file1 file2... --"
Run multiple files. If a "--" is supplied, any additional arguments will be treated as arguments for the files, rather than additional files.
.TP
.BI \-e " code"
@ -93,7 +92,7 @@ Compiles the Nomsu file 'my_file.nom' into a Lua file called 'my_file.lua'
.TP
.B
nomsu -m one.nom two.nom three.nom
nomsu one.nom two.nom three.nom --
Runs 'one.nom', then 'two.nom', then 'three.nom'.
.TP

2
examples/how_do_i.nom
View File

@ -7,7 +7,7 @@
(including any deeper-level indented text)
The comment ends when the indentation ends
# How do I import a file?
use "lib/os.nom"
use "lib/os"
# How do I import all the files in a directory?
use "lib"

6
files.lua
View File

@ -3,7 +3,7 @@ local re = require('re')
local Files = { }
local run_cmd
run_cmd = function(cmd)
local f = io.popen(cmd)
local f = io.popen(cmd .. ' 2>/dev/null')
local lines
do
local _accum_0 = { }
@ -84,7 +84,7 @@ Files.list = function(path)
path
}
else
_BROWSE_CACHE[path] = run_cmd('find -L "' .. path .. '" -not -path "*/\\.*" -type f 2>/dev/null') or false
_BROWSE_CACHE[path] = run_cmd('find -L "' .. path .. '" -not -path "*/\\.*" -type f') or false
end
end
return _BROWSE_CACHE[path]
@ -158,7 +158,7 @@ if ok then
return _BROWSE_CACHE[path]
end
else
if not (run_cmd('find . -maxdepth 0 2>/dev/null')) then
if not (run_cmd('find . -maxdepth 0')) then
local url
if jit then
url = 'https://github.com/spacewander/luafilesystem'

6
files.moon
View File

@ -4,7 +4,7 @@ re = require 're'
Files = {}
run_cmd = (cmd)->
f = io.popen(cmd)
f = io.popen(cmd..' 2>/dev/null')
lines = [line for line in f\lines!]
return nil unless f\close!
return lines
@ -57,7 +57,7 @@ Files.list = (path)->
local files
_BROWSE_CACHE[path] = if _SPOOFED_FILES[path] or path == 'stdin' or path == '-'
{path}
else run_cmd('find -L "'..path..'" -not -path "*/\\.*" -type f 2>/dev/null') or false
else run_cmd('find -L "'..path..'" -not -path "*/\\.*" -type f') or false
return _BROWSE_CACHE[path]
ok, lfs = pcall(require, "lfs")
@ -93,7 +93,7 @@ if ok
if f\match("^%./") then _BROWSE_CACHE[path][i] = f\sub(3)
return _BROWSE_CACHE[path]
else
unless run_cmd('find . -maxdepth 0 2>/dev/null')
unless run_cmd('find . -maxdepth 0')
url = if jit
'https://github.com/spacewander/luafilesystem'
else 'https://github.com/keplerproject/luafilesystem'

85
importer.lua
View File

@ -1,85 +0,0 @@
local import_to_1_from
import_to_1_from = function(host, to_import, prefix)
if prefix == nil then
prefix = nil
end
do
local host_mt = getmetatable(host)
if host_mt then
if host_mt.__import then
host_mt.__import(host, to_import, prefix)
return
end
end
end
for k, v in pairs(to_import) do
if k == to_import then
k = host
end
if v == to_import then
v = host
end
if prefix and type(k) == 'string' then
k = prefix .. k
end
host[k] = v
end
end
local _imports = setmetatable({ }, {
__mode = "k"
})
local Importer = setmetatable({
__index = function(self, key)
return _imports[self][key]
end,
__import = function(self, to_import, prefix)
if prefix == nil then
prefix = nil
end
local imports = assert(_imports[self])
for k, v in pairs(to_import) do
local _continue_0 = false
repeat
if prefix and type(k) == 'string' then
k = prefix .. k
end
imports[k] = v
if v == to_import then
_continue_0 = true
break
end
local conflict = self[k]
do
local conflict_mt = getmetatable(host)
if conflict_mt then
if conflict_mt.__import then
conflict_mt.__import(conflict, v, prefix)
end
end
end
_continue_0 = true
until true
if not _continue_0 then
break
end
end
end
}, {
__call = function(self, t)
_imports[t] = { }
setmetatable(t, self)
return t
end
})
local _1_forked
_1_forked = function(self, t)
local f = Importer(t or { })
_imports[f] = assert(_imports[self])
import_to_1_from(f, self)
return f
end
return {
Importer = Importer,
import_to_1_from = import_to_1_from,
_1_forked = _1_forked
}

47
importer.moon
View File

@ -1,47 +0,0 @@
-- This file defines Importer, which is a type of table that can import from other tables
import_to_1_from = (host, to_import, prefix=nil)->
if host_mt = getmetatable(host)
if host_mt.__import
host_mt.__import(host, to_import, prefix)
return
for k,v in pairs(to_import)
if k == to_import then k = host
if v == to_import then v = host
if prefix and type(k) == 'string'
--print "PREFIXING #{k} -> #{prefix..k}"
k = prefix..k
--print("IMPORTED (#{k})")
host[k] = v
_imports = setmetatable({}, {__mode:"k"})
Importer = setmetatable({
__index: (key)=> _imports[@][key]
__import: (to_import, prefix=nil)=>
imports = assert _imports[@]
for k,v in pairs(to_import)
if prefix and type(k) == 'string'
k = prefix..k
--print("IMPORTED (#{k})")
imports[k] = v
continue if v == to_import
conflict = @[k]
if conflict_mt = getmetatable(host)
if conflict_mt.__import
conflict_mt.__import(conflict, v, prefix)
--__newindex: (k,v)=>
-- print("DEFINED (#{k})")
-- rawset(@, k, v)
}, {
__call: (t)=>
_imports[t] = {}
setmetatable(t, @)
return t
})
_1_forked = (t)=>
f = Importer(t or {})
_imports[f] = assert _imports[@]
import_to_1_from(f, @)
return f
return {:Importer, :import_to_1_from, :_1_forked}

2
lib/consolecolor.nom
View File

@ -18,7 +18,7 @@ $colors = {
for $name = $colornum in $colors:
$colornum = "\$colornum"
$compile.action.$name =
$(COMPILE RULES).$name =
for ($compile $text):
if $text:
return (Lua "('\\027[\($colornum)m'..\($text as lua expr)..'\\027[0m')")

4
lib/file_hash.nom
View File

@ -2,8 +2,8 @@
#
This file defines some actions for hashing files and looking up files by hash.
use "lib/os.nom"
use "lib/base64.nom"
use "lib/os"
use "lib/base64"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
lib/object.nom
View File

@ -108,7 +108,7 @@ test:
return inst
end,
})
_ENV[class.name:as_lua_id()] = class
\(nomsu environment name)[class.name:as_lua_id()] = class
class.__index = class
class.class = class
class.__tostring = function(inst)

9
lib/os.nom
View File

@ -2,21 +2,12 @@
#
This file defines some actions that interact with the operating system and filesystem.
test:
assume (nomsu files for "core")
externally (files for $path) means:
$files = (=lua "Files.list(\$path)")
if $files:
$files = (List $files)
return $files
externally (nomsu files for $path) means:
for $nomsupath in ($package.nomsupath, all matches of "[^;]+"):
$files = (files for "\($nomsupath)/\$path")
if $files:
return $files
externally (=sh $cmd) means:
lua> ("
local result = io.popen(\$cmd)

4
lib/things.nom
View File

@ -5,7 +5,6 @@
test:
an (Empty) is a thing
a (Dog) is a thing:
[$it, $its] = [Dog, Dog]
($its, set up) means:
$its.barks or= 0
@ -37,7 +36,6 @@ test:
assume (($d, bark) == "Bark!")
a (Corgi) is a thing:
[$it, $its] = [Corgi, Corgi]
$it [set up, gets pissed off] like a (Dog)
($it, as text) means "Dogloaf \{: for $k = $v in $it: add $k = $v}"
($its, sploot) means "sploooot"
@ -61,7 +59,6 @@ test:
assume (($d, bark) == "Bark! Bark!")
a (Vec) is a thing with {.x, .y}:
$its = (Vec)
($its, + $other) means (Vec {.x = ($its.x + $other.x), .y = ($its.y + $other.y)})
assume ((Vec {.x = 1, .y = 2}) + (Vec {.x = 10, .y = 10})) ==
@ -145,6 +142,7 @@ externally (a class named $classname with $members $(initialize $)) means:
(
Lua ("
, function(\$class_id)
local it, its = \$class_id, \$class_id;
\$body_lua
end
")

183
nomsu.lua
View File

@ -1,70 +1,19 @@
if NOMSU_VERSION and NOMSU_PREFIX then
package.path = tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(NOMSU_VERSION) .. "/?.lua;" .. package.path
package.cpath = tostring(NOMSU_PREFIX) .. "/lib/nomsu/" .. tostring(NOMSU_VERSION) .. "/?.so;" .. package.cpath
end
local EXIT_SUCCESS, EXIT_FAILURE = 0, 1
if _VERSION == "Lua 5.1" and not jit then
print("Sorry, Nomsu does not run on Lua 5.1. Please use LuaJIT 2+ or Lua 5.2+")
os.exit(EXIT_FAILURE)
end
if NOMSU_VERSION and NOMSU_PREFIX then
local ver_bits
do
local _accum_0 = { }
local _len_0 = 1
for ver_bit in NOMSU_VERSION:gmatch("[0-9]+") do
_accum_0[_len_0] = ver_bit
_len_0 = _len_0 + 1
end
ver_bits = _accum_0
end
local partial_vers
do
local _accum_0 = { }
local _len_0 = 1
for i = #ver_bits, 1, -1 do
_accum_0[_len_0] = table.concat(ver_bits, '.', 1, i)
_len_0 = _len_0 + 1
end
partial_vers = _accum_0
end
package.path = table.concat((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #partial_vers do
local v = partial_vers[_index_0]
_accum_0[_len_0] = tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(v) .. "/?.lua"
_len_0 = _len_0 + 1
end
return _accum_0
end)(), ";") .. ";" .. package.path
package.cpath = table.concat((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #partial_vers do
local v = partial_vers[_index_0]
_accum_0[_len_0] = tostring(NOMSU_PREFIX) .. "/lib/nomsu/" .. tostring(v) .. "/?.so"
_len_0 = _len_0 + 1
end
return _accum_0
end)(), ";") .. ";" .. package.cpath
package.nomsupath = table.concat((function()
local _accum_0 = { }
local _len_0 = 1
for _index_0 = 1, #partial_vers do
local v = partial_vers[_index_0]
_accum_0[_len_0] = tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(v)
_len_0 = _len_0 + 1
end
return _accum_0
end)(), ";") .. ";."
else
package.nomsupath = "."
end
local usage = [=[Nomsu Compiler
Usage: (nomsu | lua nomsu.lua | moon nomsu.moon) [-V version] [--help | -h] [--version] [-O optimization level] [-v] [-c] [-s] [-d debugger] [--no-core] [(file | -t tool | -e "nomsu code..." | -m files... [--]) [nomsu args...]]
Usage: (nomsu | lua nomsu.lua | moon nomsu.moon) [-V version] [--help | -h] [--version] [-O optimization level] [-v] [-c] [-s] [-d debugger] [--no-core] [(file | -t tool | -e "nomsu code..." | files... -- ) [nomsu args...]]
OPTIONS
-t <tool> Run a tool.
-e Execute the specified string.
-m Run multiple files (all extra arguments).
-O <level> Run the compiler with the given optimization level (>0: use precompiled .lua versions of Nomsu files, when available).
-v Verbose: print compiled lua code.
-c Compile the input files into a .lua files.
@ -96,21 +45,20 @@ do
local _obj_0 = require('containers')
List, Dict, Text = _obj_0.List, _obj_0.Dict, _obj_0.Text
end
local nomsu_environment = require('nomsu_environment')
if not arg or debug.getinfo(2).func == require then
return nomsu_environment
end
local sep = "\3"
local parser = re.compile([[ args <- {| (flag %sep)*
(("-e" %sep {:execute: {[^%sep]+} :} %sep)
/ {:files: {|
("-t" %sep {~ {[^%sep]+} -> "nomsu://tools/%1.nom" ~} %sep
/ "-m" %sep (!("--" %sep) {[^%sep]+} %sep)* ("--" %sep)?
/ {[^%sep]+} %sep
/ {~ '' %sep? -> 'nomsu://tools/repl.nom' ~}) |} :})
{:files: {|
( ("-m" %sep)? (!("--" %sep) file)* ("--" %sep)
/ file
/ {~ '' %sep? -> 'nomsu://tools/repl.nom' ~}) |} :}
{:nomsu_args: {| (nomsu_flag %sep)* {:extras: {| ({[^%sep]+} %sep)* |} :} |} :}
|} !.
file <-
( "-e" %sep ({[^%sep]+} -> spoof) %sep
/ "-t" %sep {~ {[^%sep]+} -> "nomsu://tools/%1.nom" ~} %sep
/ {[^%sep]+} %sep)
flag <- longflag / shortflag / "-" shortboolflag+
longflag <-
{:help: "--help" %true :}
@ -132,7 +80,8 @@ local parser = re.compile([[ args <- {| (flag %sep)*
]], {
["true"] = lpeg.Cc(true),
number = lpeg.R("09") ^ 1 / tonumber,
sep = lpeg.P(sep)
sep = lpeg.P(sep),
spoof = Files.spoof
})
local arg_string = table.concat(arg, sep) .. sep
local args = parser:match(arg_string)
@ -147,74 +96,62 @@ for _index_0 = 1, #_list_0 do
nomsu_args[argpair.key] = argpair.value
end
nomsu_args.extras = List(args.nomsu_args.extras or { })
local optimization = tonumber(args.optimization or 1)
local nomsupath = { }
if NOMSU_VERSION and NOMSU_PREFIX then
if optimization > 0 then
table.insert(nomsupath, tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(NOMSU_VERSION) .. "/?.lua")
table.insert(nomsupath, tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(NOMSU_VERSION) .. "/?/init.lua")
end
table.insert(nomsupath, tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(NOMSU_VERSION) .. "/?.nom")
table.insert(nomsupath, tostring(NOMSU_PREFIX) .. "/share/nomsu/" .. tostring(NOMSU_VERSION) .. "/?/init.nom")
end
if NOMSU_PACKAGEPATH then
if optimization > 0 then
table.insert(nomsupath, tostring(NOMSU_PACKAGEPATH) .. "/nomsu/?.lua")
table.insert(nomsupath, tostring(NOMSU_PACKAGEPATH) .. "/nomsu/?/init.lua")
end
table.insert(nomsupath, tostring(NOMSU_PACKAGEPATH) .. "/nomsu/?.nom")
table.insert(nomsupath, tostring(NOMSU_PACKAGEPATH) .. "/nomsu/?/init.nom")
end
if optimization > 0 then
table.insert(nomsupath, "./?.lua")
table.insert(nomsupath, "./?/init.lua")
end
table.insert(nomsupath, "./?.nom")
table.insert(nomsupath, "./?/init.nom")
package.nomsupath = table.concat(nomsupath, ";")
local nomsu_environment = require('nomsu_environment')
nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
nomsu_environment.OPTIMIZATION = tonumber(args.optimization or 1)
nomsu_environment.OPTIMIZATION = optimization
nomsu_environment.NOMSU_PACKAGEPATH = NOMSU_PACKAGEPATH
nomsu_environment.NOMSU_PREFIX = NOMSU_PREFIX
local run
run = function()
if not (args.no_core) then
for nomsupath in package.nomsupath:gmatch("[^;]+") do
local _continue_0 = false
repeat
local files = Files.list(nomsupath .. "/core")
if not (files) then
_continue_0 = true
break
end
for _index_0 = 1, #files do
local _continue_1 = false
repeat
local f = files[_index_0]
if not (f:match("%.nom$")) then
_continue_1 = true
break
end
nomsu_environment.run_file_1_in(f, nomsu_environment, nomsu_environment.OPTIMIZATION)
_continue_1 = true
until true
if not _continue_1 then
break
end
end
_continue_0 = true
until true
if not _continue_0 then
break
end
end
nomsu_environment:export("core")
end
if args.version then
nomsu_environment.run_1_in("say (Nomsu version)", nomsu_environment)
nomsu_environment:run("say (Nomsu version)")
os.exit(EXIT_SUCCESS)
end
local input_files = { }
if args.execute then
table.insert(input_files, Files.spoof("<input command>", args.execute))
end
if args.files then
local _list_1 = args.files
for _index_0 = 1, #_list_1 do
local f = _list_1[_index_0]
local files
do
local nomsu_name = f:match("^nomsu://(.*)")
local nomsu_name = f:match("^nomsu://(.*)%.nom")
if nomsu_name then
for nomsupath in package.nomsupath:gmatch("[^;]+") do
files = Files.list(nomsupath .. "/" .. nomsu_name)
if files then
break
end
local path, err = package.searchpath(nomsu_name, package.nomsupath, "/")
if not path then
error(err)
end
table.insert(input_files, path)
else
files = Files.list(f)
table.insert(input_files, f)
end
end
if not (files and #files > 0) then
error("Could not find: '" .. tostring(f) .. "'")
end
for _index_1 = 1, #files do
local filename = files[_index_1]
table.insert(input_files, filename)
end
end
end
for _index_0 = 1, #input_files do
@ -241,13 +178,13 @@ run = function()
}
end
for chunk_no, chunk in ipairs(tree) do
local lua = nomsu_environment.compile(chunk)
local lua = nomsu_environment:compile(chunk)
lua:declare_locals()
lua:prepend((chunk_no > 1) and '\n' or '', "-- File " .. tostring(filename) .. " chunk #" .. tostring(chunk_no) .. "\n")
if args.verbose then
print(lua:text())
end
nomsu_environment.run_1_in(chunk, nomsu_environment)
nomsu_environment:run(chunk)
output:write(lua:text(), "\n")
end
print(("Compiled %-25s -> %s"):format(filename, filename:gsub("%.nom$", ".lua")))
@ -263,14 +200,18 @@ run = function()
}
end
for chunk_no, chunk in ipairs(tree) do
local lua = nomsu_environment.compile(chunk)
local lua = nomsu_environment:compile(chunk)
lua:declare_locals()
lua:prepend((chunk_no > 1) and '\n' or '', "-- File " .. tostring(filename) .. " chunk #" .. tostring(chunk_no) .. "\n")
print(lua:text())
nomsu_environment.run_1_in(lua, nomsu_environment)
nomsu_environment:run(lua)
end
else
nomsu_environment.run_file_1_in(filename, nomsu_environment, 0)
local f = Files.read(filename)
if filename:match("%.lua$") then
f = LuaCode:from(Source(filename, 1, #f), f)
end
nomsu_environment:run(f)
end
end
end

111
nomsu.moon
View File

@ -1,6 +1,10 @@
#!/usr/bin/env moon
-- This file contains the command-line Nomsu runner.
if NOMSU_VERSION and NOMSU_PREFIX
package.path = "#{NOMSU_PREFIX}/share/nomsu/#{NOMSU_VERSION}/?.lua;"..package.path
package.cpath = "#{NOMSU_PREFIX}/lib/nomsu/#{NOMSU_VERSION}/?.so;"..package.cpath
EXIT_SUCCESS, EXIT_FAILURE = 0, 1
if _VERSION == "Lua 5.1" and not jit
@ -8,24 +12,14 @@ if _VERSION == "Lua 5.1" and not jit
print("Sorry, Nomsu does not run on Lua 5.1. Please use LuaJIT 2+ or Lua 5.2+")
os.exit(EXIT_FAILURE)
if NOMSU_VERSION and NOMSU_PREFIX
ver_bits = [ver_bit for ver_bit in NOMSU_VERSION\gmatch("[0-9]+")]
partial_vers = [table.concat(ver_bits,'.',1,i) for i=#ver_bits,1,-1]
package.path = table.concat(["#{NOMSU_PREFIX}/share/nomsu/#{v}/?.lua" for v in *partial_vers],";")..";"..package.path
package.cpath = table.concat(["#{NOMSU_PREFIX}/lib/nomsu/#{v}/?.so" for v in *partial_vers],";")..";"..package.cpath
package.nomsupath = table.concat(["#{NOMSU_PREFIX}/share/nomsu/#{v}" for v in *partial_vers],";")..";."
else
package.nomsupath = "."
usage = [=[
Nomsu Compiler
Usage: (nomsu | lua nomsu.lua | moon nomsu.moon) [-V version] [--help | -h] [--version] [-O optimization level] [-v] [-c] [-s] [-d debugger] [--no-core] [(file | -t tool | -e "nomsu code..." | -m files... [--]) [nomsu args...]]
Usage: (nomsu | lua nomsu.lua | moon nomsu.moon) [-V version] [--help | -h] [--version] [-O optimization level] [-v] [-c] [-s] [-d debugger] [--no-core] [(file | -t tool | -e "nomsu code..." | files... -- ) [nomsu args...]]
OPTIONS
-t <tool> Run a tool.
-e Execute the specified string.
-m Run multiple files (all extra arguments).
-O <level> Run the compiler with the given optimization level (>0: use precompiled .lua versions of Nomsu files, when available).
-v Verbose: print compiled lua code.
-c Compile the input files into a .lua files.
@ -47,29 +41,24 @@ if not ok
os.exit(EXIT_FAILURE)
Files = require "files"
Errhand = require "error_handling"
--NomsuCompiler = require "nomsu_compiler"
{:NomsuCode, :LuaCode, :Source} = require "code_obj"
--{:Importer, :import_to_1_from, :_1_forked} = require 'importer'
{:List, :Dict, :Text} = require 'containers'
--SyntaxTree = require "syntax_tree"
nomsu_environment = require('nomsu_environment')
-- If this file was reached via require(), then just return the Nomsu compiler
if not arg or debug.getinfo(2).func == require
return nomsu_environment
sep = "\3"
parser = re.compile([[
args <- {| (flag %sep)*
(("-e" %sep {:execute: {[^%sep]+} :} %sep)
/ {:files: {|
("-t" %sep {~ {[^%sep]+} -> "nomsu://tools/%1.nom" ~} %sep
/ "-m" %sep (!("--" %sep) {[^%sep]+} %sep)* ("--" %sep)?
/ {[^%sep]+} %sep
/ {~ '' %sep? -> 'nomsu://tools/repl.nom' ~}) |} :})
{:files: {|
( ("-m" %sep)? (!("--" %sep) file)* ("--" %sep)
/ file
/ {~ '' %sep? -> 'nomsu://tools/repl.nom' ~}) |} :}
{:nomsu_args: {| (nomsu_flag %sep)* {:extras: {| ({[^%sep]+} %sep)* |} :} |} :}
|} !.
file <-
( "-e" %sep ({[^%sep]+} -> spoof) %sep
/ "-t" %sep {~ {[^%sep]+} -> "nomsu://tools/%1.nom" ~} %sep
/ {[^%sep]+} %sep)
flag <- longflag / shortflag / "-" shortboolflag+
longflag <-
{:help: "--help" %true :}
@ -89,7 +78,8 @@ parser = re.compile([[
nomsu_shortboolflag <- {| {:key: [a-zA-Z] :} {:value: %true :} |}
nomsu_longflag <- '--' {| {:key: [^%sep=]+ :} {:value: ('=' {[^%sep]+}) / %true :} |}
]], {
true:lpeg.Cc(true), number:lpeg.R("09")^1/tonumber, sep:lpeg.P(sep)
true:lpeg.Cc(true), number:lpeg.R("09")^1/tonumber, sep:lpeg.P(sep),
spoof: Files.spoof
})
arg_string = table.concat(arg, sep)..sep
args = parser\match(arg_string)
@ -100,38 +90,53 @@ nomsu_args = Dict{}
for argpair in *args.nomsu_args
nomsu_args[argpair.key] = argpair.value
nomsu_args.extras = List(args.nomsu_args.extras or {})
optimization = tonumber(args.optimization or 1)
nomsupath = {}
if NOMSU_VERSION and NOMSU_PREFIX
if optimization > 0
table.insert nomsupath, "#{NOMSU_PREFIX}/share/nomsu/#{NOMSU_VERSION}/?.lua"
table.insert nomsupath, "#{NOMSU_PREFIX}/share/nomsu/#{NOMSU_VERSION}/?/init.lua"
table.insert nomsupath, "#{NOMSU_PREFIX}/share/nomsu/#{NOMSU_VERSION}/?.nom"
table.insert nomsupath, "#{NOMSU_PREFIX}/share/nomsu/#{NOMSU_VERSION}/?/init.nom"
if NOMSU_PACKAGEPATH
if optimization > 0
table.insert nomsupath, "#{NOMSU_PACKAGEPATH}/nomsu/?.lua"
table.insert nomsupath, "#{NOMSU_PACKAGEPATH}/nomsu/?/init.lua"
table.insert nomsupath, "#{NOMSU_PACKAGEPATH}/nomsu/?.nom"
table.insert nomsupath, "#{NOMSU_PACKAGEPATH}/nomsu/?/init.nom"
if optimization > 0
table.insert nomsupath, "./?.lua"
table.insert nomsupath, "./?/init.lua"
table.insert nomsupath, "./?.nom"
table.insert nomsupath, "./?/init.nom"
package.nomsupath = table.concat(nomsupath, ";")
nomsu_environment = require('nomsu_environment')
nomsu_environment.COMMAND_LINE_ARGS = nomsu_args
nomsu_environment.OPTIMIZATION = tonumber(args.optimization or 1)
nomsu_environment.OPTIMIZATION = optimization
nomsu_environment.NOMSU_PACKAGEPATH = NOMSU_PACKAGEPATH
nomsu_environment.NOMSU_PREFIX = NOMSU_PREFIX
run = ->
unless args.no_core
for nomsupath in package.nomsupath\gmatch("[^;]+")
files = Files.list(nomsupath.."/core")
continue unless files
for f in *files
continue unless f\match("%.nom$")
nomsu_environment.run_file_1_in f, nomsu_environment, nomsu_environment.OPTIMIZATION
nomsu_environment\export("core")
if args.version
nomsu_environment.run_1_in("say (Nomsu version)", nomsu_environment)
nomsu_environment\run("say (Nomsu version)")
os.exit(EXIT_SUCCESS)
input_files = {}
if args.execute
table.insert input_files, Files.spoof("<input command>", args.execute)
if args.files
for f in *args.files
local files
if nomsu_name = f\match("^nomsu://(.*)")
for nomsupath in package.nomsupath\gmatch("[^;]+")
files = Files.list(nomsupath.."/"..nomsu_name)
break if files
if nomsu_name = f\match("^nomsu://(.*)%.nom")
path, err = package.searchpath(nomsu_name, package.nomsupath, "/")
if not path then error(err)
table.insert input_files, path
else
files = Files.list(f)
unless files and #files > 0
error("Could not find: '#{f}'")
for filename in *files
table.insert input_files, filename
table.insert input_files, f
for filename in *input_files
if args.check_syntax
@ -150,11 +155,11 @@ run = ->
tree = nomsu_environment._1_parsed(code)
tree = {tree} unless tree.type == 'FileChunks'
for chunk_no, chunk in ipairs tree
lua = nomsu_environment.compile(chunk)
lua = nomsu_environment\compile(chunk)
lua\declare_locals!
lua\prepend((chunk_no > 1) and '\n' or '', "-- File #{filename} chunk ##{chunk_no}\n")
if args.verbose then print(lua\text!)
nomsu_environment.run_1_in(chunk, nomsu_environment)
nomsu_environment\run(chunk)
output\write(lua\text!, "\n")
print ("Compiled %-25s -> %s")\format(filename, filename\gsub("%.nom$", ".lua"))
output\close!
@ -165,14 +170,18 @@ run = ->
tree = nomsu_environment._1_parsed(code)
tree = {tree} unless tree.type == 'FileChunks'
for chunk_no, chunk in ipairs tree
lua = nomsu_environment.compile(chunk)
lua = nomsu_environment\compile(chunk)
lua\declare_locals!
lua\prepend((chunk_no > 1) and '\n' or '', "-- File #{filename} chunk ##{chunk_no}\n")
print(lua\text!)
nomsu_environment.run_1_in(lua, nomsu_environment)
nomsu_environment\run(lua)
else
-- Just run the file
nomsu_environment.run_file_1_in(filename, nomsu_environment, 0)
f = Files.read(filename)
if filename\match("%.lua$")
f = LuaCode\from(Source(filename, 1, #f), f)
nomsu_environment\run(f)
--nomsu_environment.run_file_1_in(filename, nomsu_environment, 0)
debugger = if args.debugger == "nil" then {}
else require(args.debugger or 'error_handling')

174
nomsu_compiler.lua
View File

@ -1,17 +1,8 @@
local lpeg = require('lpeg')
local R, P, S
R, P, S = lpeg.R, lpeg.P, lpeg.S
local re = require('re')
local List, Dict, Text
do
local _obj_0 = require('containers')
List, Dict, Text = _obj_0.List, _obj_0.Dict, _obj_0.Text
end
local insert, remove, concat
do
local _obj_0 = table
insert, remove, concat = _obj_0.insert, _obj_0.remove, _obj_0.concat
end
local unpack = unpack or table.unpack
local match, sub, gsub, format, byte, find
do
@ -24,23 +15,7 @@ do
LuaCode, Source = _obj_0.LuaCode, _obj_0.Source
end
local SyntaxTree = require("syntax_tree")
local Importer, import_to_1_from, _1_forked
do
local _obj_0 = require('importer')
Importer, import_to_1_from, _1_forked = _obj_0.Importer, _obj_0.import_to_1_from, _obj_0._1_forked
end
local Files = require("files")
table.map = function(t, fn)
return setmetatable((function()
local _accum_0 = { }
local _len_0 = 1
for _, v in ipairs(t) do
_accum_0[_len_0] = fn(v)
_len_0 = _len_0 + 1
end
return _accum_0
end)(), getmetatable(t))
end
local pretty_error = require("pretty_errors")
local compile_error
compile_error = function(source, err_msg, hint)
@ -68,130 +43,22 @@ compile_error = function(source, err_msg, hint)
})
return error(err_str, 0)
end
local re = require('re')
local math_expression = re.compile([[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]])
local MAX_LINE = 80
local compile = setmetatable({
action = Importer({
[""] = function(compile, fn, ...)
local lua = LuaCode()
local fn_lua = compile(fn)
lua:add(fn_lua)
if not (fn_lua:text():match("^%(.*%)$") or fn_lua:text():match("^[_a-zA-Z][_a-zA-Z0-9.]*$")) then
lua:parenthesize()
end
lua:add("(")
for i = 1, select('#', ...) do
if i > 1 then
lua:add(", ")
end
lua:add(compile((select(i, ...))))
end
lua:add(")")
return lua
end,
["Lua"] = function(compile, code)
if not code then
return LuaCode("LuaCode()")
end
if code.type ~= "Text" then
return LuaCode("LuaCode:from(", tostring(code.source):as_lua(), ", ", compile(code), ")")
end
local operate_on_text
operate_on_text = function(text)
local lua = LuaCode:from(text.source, "LuaCode:from(", tostring(text.source):as_lua())
for _index_0 = 1, #text do
local bit = text[_index_0]
local bit_lua
if type(bit) == "string" then
bit_lua = bit:as_lua()
elseif bit.type == "Text" then
bit_lua = operate_on_text(bit)
elseif bit.type == "Block" then
bit_lua = LuaCode:from(bit.source, "(function()", "\n local _lua = LuaCode:from(", tostring(bit.source):as_lua(), ")", "\n local function add(...) _lua:add(...) end", "\n local function join_with(glue)", "\n local old_bits = _lua.bits", "\n _lua = LuaCode:from(_lua.source)", "\n _lua:concat_add(old_bits, glue)", "\n end", "\n ", compile(bit), "\n return _lua", "\nend)()")
else
bit_lua = compile(bit)
end
local bit_leading_len = #(bit_lua:match("^[^\n]*"))
lua:add(lua:trailing_line_len() + bit_leading_len > MAX_LINE and ",\n " or ", ")
lua:add(bit_lua)
end
lua:add(")")
return lua
end
return operate_on_text(code)
end,
["lua >"] = function(compile, code)
if code.type ~= "Text" then
return code
end
local operate_on_text
operate_on_text = function(text)
local lua = LuaCode:from(text.source)
for _index_0 = 1, #text do
local bit = text[_index_0]
if type(bit) == "string" then
lua:add(bit)
elseif bit.type == "Text" then
lua:add(operate_on_text(bit))
else
lua:add(compile(bit))
end
end
return lua
end
return operate_on_text(code)
end,
["= lua"] = function(compile, code)
return compile.action["lua >"](compile, code)
end,
["use"] = function(compile, path)
return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION)")
end,
["use 1 with prefix"] = function(compile, path, prefix)
return LuaCode("run_file_1_in(" .. tostring(compile(path)) .. ", _ENV, OPTIMIZATION, ", compile(prefix), ")")
end,
["test"] = function(compile, body)
if not (body.type == 'Block') then
compile_error(body, "This should be a Block")
end
local test_nomsu = body:get_source_code():match(":[ ]*(.*)")
do
local indent = test_nomsu:match("\n([ ]*)")
if indent then
test_nomsu = test_nomsu:gsub("\n" .. indent, "\n")
end
end
local test_text = compile(SyntaxTree({
type = "Text",
source = body.source,
test_nomsu
}))
return LuaCode("TESTS[" .. tostring(tostring(body.source):as_lua()) .. "] = ", test_text)
end,
["is jit"] = function(compile, code)
return LuaCode("jit")
end,
["Lua version"] = function(compile, code)
return LuaCode("_VERSION")
end,
["nomsu environment"] = function(compile)
return LuaCode("_ENV")
end
})
}, {
__import = import_to_1_from,
__call = function(compile, tree)
local compile
compile = function(self, tree)
local _exp_0 = tree.type
if "Action" == _exp_0 then
local stub = tree.stub
local compile_action = compile.action[stub]
local compile_action = self.COMPILE_RULES[stub]
if not compile_action and math_expression:match(stub) then
local lua = LuaCode:from(tree.source)
for i, tok in ipairs(tree) do
if type(tok) == 'string' then
lua:add(tok)
else
local tok_lua = compile(tok)
local tok_lua = self:compile(tok)
if tok.type == "Action" then
tok_lua:parenthesize()
end
@ -217,7 +84,7 @@ local compile = setmetatable({
end
args = _accum_0
end
local ret = compile_action(compile, unpack(args))
local ret = compile_action(self, unpack(args))
if ret == nil then
local info = debug.getinfo(compile_action, "S")
local filename = Source:from_string(info.source).filename
@ -228,13 +95,13 @@ local compile = setmetatable({
return ret
end
if ret ~= tree then
return compile(ret)
return self:compile(ret)
end
end
local lua = LuaCode:from(tree.source)
lua:add((stub):as_lua_id(), "(")
for argnum, arg in ipairs(tree:get_args()) do
local arg_lua = compile(arg)
local arg_lua = self:compile(arg)
if arg.type == "Block" then
arg_lua = LuaCode:from(arg.source, "(function()\n ", arg_lua, "\nend)()")
end
@ -249,7 +116,7 @@ local compile = setmetatable({
return lua
elseif "MethodCall" == _exp_0 then
local lua = LuaCode:from(tree.source)
local target_lua = compile(tree[1])
local target_lua = self:compile(tree[1])
local target_text = target_lua:text()
if not (target_text:match("^%(.*%)$") or target_text:match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or tree[1].type == "IndexChain") then
target_lua:parenthesize()
@ -261,7 +128,7 @@ local compile = setmetatable({
lua:add(target_lua, ":")
lua:add((tree[i].stub):as_lua_id(), "(")
for argnum, arg in ipairs(tree[i]:get_args()) do
local arg_lua = compile(arg)
local arg_lua = self:compile(arg)
if arg.type == "Block" then
arg_lua = LuaCode:from(arg.source, "(function()\n ", arg_lua, "\nend)()")
end
@ -283,7 +150,7 @@ local compile = setmetatable({
if type(x) == 'number' then
return tostring(x)
elseif SyntaxTree:is_instance(x) then
return compile(x)
return self:compile(x)
elseif Source:is_instance(x) then
return tostring(x):as_lua()
else
@ -319,7 +186,7 @@ local compile = setmetatable({
if i > 1 then
lua:add("\n")
end
lua:add(compile(line))
lua:add(self:compile(line))
end
return lua
elseif "Text" == _exp_0 then
@ -351,7 +218,7 @@ local compile = setmetatable({
end
string_buffer = ""
end
local bit_lua = compile(bit)
local bit_lua = self:compile(bit)
if bit.type == "Block" and #bit == 1 then
bit = bit[1]
end
@ -393,7 +260,7 @@ local compile = setmetatable({
lua:add(" + ")
end
lua:add(tree.type, "(function(", (tree.type == 'List' and "add" or ("add, " .. ("add 1 ="):as_lua_id())), ")")
lua:add("\n ", compile(tree[i]), "\nend)")
lua:add("\n ", self:compile(tree[i]), "\nend)")
chunks = chunks + 1
i = i + 1
else
@ -406,7 +273,7 @@ local compile = setmetatable({
if tree[i].type == "Block" then
break
end
local item_lua = compile(tree[i])
local item_lua = self:compile(tree[i])
if item_lua:text():match("^%.[a-zA-Z_]") then
item_lua = item_lua:text():sub(2)
end
@ -434,7 +301,7 @@ local compile = setmetatable({
end
return lua
elseif "Index" == _exp_0 then
local key_lua = compile(tree[1])
local key_lua = self:compile(tree[1])
local key_str = match(key_lua:text(), '^"([a-zA-Z_][a-zA-Z0-9_]*)"$')
if key_str and key_str:is_lua_id() then
return LuaCode:from(tree.source, ".", key_str)
@ -452,9 +319,9 @@ local compile = setmetatable({
key
})
end
return LuaCode:from(tree.source, compile(key), "=", (tree[2] and compile(tree[2]) or "true"))
return LuaCode:from(tree.source, self:compile(key), "=", (tree[2] and self:compile(tree[2]) or "true"))
elseif "IndexChain" == _exp_0 then
local lua = compile(tree[1])
local lua = self:compile(tree[1])
if lua:text():match("['\"}]$") or lua:text():match("]=*]$") then
lua:parenthesize()
end
@ -467,7 +334,7 @@ local compile = setmetatable({
key
})
end
lua:add(compile(key))
lua:add(self:compile(key))
end
return lua
elseif "Number" == _exp_0 then
@ -483,8 +350,7 @@ local compile = setmetatable({
else
return error("Unknown type: " .. tostring(tree.type))
end
end
})
end
return {
compile = compile,
compile_error = compile_error

145
nomsu_compiler.moon
View File

@ -1,28 +1,13 @@
--
-- This file contains the source code of the Nomsu compiler.
-- Nomsu is a programming language that cross-compiles to Lua. It was designed to be good
-- at natural-language-like code that is highly self-modifying and flexible.
-- The only dependency is LPEG, which can be installed using "luarocks install lpeg"
-- File usage:
-- Either, in a lua/moonscript file:
-- Nomsu = require "nomsu"
-- nomsu = Nomsu()
-- nomsu:run(your_nomsu_code)
-- Or from the command line:
-- lua nomsu.lua your_file.nom
lpeg = require 'lpeg'
{:R,:P,:S} = lpeg
re = require 're'
--
{:List, :Dict, :Text} = require 'containers'
{:insert, :remove, :concat} = table
unpack or= table.unpack
{:match, :sub, :gsub, :format, :byte, :find} = string
{:LuaCode, :Source} = require "code_obj"
SyntaxTree = require "syntax_tree"
{:Importer, :import_to_1_from, :_1_forked} = require 'importer'
Files = require "files"
table.map = (t, fn)-> setmetatable([fn(v) for _,v in ipairs(t)], getmetatable(t))
-- TODO: de-duplicate this
pretty_error = require("pretty_errors")
compile_error = (source, err_msg, hint=nil)->
@ -45,110 +30,22 @@ compile_error = (source, err_msg, hint=nil)->
-- This is a bit of a hack, but this code handles arbitrarily complex
-- math expressions like 2*x + 3^2 without having to define a single
-- action for every possibility.
re = require 're'
math_expression = re.compile [[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]]
MAX_LINE = 80 -- For beautification purposes, try not to make lines much longer than this value
compile = setmetatable({
action: Importer{
[""]: (compile, fn, ...)->
lua = LuaCode!
fn_lua = compile(fn)
lua\add fn_lua
unless fn_lua\text!\match("^%(.*%)$") or fn_lua\text!\match("^[_a-zA-Z][_a-zA-Z0-9.]*$")
lua\parenthesize!
lua\add "("
for i=1,select('#',...)
lua\add(", ") if i > 1
lua\add compile((select(i, ...)))
lua\add ")"
return lua
["Lua"]: (compile, code)->
if not code
return LuaCode("LuaCode()")
if code.type != "Text"
return LuaCode("LuaCode:from(", tostring(code.source)\as_lua!, ", ", compile(code), ")")
operate_on_text = (text)->
lua = LuaCode\from(text.source, "LuaCode:from(", tostring(text.source)\as_lua!)
for bit in *text
local bit_lua
if type(bit) == "string"
bit_lua = bit\as_lua!
elseif bit.type == "Text"
bit_lua = operate_on_text(bit)
elseif bit.type == "Block"
bit_lua = LuaCode\from bit.source, "(function()",
"\n local _lua = LuaCode:from(", tostring(bit.source)\as_lua!, ")",
"\n local function add(...) _lua:add(...) end",
"\n local function join_with(glue)",
"\n local old_bits = _lua.bits",
"\n _lua = LuaCode:from(_lua.source)",
"\n _lua:concat_add(old_bits, glue)",
"\n end",
"\n ", compile(bit),
"\n return _lua",
"\nend)()"
else
bit_lua = compile(bit)
bit_leading_len = #(bit_lua\match("^[^\n]*"))
lua\add(lua\trailing_line_len! + bit_leading_len > MAX_LINE and ",\n " or ", ")
lua\add(bit_lua)
lua\add ")"
return lua
return operate_on_text code
["lua >"]: (compile, code)->
if code.type != "Text"
return code
operate_on_text = (text)->
lua = LuaCode\from(text.source)
for bit in *text
if type(bit) == "string"
lua\add bit
elseif bit.type == "Text"
lua\add(operate_on_text(bit))
else
lua\add compile(bit)
return lua
return operate_on_text code
["= lua"]: (compile, code)-> compile.action["lua >"](compile, code)
["use"]: (compile, path)-> LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION)")
["use 1 with prefix"]: (compile, path, prefix)->
LuaCode("run_file_1_in(#{compile(path)}, _ENV, OPTIMIZATION, ", compile(prefix), ")")
["test"]: (compile, body)->
unless body.type == 'Block'
compile_error(body, "This should be a Block")
test_nomsu = body\get_source_code!\match(":[ ]*(.*)")
if indent = test_nomsu\match("\n([ ]*)")
test_nomsu = test_nomsu\gsub("\n"..indent, "\n")
test_text = compile(SyntaxTree{type:"Text", source:body.source, test_nomsu})
return LuaCode "TESTS[#{tostring(body.source)\as_lua!}] = ", test_text
["is jit"]: (compile, code)-> LuaCode("jit")
["Lua version"]: (compile, code)-> LuaCode("_VERSION")
["nomsu environment"]: (compile)-> LuaCode("_ENV")
}
}, {
__import: import_to_1_from
__call: (compile, tree)->
compile = (tree)=>
switch tree.type
when "Action"
stub = tree.stub
compile_action = compile.action[stub]
compile_action = @COMPILE_RULES[stub]
if not compile_action and math_expression\match(stub)
lua = LuaCode\from(tree.source)
for i,tok in ipairs tree
if type(tok) == 'string'
lua\add tok
else
tok_lua = compile(tok)
tok_lua = @compile(tok)
-- TODO: this is overly eager, should be less aggressive
tok_lua\parenthesize! if tok.type == "Action"
lua\add tok_lua
@ -159,7 +56,7 @@ compile = setmetatable({
args = [arg for arg in *tree when type(arg) != "string"]
-- Force Lua to avoid tail call optimization for debugging purposes
-- TODO: use tail call?
ret = compile_action(compile, unpack(args))
ret = compile_action(@, unpack(args))
if ret == nil
info = debug.getinfo(compile_action, "S")
filename = Source\from_string(info.source).filename
@ -170,12 +67,12 @@ compile = setmetatable({
ret.source or= tree.source
return ret
if ret != tree
return compile(ret)
return @compile(ret)
lua = LuaCode\from(tree.source)
lua\add((stub)\as_lua_id!,"(")
for argnum, arg in ipairs tree\get_args!
arg_lua = compile(arg)
arg_lua = @compile(arg)
if arg.type == "Block"
arg_lua = LuaCode\from(arg.source, "(function()\n ", arg_lua, "\nend)()")
if lua\trailing_line_len! + #arg_lua\text! > MAX_LINE
@ -188,7 +85,7 @@ compile = setmetatable({
when "MethodCall"
lua = LuaCode\from tree.source
target_lua = compile tree[1]
target_lua = @compile tree[1]
target_text = target_lua\text!
-- TODO: this parenthesizing is maybe overly conservative
if not (target_text\match("^%(.*%)$") or target_text\match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or
@ -200,7 +97,7 @@ compile = setmetatable({
lua\add target_lua, ":"
lua\add((tree[i].stub)\as_lua_id!,"(")
for argnum, arg in ipairs tree[i]\get_args!
arg_lua = compile(arg)
arg_lua = @compile(arg)
if arg.type == "Block"
arg_lua = LuaCode\from(arg.source, "(function()\n ", arg_lua, "\nend)()")
if lua\trailing_line_len! + #arg_lua\text! > MAX_LINE
@ -218,7 +115,7 @@ compile = setmetatable({
if type(x) == 'number'
tostring(x)
elseif SyntaxTree\is_instance(x)
compile(x)
@compile(x)
elseif Source\is_instance(x)
tostring(x)\as_lua!
else x\as_lua!
@ -246,7 +143,7 @@ compile = setmetatable({
lua = LuaCode\from(tree.source)
for i, line in ipairs tree
if i > 1 then lua\add "\n"
lua\add compile(line)
lua\add @compile(line)
return lua
when "Text"
@ -270,7 +167,7 @@ compile = setmetatable({
add_bit string_buffer\sub(i, i+MAX_LINE-1)\as_lua!
string_buffer = ""
bit_lua = compile(bit)
bit_lua = @compile(bit)
if bit.type == "Block" and #bit == 1
bit = bit[1]
if bit.type == "Block"
@ -303,7 +200,7 @@ compile = setmetatable({
if tree[i].type == 'Block'
lua\add " + " if chunks > 0
lua\add tree.type, "(function(", (tree.type == 'List' and "add" or ("add, "..("add 1 =")\as_lua_id!)), ")"
lua\add "\n ", compile(tree[i]), "\nend)"
lua\add "\n ", @compile(tree[i]), "\nend)"
chunks += 1
i += 1
else
@ -313,7 +210,7 @@ compile = setmetatable({
while tree[i]
if tree[i].type == "Block"
break
item_lua = compile tree[i]
item_lua = @compile tree[i]
if item_lua\text!\match("^%.[a-zA-Z_]")
item_lua = item_lua\text!\sub(2)
if tree.type == 'Dict' and tree[i].type == 'Index'
@ -336,7 +233,7 @@ compile = setmetatable({
return lua
when "Index"
key_lua = compile(tree[1])
key_lua = @compile(tree[1])
key_str = match(key_lua\text!, '^"([a-zA-Z_][a-zA-Z0-9_]*)"$')
return if key_str and key_str\is_lua_id!
LuaCode\from tree.source, ".", key_str
@ -352,10 +249,10 @@ compile = setmetatable({
key = tree[1]
if key.type != "Index"
key = SyntaxTree{type:"Index", source:key.source, key}
return LuaCode\from tree.source, compile(key),"=",(tree[2] and compile(tree[2]) or "true")
return LuaCode\from tree.source, @compile(key),"=",(tree[2] and @compile(tree[2]) or "true")
when "IndexChain"
lua = compile(tree[1])
lua = @compile(tree[1])
if lua\text!\match("['\"}]$") or lua\text!\match("]=*]$")
lua\parenthesize!
for i=2,#tree
@ -363,7 +260,7 @@ compile = setmetatable({
-- TODO: remove this shim
if key.type != "Index"
key = SyntaxTree{type:"Index", source:key.source, key}
lua\add compile(key)
lua\add @compile(key)
return lua
when "Number"
@ -385,6 +282,4 @@ compile = setmetatable({
else
error("Unknown type: #{tree.type}")
})
return {:compile, :compile_error}

2
nomsu_decompiler.lua
View File

@ -130,7 +130,7 @@ tree_to_inline_nomsu = function(tree)
local interp_nomsu = tree_to_inline_nomsu(bit)
if bit.type ~= "Var" and bit.type ~= "List" and bit.type ~= "Dict" then
interp_nomsu:parenthesize()
elseif bit.type == "Var" and type(tree[i + 1]) == 'string' and not match(tree[i + 1], "^[ \n\t,.:;#(){}[%]]") then
elseif bit.type == "Var" and type(bit[1]) == 'string' and type(tree[i + 1]) == 'string' and not match(tree[i + 1], "^[ \n\t,.:;#(){}[%]]") then
interp_nomsu:parenthesize()
end
nomsu:add("\\", interp_nomsu)

3
nomsu_decompiler.moon
View File

@ -95,7 +95,8 @@ tree_to_inline_nomsu = (tree)->
interp_nomsu = tree_to_inline_nomsu(bit)
if bit.type != "Var" and bit.type != "List" and bit.type != "Dict"
interp_nomsu\parenthesize!
elseif bit.type == "Var" and type(tree[i+1]) == 'string' and not match(tree[i+1], "^[ \n\t,.:;#(){}[%]]")
elseif bit.type == "Var" and type(bit[1]) == 'string' and
type(tree[i+1]) == 'string' and not match(tree[i+1], "^[ \n\t,.:;#(){}[%]]")
interp_nomsu\parenthesize!
nomsu\add "\\", interp_nomsu
nomsu = NomsuCode\from(tree.source)

222
nomsu_environment.lua
View File

@ -3,11 +3,6 @@ do
local _obj_0 = require("code_obj")
NomsuCode, LuaCode, Source = _obj_0.NomsuCode, _obj_0.LuaCode, _obj_0.Source
end
local Importer, import_to_1_from, _1_forked
do
local _obj_0 = require('importer')
Importer, import_to_1_from, _1_forked = _obj_0.Importer, _obj_0.import_to_1_from, _obj_0._1_forked
end
local List, Dict, Text
do
local _obj_0 = require('containers')
@ -24,26 +19,27 @@ make_tree = function(tree, userdata)
tree = SyntaxTree(tree)
return tree
end
table.map = function(t, fn)
return setmetatable((function()
local _accum_0 = { }
local _len_0 = 1
for _, v in ipairs(t) do
_accum_0[_len_0] = fn(v)
_len_0 = _len_0 + 1
end
return _accum_0
end)(), getmetatable(t))
end
local Parsers = { }
local max_parser_version = 0
for version = 1, 999 do
local peg_file
if package.nomsupath then
for path in package.nomsupath:gmatch("[^;]+") do
local _continue_0 = false
repeat
if path == "." and package.nomsupath ~= "." then
_continue_0 = true
break
end
peg_file = io.open(path .. "/nomsu." .. tostring(version) .. ".peg")
if peg_file then
break
end
_continue_0 = true
until true
if not _continue_0 then
break
local pegpath = package.nomsupath:gsub("%.nom", ".peg")
do
local path = package.searchpath("nomsu." .. tostring(version), pegpath, "/")
if path then
peg_file = io.open(path)
end
end
else
@ -68,8 +64,10 @@ do
compile, compile_error = _obj_0.compile, _obj_0.compile_error
end
local _currently_running_files = List({ })
local nomsu_environment = Importer({
NOMSU_COMPILER_VERSION = 12,
local nomsu_environment
local _module_imports = { }
nomsu_environment = setmetatable({
NOMSU_COMPILER_VERSION = 13,
NOMSU_SYNTAX_VERSION = max_parser_version,
next = next,
unpack = unpack or table.unpack,
@ -129,14 +127,12 @@ local nomsu_environment = Importer({
NomsuCode_from = (function(src, ...)
return NomsuCode:from(src, ...)
end),
SOURCE_MAP = Importer({ }),
SOURCE_MAP = { },
getfenv = getfenv,
_1_as_nomsu = tree_to_nomsu,
_1_as_inline_nomsu = tree_to_inline_nomsu,
compile = compile,
_1_as_lua = compile,
compile_error_at = compile_error,
_1_forked = _1_forked,
import_to_1_from = import_to_1_from,
exit = os.exit,
quit = os.exit,
_1_parsed = function(nomsu_code, syntax_version)
@ -208,19 +204,87 @@ local nomsu_environment = Importer({
end
return tree
end,
run_1_in = function(to_run, environment)
load_module = function(self, package_name)
local path
if package_name:match("%.nom$") or package_name:match("%.lua") then
path = package_name
else
local err
path, err = package.searchpath(package_name, package.nomsupath, "/")
if not path then
error(err)
end
end
path = path:gsub("^%./", "")
do
local ret = package.loaded[package_name] or package.loaded[path]
if ret then
return ret
end
end
if _currently_running_files:has(path) then
local i = _currently_running_files:index_of(path)
_currently_running_files:add(path)
local circle = _currently_running_files:from_1_to(i, -1)
error("Circular import detected:\n " .. circle:joined_with("\n..imports "))
end
local mod = self:new_environment()
mod.MODULE_NAME = package_name
mod.TESTS = Dict({ })
local code = Files.read(path)
if path:match("%.lua$") then
code = LuaCode:from(Source(path, 1, #code), code)
else
code = NomsuCode:from(Source(path, 1, #code), code)
end
_currently_running_files:add(path)
assert(mod[jit and "_G" or "_ENV"] == mod)
mod:run(code)
assert(mod[jit and "_G" or "_ENV"] == mod)
_currently_running_files:pop()
package.loaded[package_name] = mod
package.loaded[path] = mod
return mod
end,
use = function(self, package_name)
local mod = self:load_module(package_name)
assert(mod[jit and "_G" or "_ENV"] == mod)
local imports = assert(_module_imports[self])
for k, v in pairs(mod) do
imports[k] = v
end
assert(mod[jit and "_G" or "_ENV"] == mod)
return mod
end,
export = function(self, package_name)
local mod = self:load_module(package_name)
assert(mod[jit and "_G" or "_ENV"] == mod)
local imports = assert(_module_imports[self])
for k, v in pairs(_module_imports[mod]) do
imports[k] = v
end
for k, v in pairs(mod) do
if k ~= "_G" and k ~= "_ENV" then
self[k] = v
end
end
assert(mod[jit and "_G" or "_ENV"] == mod)
return mod
end,
run = function(self, to_run)
if not to_run then
error("Need both something to run and an environment")
end
if type(to_run) == 'string' then
local filename = Files.spoof(to_run)
to_run = NomsuCode:from(Source(filename, 1, #to_run), to_run)
local ret = environment.run_1_in(to_run, environment)
return ret
return self:run(to_run)
elseif NomsuCode:is_instance(to_run) then
local tree = environment._1_parsed(to_run)
local tree = self._1_parsed(to_run)
if tree == nil then
return nil
end
local ret = environment.run_1_in(tree, environment)
return ret
return self:run(tree)
elseif SyntaxTree:is_instance(to_run) then
local filename = to_run.source.filename:gsub("\n.*", "...")
if to_run.type ~= "FileChunks" then
@ -230,16 +294,16 @@ local nomsu_environment = Importer({
end
local ret = nil
for chunk_no, chunk in ipairs(to_run) do
local lua = environment.compile(chunk)
local lua = self:compile(chunk)
lua:declare_locals()
lua:prepend("-- File: " .. tostring(filename) .. " chunk #" .. tostring(chunk_no) .. "\n")
ret = environment.run_1_in(lua, environment)
ret = self:run(lua)
end
return ret
elseif LuaCode:is_instance(to_run) then
local source = to_run.source
local lua_string = to_run:text()
local run_lua_fn, err = load(lua_string, tostring(source), "t", environment)
local run_lua_fn, err = load(lua_string, tostring(source), "t", self)
if not run_lua_fn then
local lines
do
@ -255,7 +319,7 @@ local nomsu_environment = Importer({
error("Failed to compile generated code:\n\027[1;34m" .. tostring(line_numbered_lua) .. "\027[0m\n\n" .. tostring(err), 0)
end
local source_key = tostring(source)
if not (environment.SOURCE_MAP[source_key] or environment.OPTIMIZATION >= 2) then
if not (self.SOURCE_MAP[source_key] or self.OPTIMIZATION >= 2) then
local map = { }
local file = Files.read(source.filename)
if not file then
@ -285,87 +349,33 @@ local nomsu_environment = Importer({
map_sources(to_run)
map[lua_line] = map[lua_line] or nomsu_line
map[0] = 0
environment.SOURCE_MAP[source_key] = map
self.SOURCE_MAP[source_key] = map
end
return run_lua_fn()
else
return error("Attempt to run unknown thing: " .. tostring(to_run))
end
end,
FILE_CACHE = { },
run_file_1_in = function(path, environment, optimization, prefix)
if prefix == nil then
prefix = nil
end
if not optimization then
optimization = environment.OPTIMIZATION
end
if environment.FILE_CACHE[path] then
import_to_1_from(environment, environment.FILE_CACHE[path], prefix)
return
end
if _currently_running_files:has(path) then
local i = _currently_running_files:index_of(path)
_currently_running_files:add(path)
local circle = _currently_running_files:from_1_to(i, -1)
error("Circular import detected:\n " .. circle:joined_with("\n..imports "))
end
_currently_running_files:add(path)
local mod = _1_forked(environment)
local did_anything = false
for nomsupath in package.nomsupath:gmatch("[^;]+") do
local _continue_0 = false
repeat
new_environment = function()
local env = { }
do
local full_path = nomsupath == "." and path or nomsupath .. "/" .. path
local files = Files.list(full_path)
if not (files) then
_continue_0 = true
break
local _tbl_0 = { }
for k, v in pairs(nomsu_environment) do
_tbl_0[k] = v
end
for _index_0 = 1, #files do
local _continue_1 = false
repeat
local filename = files[_index_0]
local lua_filename = filename:gsub("%.nom$", ".lua")
if environment.FILE_CACHE[filename] then
import_to_1_from(environment, environment.FILE_CACHE[filename], prefix)
did_anything = true
_continue_1 = true
break
_module_imports[env] = _tbl_0
end
local code
if optimization ~= 0 and Files.exists(lua_filename) then
local file = Files.read(lua_filename)
code = LuaCode:from(Source(filename, 1, #file), file)
else
local file = Files.read(filename)
code = NomsuCode:from(Source(filename, 1, #file), file)
env[jit and "_G" or "_ENV"] = env
setmetatable(env, getmetatable(nomsu_environment))
return env
end
environment.run_1_in(code, mod)
did_anything = true
_continue_1 = true
until true
if not _continue_1 then
break
end
end
break
end
_continue_0 = true
until true
if not _continue_0 then
break
end
end
if not (did_anything) then
error("File not found: " .. tostring(path) .. "\n(searched in " .. tostring(package.nomsupath) .. ")", 0)
end
import_to_1_from(environment, mod, prefix)
environment.FILE_CACHE[path] = mod
return _currently_running_files:remove()
}, {
__index = function(self, k)
return _module_imports[self][k]
end
})
nomsu_environment._ENV = nomsu_environment
nomsu_environment[jit and "_G" or "_ENV"] = nomsu_environment
nomsu_environment.COMPILE_RULES = require('bootstrap')
_module_imports[nomsu_environment] = { }
SOURCE_MAP = nomsu_environment.SOURCE_MAP
return nomsu_environment

157
nomsu_environment.moon
View File

@ -1,7 +1,6 @@
-- This file defines the environment in which Nomsu code runs, including some
-- basic bootstrapping functionality.
{:NomsuCode, :LuaCode, :Source} = require "code_obj"
{:Importer, :import_to_1_from, :_1_forked} = require 'importer'
{:List, :Dict, :Text} = require 'containers'
SyntaxTree = require "syntax_tree"
Files = require "files"
@ -14,15 +13,16 @@ make_tree = (tree, userdata)->
tree = SyntaxTree(tree)
return tree
table.map = (t, fn)-> setmetatable([fn(v) for _,v in ipairs(t)], getmetatable(t))
Parsers = {}
max_parser_version = 0
for version=1,999
local peg_file
if package.nomsupath
for path in package.nomsupath\gmatch("[^;]+")
continue if path == "." and package.nomsupath != "."
peg_file = io.open(path.."/nomsu.#{version}.peg")
break if peg_file
pegpath = package.nomsupath\gsub("%.nom", ".peg")
if path = package.searchpath("nomsu.#{version}", pegpath, "/")
peg_file = io.open(path)
else
peg_file = io.open("nomsu.#{version}.peg")
break unless peg_file
@ -34,8 +34,10 @@ for version=1,999
{:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler"
{:compile, :compile_error} = require('nomsu_compiler')
_currently_running_files = List{} -- Used to check for circular imports in run_file_1_in
nomsu_environment = Importer{
NOMSU_COMPILER_VERSION: 12, NOMSU_SYNTAX_VERSION: max_parser_version
local nomsu_environment
_module_imports = {}
nomsu_environment = setmetatable({
NOMSU_COMPILER_VERSION: 13, NOMSU_SYNTAX_VERSION: max_parser_version
-- Lua stuff:
:next, unpack: unpack or table.unpack, :setmetatable, :rawequal, :getmetatable, :pcall,
yield:coroutine.yield, resume:coroutine.resume, coroutine_status_of:coroutine.status,
@ -53,12 +55,13 @@ nomsu_environment = Importer{
:LuaCode, :NomsuCode, :Source
LuaCode_from: ((src, ...)-> LuaCode\from(src, ...)),
NomsuCode_from: ((src, ...)-> NomsuCode\from(src, ...)),
SOURCE_MAP: Importer({})
SOURCE_MAP: {},
getfenv:getfenv,
-- Nomsu functions:
_1_as_nomsu:tree_to_nomsu, _1_as_inline_nomsu:tree_to_inline_nomsu,
compile: compile, _1_as_lua: compile, compile_error_at:compile_error,
:_1_forked, :import_to_1_from, exit:os.exit, quit:os.exit,
compile: compile, compile_error_at:compile_error,
exit:os.exit, quit:os.exit,
_1_parsed: (nomsu_code, syntax_version)->
if type(nomsu_code) == 'string'
@ -96,17 +99,72 @@ nomsu_environment = Importer{
return tree
run_1_in: (to_run, environment)->
load_module: (package_name)=>
local path
if package_name\match("%.nom$") or package_name\match("%.lua")
path = package_name
else
path, err = package.searchpath(package_name, package.nomsupath, "/")
if not path then error(err)
path = path\gsub("^%./", "")
if ret = package.loaded[package_name] or package.loaded[path]
return ret
if _currently_running_files\has(path)
i = _currently_running_files\index_of(path)
_currently_running_files\add path
circle = _currently_running_files\from_1_to(i, -1)
error("Circular import detected:\n "..circle\joined_with("\n..imports "))
mod = @new_environment!
mod.MODULE_NAME = package_name
mod.TESTS = Dict{}
code = Files.read(path)
if path\match("%.lua$")
code = LuaCode\from(Source(path, 1, #code), code)
else
code = NomsuCode\from(Source(path, 1, #code), code)
_currently_running_files\add path
assert(mod[jit and "_G" or "_ENV"] == mod)
mod\run(code)
assert(mod[jit and "_G" or "_ENV"] == mod)
_currently_running_files\pop!
package.loaded[package_name] = mod
package.loaded[path] = mod
return mod
use: (package_name)=>
mod = @load_module(package_name)
assert(mod[jit and "_G" or "_ENV"] == mod)
imports = assert _module_imports[@]
for k,v in pairs(mod)
imports[k] = v
assert(mod[jit and "_G" or "_ENV"] == mod)
return mod
export: (package_name)=>
mod = @load_module(package_name)
assert(mod[jit and "_G" or "_ENV"] == mod)
imports = assert _module_imports[@]
for k,v in pairs(_module_imports[mod])
imports[k] = v
for k,v in pairs(mod)
if k != "_G" and k != "_ENV"
@[k] = v
assert(mod[jit and "_G" or "_ENV"] == mod)
return mod
run: (to_run)=>
if not to_run
error("Need both something to run and an environment")
if type(to_run) == 'string'
filename = Files.spoof(to_run)
to_run = NomsuCode\from(Source(filename, 1, #to_run), to_run)
ret = environment.run_1_in(to_run, environment)
return ret
return @run(to_run)
elseif NomsuCode\is_instance(to_run)
tree = environment._1_parsed(to_run)
tree = @._1_parsed(to_run)
return nil if tree == nil
ret = environment.run_1_in(tree, environment)
return ret
return @run(tree)
elseif SyntaxTree\is_instance(to_run)
filename = to_run.source.filename\gsub("\n.*", "...")
if to_run.type != "FileChunks"
@ -116,22 +174,22 @@ nomsu_environment = Importer{
-- compiles.
ret = nil
for chunk_no, chunk in ipairs to_run
lua = environment.compile(chunk)
lua = @compile(chunk)
lua\declare_locals!
lua\prepend "-- File: #{filename} chunk ##{chunk_no}\n"
ret = environment.run_1_in(lua, environment)
ret = @run(lua)
return ret
elseif LuaCode\is_instance(to_run)
source = to_run.source
lua_string = to_run\text!
-- If you replace tostring(source) with "nil", source mapping won't happen
run_lua_fn, err = load(lua_string, tostring(source), "t", environment)
run_lua_fn, err = load(lua_string, tostring(source), "t", @)
if not run_lua_fn
lines =[("%3d|%s")\format(i,line) for i, line in ipairs Files.get_lines(lua_string)]
line_numbered_lua = table.concat(lines, "\n")
error("Failed to compile generated code:\n\027[1;34m#{line_numbered_lua}\027[0m\n\n#{err}", 0)
source_key = tostring(source)
unless environment.SOURCE_MAP[source_key] or environment.OPTIMIZATION >= 2
unless @SOURCE_MAP[source_key] or @OPTIMIZATION >= 2
map = {}
file = Files.read(source.filename)
if not file
@ -152,56 +210,23 @@ nomsu_environment = Importer{
map[lua_line] or= nomsu_line
map[0] = 0
-- Mapping from lua line number to nomsu line numbers
environment.SOURCE_MAP[source_key] = map
@SOURCE_MAP[source_key] = map
return run_lua_fn!
else
error("Attempt to run unknown thing: "..tostring(to_run))
FILE_CACHE: {}
run_file_1_in: (path, environment, optimization, prefix=nil)->
if not optimization
optimization = environment.OPTIMIZATION
if environment.FILE_CACHE[path]
import_to_1_from(environment, environment.FILE_CACHE[path], prefix)
return
if _currently_running_files\has(path)
i = _currently_running_files\index_of(path)
_currently_running_files\add path
circle = _currently_running_files\from_1_to(i, -1)
error("Circular import detected:\n "..circle\joined_with("\n..imports "))
_currently_running_files\add path
mod = _1_forked(environment)
did_anything = false
for nomsupath in package.nomsupath\gmatch("[^;]+")
full_path = nomsupath == "." and path or nomsupath.."/"..path
files = Files.list(full_path)
continue unless files
for filename in *files
lua_filename = filename\gsub("%.nom$", ".lua")
-- Need to check here to prevent re-running files
if environment.FILE_CACHE[filename]
import_to_1_from(environment, environment.FILE_CACHE[filename], prefix)
did_anything = true
continue
-- TODO: don't automatically use precompiled version?
code = if optimization != 0 and Files.exists(lua_filename)
-- TODO: use a checksum?
file = Files.read(lua_filename)
LuaCode\from(Source(filename, 1, #file), file)
else
file = Files.read(filename)
NomsuCode\from(Source(filename, 1, #file), file)
environment.run_1_in(code, mod)
did_anything = true
break
unless did_anything
error("File not found: #{path}\n(searched in #{package.nomsupath})", 0)
import_to_1_from(environment, mod, prefix)
environment.FILE_CACHE[path] = mod
_currently_running_files\remove!
}
nomsu_environment._ENV = nomsu_environment
new_environment: ->
env = {}
_module_imports[env] = {k,v for k,v in pairs(nomsu_environment)}
env[jit and "_G" or "_ENV"] = env
setmetatable(env, getmetatable(nomsu_environment))
return env
}, {
__index: (k)=> _module_imports[@][k]
})
nomsu_environment[jit and "_G" or "_ENV"] = nomsu_environment
nomsu_environment.COMPILE_RULES = require('bootstrap')
_module_imports[nomsu_environment] = {}
-- Hacky use of globals:
export SOURCE_MAP

4
tools/find.nom
View File

@ -16,8 +16,8 @@
<filename>:<line number>:
<matching lines>
use "lib/os.nom"
use "lib/consolecolor.nom"
use "lib/os"
use "lib/consolecolor"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
tools/format.nom
View File

@ -7,7 +7,7 @@
If the "-q" flag is used and an error occurs, the original file will be printed.
If no files are passed in, this will read from stdin.
use "lib/os.nom"
use "lib/os"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2
tools/parse.nom
View File

@ -3,7 +3,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"
use "lib/os"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

10
tools/repl.nom
View File

@ -2,8 +2,8 @@
#
This file defines a Read-Evaluate-Print-Loop (REPL) for Nomsu
use "lib/consolecolor.nom"
use "lib/os.nom"
use "lib/consolecolor"
use "lib/os"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -44,7 +44,7 @@ repeat:
spoof file $buff
try:
$tree = ($buff parsed)
..if it fails $err:
..if it fails with $err:
say $err
do next
@ -54,7 +54,7 @@ repeat:
for $chunk in $tree:
try:
$lua = ($chunk as lua)
..if it fails $err: say $err
..if it fails with $err: say $err
unless $lua:
do next
@ -65,7 +65,7 @@ repeat:
$lua, remove free vars
try:
$ret = (run $lua)
..if it fails $err: say $err
..if it fails with $err: say $err
..if it succeeds:
if (type of $ret) is:
"nil":

4
tools/replace.nom
View File

@ -15,8 +15,8 @@
contents will be output.
If no files are passed in, this will read from stdin.
use "lib/os.nom"
use "lib/consolecolor.nom"
use "lib/os"
use "lib/consolecolor"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

14
tools/test.nom
View File

@ -3,15 +3,14 @@
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"
use "lib/os"
use "lib/consolecolor"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Make sure all the files get run
for $filename in $(COMMAND LINE ARGS).extras: use $filename
$tests = {: for $s = $t in $TESTS: add (=lua "Source:from_string(\$s)") = $t}
for $filename in $(COMMAND LINE ARGS).extras:
$(test environment) = (new environment)
$(test environment), use $filename
$file = (read file $filename)
$version =
$file, matching ("
@ -20,8 +19,7 @@ for $filename in $(COMMAND LINE ARGS).extras:
]*)
")
$file_tests = []
for $src = $test in $tests:
if ($src.filename == $filename):
for $src = $test in $(test environment).TESTS:
if $version:
$test = ("
#!/usr/bin/env nomsu -V\$version
@ -38,7 +36,7 @@ for $filename in $(COMMAND LINE ARGS).extras:
for $ in $file_tests:
if (command line args).v:
say " \(yellow ($.test, with "\n" -> "\n "))"
run $.test
$(test environment), run $.test
if (command line args).v:
say (green "PASS")

4
tools/upgrade.nom
View File

@ -6,8 +6,8 @@
upgraded code will be printed.
use "compatibility"
use "lib/os.nom"
use "lib/consolecolor.nom"
use "lib/os"
use "lib/consolecolor"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~