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

steamlining and tweaks to the makefile. Version bump: 6.14.13.8

Makefile

@@ -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 \
+	if [[ ! $$prefix ]]; then prefix="/usr/local"; fi; \
-		prefix="/usr/local"; \
+	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 \
+	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 = [[$$version]], [[$$prefix]]" | cat - nomsu.lua > $$prefix/bin/nomsu$$version \
+	&& 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 \
+	if [[ ! $$prefix ]]; then prefix="/usr/local"; fi; \
-		prefix="/usr/local"; \
+	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

bootstrap.lua

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

bootstrap.moon

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

code_obj.lua

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

code_obj.moon

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

compatibility/2.3.nom

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

compatibility/2.4.nom

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

compatibility/2.5.5.5.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/2.5.nom

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

compatibility/2.nom

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

compatibility/3.5.5.6.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/3.6.nom

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

compatibility/3.7.nom

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

compatibility/3.nom

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

compatibility/4.10.12.7.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/4.11.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/4.12.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/4.8.10.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/4.9.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/5.13.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/6.14.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

compatibility/compatibility.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

core/collections.nom

@@ -3,9 +3,9 @@
     This file contains code that supports manipulating and using collections like lists
     and dictionaries.
     
-use "core/metaprogramming.nom"
+use "core/metaprogramming"
-use "core/control_flow.nom"
+use "core/control_flow"
-use "core/operators.nom"
+use "core/operators"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

core/control_flow.nom

@@ -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/metaprogramming"
-use "core/operators.nom"
+use "core/operators"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -464,29 +464,26 @@ 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:
+    $lua =
-        define mangler
+        Lua ("
-        (recurse $v on $x) compiles to
+            do
-            Lua "table.insert(\(mangle "stack \($v.1)"), \($x as lua expr))"
+                local _stack_\($var as lua expr) = List{\($structure as lua expr)}
-        
+                while #_stack_\($var as lua expr) > 0 do
-        $lua =
+                    \($var as lua expr) = table.remove(_stack_\($var as lua expr), 1)
-            Lua ("
+                    \($body as lua)
-                do
+        ")
-                    local \(mangle "stack \($var.1)") = List{\($structure as lua expr)}
+    
-                    while #\(mangle "stack \($var.1)") > 0 do
+    if ($body has subtree \(do next)):
-                        \($var as lua expr) = table.remove(\(mangle "stack \($var.1)"), 1)
+        $lua, add "\n        ::continue::"
-                        \($body as lua)
+    
-            ")
+    if ($body has subtree \(do next $var)):
-        
+        $lua, add "\n        \(\(---next $var ---) as lua)"
-        if ($body has subtree \(do next)):
+    
-            $lua, add "\n        ::continue::"
+    $lua, add "\n    end -- Recursive loop"
-        
+    if ($body has subtree \(stop $var)):
-        if ($body has subtree \(do next $var)):
+        $lua, add "\n        \(\(---stop $var ---) as lua)"
-            $lua, add "\n        \(\(---next $var ---) as lua)"
+    $lua, add "\nend -- Recursive scope"
-        
+    return $lua
-        $lua, add "\n    end -- Recursive loop"
-        if ($body has subtree \(stop $var)):
-            $lua, add "\n        \(\(---stop $var ---) as lua)"
-        $lua, add "\nend -- Recursive scope"
-        return $lua

core/coroutines.nom

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

core/errors.nom

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

core/id.nom

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

core/init.nom

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

core/io.nom

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

core/math.nom

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

core/metaprogramming.nom

@@ -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_RULES["->"] = COMPILE_RULES["1 ->"]
-    compile.action["for"] = compile.action["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)
+    COMPILE_RULES["1 compiles to"] = function(env, \$action, \$body)
-        local \$args = List{\(\$compile), unpack(\$action:get_args())}
+        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 \$args = List{"\(nomsu environment)", unpack(\$actions[1]:get_args())}
-        local \$compiled_args = List(table.map(\$args, compile))
+        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())}
+            local \$alias_args = List{"\(nomsu environment)", unpack(alias:get_args())}
-            lua:add("\\ncompile.action[", alias:get_stub():as_lua(), "] = ")
+            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), ", ")
+                local \$compiled_alias_args = List{"\(nomsu environment)"};
-                lua:add(") return compile.action[", \$actions[1]:get_stub():as_lua(), "](")
+                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 ("
+#
-    do
+    (with local compile actions $body) compiles to ("
-        --local compile = _1_forked(compile)
+        do
-        local old_action = compile.action
+            local OLD_RULES = COMPILE_RULES
-        compile.action = _1_forked(old_action)
+            local OLD_ENV = \(nomsu environment)
-        \($body as lua)
+            local \(nomsu environment) = setmetatable({
-        compile.action = old_action
+                COMPILE_RULES=setmetatable({}, {__index=OLD_RULES})
-    end
+            }, {__index=OLD_ENV})
-")
+            \($body as lua)
+        end
+    ")
 
 externally (Nomsu version) means:
     return ("

core/operators.nom

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

core/text.nom

@@ -3,9 +3,9 @@
     This file contains some definitions of text escape sequences, including ANSI console
     color codes.
     
-use "core/metaprogramming.nom"
+use "core/metaprogramming"
-use "core/operators.nom"
+use "core/operators"
-use "core/control_flow.nom"
+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)

doc/nomsu.1

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

examples/how_do_i.nom

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

files.lua

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

files.moon

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

importer.lua

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

importer.moon

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

lib/consolecolor.nom

@@ -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')")

lib/file_hash.nom

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

lib/object.nom

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

lib/os.nom

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

lib/things.nom

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

nomsu.lua

@@ -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: {|
-         / {:files: {|
+          ( ("-m" %sep)? (!("--" %sep) file)* ("--" %sep)
-            ("-t" %sep {~ {[^%sep]+} -> "nomsu://tools/%1.nom" ~} %sep
+           / file
-             / "-m" %sep (!("--" %sep) {[^%sep]+} %sep)* ("--" %sep)?
+           / {~ '' %sep? -> 'nomsu://tools/repl.nom' ~}) |} :}
-             / {[^%sep]+} %sep
-             / {~ '' %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
+    nomsu_environment:export("core")
-      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
   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
+          local path, err = package.searchpath(nomsu_name, package.nomsupath, "/")
-            files = Files.list(nomsupath .. "/" .. nomsu_name)
+          if not path then
-            if files then
+            error(err)
-              break
-            end
           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

nomsu.moon

@@ -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: {|
-         / {:files: {|
+          ( ("-m" %sep)? (!("--" %sep) file)* ("--" %sep)
-            ("-t" %sep {~ {[^%sep]+} -> "nomsu://tools/%1.nom" ~} %sep
+           / file
-             / "-m" %sep (!("--" %sep) {[^%sep]+} %sep)* ("--" %sep)?
+           / {~ '' %sep? -> 'nomsu://tools/repl.nom' ~}) |} :}
-             / {[^%sep]+} %sep
-             / {~ '' %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,39 +90,54 @@ 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("[^;]+")
+        nomsu_environment\export("core")
-            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
 
     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://(.*)%.nom")
-            if nomsu_name = f\match("^nomsu://(.*)")
+                path, err = package.searchpath(nomsu_name, package.nomsupath, "/")
-                for nomsupath in package.nomsupath\gmatch("[^;]+")
+                if not path then error(err)
-                    files = Files.list(nomsupath.."/"..nomsu_name)
+                table.insert input_files, path
-                    break if files
             else
-                files = Files.list(f)
+                table.insert input_files, f
-            unless files and #files > 0
+
-                error("Could not find: '#{f}'")
-            for filename in *files
-                table.insert input_files, filename
-    
     for filename in *input_files
         if args.check_syntax
             -- 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')

nomsu_compiler.lua

@@ -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,173 +43,92 @@ 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({
+local compile
-  action = Importer({
+compile = function(self, tree)
-    [""] = function(compile, fn, ...)
+  local _exp_0 = tree.type
-      local lua = LuaCode()
+  if "Action" == _exp_0 then
-      local fn_lua = compile(fn)
+    local stub = tree.stub
-      lua:add(fn_lua)
+    local compile_action = self.COMPILE_RULES[stub]
-      if not (fn_lua:text():match("^%(.*%)$") or fn_lua:text():match("^[_a-zA-Z][_a-zA-Z0-9.]*$")) then
+    if not compile_action and math_expression:match(stub) 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 _exp_0 = tree.type
-    if "Action" == _exp_0 then
-      local stub = tree.stub
-      local compile_action = compile.action[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)
-            if tok.type == "Action" then
-              tok_lua:parenthesize()
-            end
-            lua:add(tok_lua)
-          end
-          if i < #tree then
-            lua:add(" ")
-          end
-        end
-        return lua
-      end
-      if compile_action then
-        local args
-        do
-          local _accum_0 = { }
-          local _len_0 = 1
-          for _index_0 = 1, #tree do
-            local arg = tree[_index_0]
-            if type(arg) ~= "string" then
-              _accum_0[_len_0] = arg
-              _len_0 = _len_0 + 1
-            end
-          end
-          args = _accum_0
-        end
-        local ret = compile_action(compile, unpack(args))
-        if ret == nil then
-          local info = debug.getinfo(compile_action, "S")
-          local filename = Source:from_string(info.source).filename
-          compile_error(tree, "The compile-time action here (" .. tostring(stub) .. ") failed to return any value.", "Look at the implementation of (" .. tostring(stub) .. ") in " .. tostring(filename) .. ":" .. tostring(info.linedefined) .. " and make sure it's returning something.")
-        end
-        if not (SyntaxTree:is_instance(ret)) then
-          ret.source = ret.source or tree.source
-          return ret
-        end
-        if ret ~= tree then
-          return compile(ret)
-        end
-      end
       local lua = LuaCode:from(tree.source)
-      lua:add((stub):as_lua_id(), "(")
+      for i, tok in ipairs(tree) do
-      for argnum, arg in ipairs(tree:get_args()) do
+        if type(tok) == 'string' then
-        local arg_lua = compile(arg)
+          lua:add(tok)
+        else
+          local tok_lua = self:compile(tok)
+          if tok.type == "Action" then
+            tok_lua:parenthesize()
+          end
+          lua:add(tok_lua)
+        end
+        if i < #tree then
+          lua:add(" ")
+        end
+      end
+      return lua
+    end
+    if compile_action then
+      local args
+      do
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #tree do
+          local arg = tree[_index_0]
+          if type(arg) ~= "string" then
+            _accum_0[_len_0] = arg
+            _len_0 = _len_0 + 1
+          end
+        end
+        args = _accum_0
+      end
+      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
+        compile_error(tree, "The compile-time action here (" .. tostring(stub) .. ") failed to return any value.", "Look at the implementation of (" .. tostring(stub) .. ") in " .. tostring(filename) .. ":" .. tostring(info.linedefined) .. " and make sure it's returning something.")
+      end
+      if not (SyntaxTree:is_instance(ret)) then
+        ret.source = ret.source or tree.source
+        return ret
+      end
+      if ret ~= tree then
+        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 = self:compile(arg)
+      if arg.type == "Block" then
+        arg_lua = LuaCode:from(arg.source, "(function()\n    ", arg_lua, "\nend)()")
+      end
+      if lua:trailing_line_len() + #arg_lua:text() > MAX_LINE then
+        lua:add(argnum > 1 and ",\n    " or "\n    ")
+      elseif argnum > 1 then
+        lua:add(", ")
+      end
+      lua:add(arg_lua)
+    end
+    lua:add(")")
+    return lua
+  elseif "MethodCall" == _exp_0 then
+    local lua = LuaCode:from(tree.source)
+    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()
+    end
+    for i = 2, #tree do
+      if i > 2 then
+        lua:add("\n")
+      end
+      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 = self:compile(arg)
         if arg.type == "Block" then
           arg_lua = LuaCode:from(arg.source, "(function()\n    ", arg_lua, "\nend)()")
         end
@@ -246,205 +140,193 @@ local compile = setmetatable({
         lua:add(arg_lua)
       end
       lua:add(")")
-      return lua
+    end
-    elseif "MethodCall" == _exp_0 then
+    return lua
-      local lua = LuaCode:from(tree.source)
+  elseif "EscapedNomsu" == _exp_0 then
-      local target_lua = compile(tree[1])
+    local lua = LuaCode:from(tree.source, "SyntaxTree{")
-      local target_text = target_lua:text()
+    local needs_comma, i = false, 1
-      if not (target_text:match("^%(.*%)$") or target_text:match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or tree[1].type == "IndexChain") then
+    local as_lua
-        target_lua:parenthesize()
+    as_lua = function(x)
+      if type(x) == 'number' then
+        return tostring(x)
+      elseif SyntaxTree:is_instance(x) then
+        return self:compile(x)
+      elseif Source:is_instance(x) then
+        return tostring(x):as_lua()
+      else
+        return x:as_lua()
       end
-      for i = 2, #tree do
+    end
-        if i > 2 then
+    for k, v in pairs((SyntaxTree:is_instance(tree[1]) and tree[1].type == "EscapedNomsu" and tree) or tree[1]) do
-          lua:add("\n")
+      local entry_lua = LuaCode()
-        end
+      if k == i then
-        lua:add(target_lua, ":")
+        i = i + 1
-        lua:add((tree[i].stub):as_lua_id(), "(")
+      elseif type(k) == 'string' and match(k, "[_a-zA-Z][_a-zA-Z0-9]*") then
-        for argnum, arg in ipairs(tree[i]:get_args()) do
+        entry_lua:add(k, "= ")
-          local arg_lua = compile(arg)
+      else
-          if arg.type == "Block" then
+        entry_lua:add("[", as_lua(k), "]= ")
-            arg_lua = LuaCode:from(arg.source, "(function()\n    ", arg_lua, "\nend)()")
-          end
-          if lua:trailing_line_len() + #arg_lua:text() > MAX_LINE then
-            lua:add(argnum > 1 and ",\n    " or "\n    ")
-          elseif argnum > 1 then
-            lua:add(", ")
-          end
-          lua:add(arg_lua)
-        end
-        lua:add(")")
       end
-      return lua
+      entry_lua:add(as_lua(v))
-    elseif "EscapedNomsu" == _exp_0 then
+      if needs_comma then
-      local lua = LuaCode:from(tree.source, "SyntaxTree{")
+        lua:add(",")
-      local needs_comma, i = false, 1
-      local as_lua
-      as_lua = function(x)
-        if type(x) == 'number' then
-          return tostring(x)
-        elseif SyntaxTree:is_instance(x) then
-          return compile(x)
-        elseif Source:is_instance(x) then
-          return tostring(x):as_lua()
-        else
-          return x:as_lua()
-        end
       end
-      for k, v in pairs((SyntaxTree:is_instance(tree[1]) and tree[1].type == "EscapedNomsu" and tree) or tree[1]) do
+      if lua:trailing_line_len() + #(entry_lua:text():match("^[\n]*")) > MAX_LINE then
-        local entry_lua = LuaCode()
+        lua:add("\n    ")
-        if k == i then
+      elseif needs_comma then
-          i = i + 1
+        lua:add(" ")
-        elseif type(k) == 'string' and match(k, "[_a-zA-Z][_a-zA-Z0-9]*") then
-          entry_lua:add(k, "= ")
-        else
-          entry_lua:add("[", as_lua(k), "]= ")
-        end
-        entry_lua:add(as_lua(v))
-        if needs_comma then
-          lua:add(",")
-        end
-        if lua:trailing_line_len() + #(entry_lua:text():match("^[\n]*")) > MAX_LINE then
-          lua:add("\n    ")
-        elseif needs_comma then
-          lua:add(" ")
-        end
-        lua:add(entry_lua)
-        needs_comma = true
       end
-      lua:add("}")
+      lua:add(entry_lua)
-      return lua
+      needs_comma = true
-    elseif "Block" == _exp_0 then
+    end
-      local lua = LuaCode:from(tree.source)
+    lua:add("}")
-      for i, line in ipairs(tree) do
+    return lua
-        if i > 1 then
+  elseif "Block" == _exp_0 then
-          lua:add("\n")
+    local lua = LuaCode:from(tree.source)
-        end
+    for i, line in ipairs(tree) do
-        lua:add(compile(line))
+      if i > 1 then
+        lua:add("\n")
       end
-      return lua
+      lua:add(self:compile(line))
-    elseif "Text" == _exp_0 then
+    end
-      local lua = LuaCode:from(tree.source)
+    return lua
-      local added = 0
+  elseif "Text" == _exp_0 then
-      local string_buffer = ""
+    local lua = LuaCode:from(tree.source)
-      local add_bit
+    local added = 0
-      add_bit = function(bit)
+    local string_buffer = ""
-        if added > 0 then
+    local add_bit
-          if lua:trailing_line_len() + #bit > MAX_LINE then
+    add_bit = function(bit)
-            lua:add("\n  ")
+      if added > 0 then
-          end
+        if lua:trailing_line_len() + #bit > MAX_LINE then
-          lua:add("..")
+          lua:add("\n  ")
         end
-        lua:add(bit)
+        lua:add("..")
-        added = added + 1
       end
-      for i, bit in ipairs(tree) do
+      lua:add(bit)
-        local _continue_0 = false
+      added = added + 1
-        repeat
+    end
-          if type(bit) == "string" then
+    for i, bit in ipairs(tree) do
-            string_buffer = string_buffer .. bit
+      local _continue_0 = false
-            _continue_0 = true
+      repeat
-            break
+        if type(bit) == "string" then
-          end
+          string_buffer = string_buffer .. bit
-          if string_buffer ~= "" then
-            for i = 1, #string_buffer, MAX_LINE do
-              add_bit(string_buffer:sub(i, i + MAX_LINE - 1):as_lua())
-            end
-            string_buffer = ""
-          end
-          local bit_lua = compile(bit)
-          if bit.type == "Block" and #bit == 1 then
-            bit = bit[1]
-          end
-          if bit.type == "Block" then
-            bit_lua = LuaCode:from(bit.source, "List(function(add)", "\n    ", bit_lua, "\nend):joined()")
-          elseif bit.type ~= "Text" then
-            bit_lua = LuaCode:from(bit.source, "tostring(", bit_lua, ")")
-          end
-          add_bit(bit_lua)
           _continue_0 = true
-        until true
-        if not _continue_0 then
           break
         end
-      end
+        if string_buffer ~= "" then
-      if string_buffer ~= "" then
+          for i = 1, #string_buffer, MAX_LINE do
-        for i = 1, #string_buffer, MAX_LINE do
+            add_bit(string_buffer:sub(i, i + MAX_LINE - 1):as_lua())
-          add_bit(string_buffer:sub(i, i + MAX_LINE - 1):as_lua())
+          end
+          string_buffer = ""
         end
-        string_buffer = ""
+        local bit_lua = self:compile(bit)
-      end
+        if bit.type == "Block" and #bit == 1 then
-      if added == 0 then
+          bit = bit[1]
-        add_bit('""')
-      end
-      if added > 1 then
-        lua:parenthesize()
-      end
-      return lua
-    elseif "List" == _exp_0 or "Dict" == _exp_0 then
-      if #tree == 0 then
-        return LuaCode:from(tree.source, tree.type, "{}")
-      end
-      local lua = LuaCode:from(tree.source)
-      local chunks = 0
-      local i = 1
-      while tree[i] do
-        if tree[i].type == 'Block' then
-          if chunks > 0 then
-            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)")
-          chunks = chunks + 1
-          i = i + 1
-        else
-          if chunks > 0 then
-            lua:add(" + ")
-          end
-          local sep = ''
-          local items_lua = LuaCode:from(tree[i].source)
-          while tree[i] do
-            if tree[i].type == "Block" then
-              break
-            end
-            local item_lua = compile(tree[i])
-            if item_lua:text():match("^%.[a-zA-Z_]") then
-              item_lua = item_lua:text():sub(2)
-            end
-            if tree.type == 'Dict' and tree[i].type == 'Index' then
-              item_lua = LuaCode:from(tree[i].source, item_lua, "=true")
-            end
-            items_lua:add(sep, item_lua)
-            if tree[i].type == "Comment" then
-              items_lua:add("\n")
-              sep = ''
-            elseif items_lua:trailing_line_len() > MAX_LINE then
-              sep = ',\n    '
-            else
-              sep = ', '
-            end
-            i = i + 1
-          end
-          if items_lua:is_multiline() then
-            lua:add(LuaCode:from(items_lua.source, tree.type, "{\n    ", items_lua, "\n}"))
-          else
-            lua:add(LuaCode:from(items_lua.source, tree.type, "{", items_lua, "}"))
-          end
-          chunks = chunks + 1
         end
+        if bit.type == "Block" then
+          bit_lua = LuaCode:from(bit.source, "List(function(add)", "\n    ", bit_lua, "\nend):joined()")
+        elseif bit.type ~= "Text" then
+          bit_lua = LuaCode:from(bit.source, "tostring(", bit_lua, ")")
+        end
+        add_bit(bit_lua)
+        _continue_0 = true
+      until true
+      if not _continue_0 then
+        break
       end
-      return lua
+    end
-    elseif "Index" == _exp_0 then
+    if string_buffer ~= "" then
-      local key_lua = compile(tree[1])
+      for i = 1, #string_buffer, MAX_LINE do
-      local key_str = match(key_lua:text(), '^"([a-zA-Z_][a-zA-Z0-9_]*)"$')
+        add_bit(string_buffer:sub(i, i + MAX_LINE - 1):as_lua())
-      if key_str and key_str:is_lua_id() then
+      end
-        return LuaCode:from(tree.source, ".", key_str)
+      string_buffer = ""
-      elseif sub(key_lua:text(), 1, 1) == "[" then
+    end
-        return LuaCode:from(tree.source, "[ ", key_lua, "]")
+    if added == 0 then
+      add_bit('""')
+    end
+    if added > 1 then
+      lua:parenthesize()
+    end
+    return lua
+  elseif "List" == _exp_0 or "Dict" == _exp_0 then
+    if #tree == 0 then
+      return LuaCode:from(tree.source, tree.type, "{}")
+    end
+    local lua = LuaCode:from(tree.source)
+    local chunks = 0
+    local i = 1
+    while tree[i] do
+      if tree[i].type == 'Block' then
+        if chunks > 0 then
+          lua:add(" + ")
+        end
+        lua:add(tree.type, "(function(", (tree.type == 'List' and "add" or ("add, " .. ("add 1 ="):as_lua_id())), ")")
+        lua:add("\n    ", self:compile(tree[i]), "\nend)")
+        chunks = chunks + 1
+        i = i + 1
       else
-        return LuaCode:from(tree.source, "[", key_lua, "]")
+        if chunks > 0 then
+          lua:add(" + ")
+        end
+        local sep = ''
+        local items_lua = LuaCode:from(tree[i].source)
+        while tree[i] do
+          if tree[i].type == "Block" then
+            break
+          end
+          local item_lua = self:compile(tree[i])
+          if item_lua:text():match("^%.[a-zA-Z_]") then
+            item_lua = item_lua:text():sub(2)
+          end
+          if tree.type == 'Dict' and tree[i].type == 'Index' then
+            item_lua = LuaCode:from(tree[i].source, item_lua, "=true")
+          end
+          items_lua:add(sep, item_lua)
+          if tree[i].type == "Comment" then
+            items_lua:add("\n")
+            sep = ''
+          elseif items_lua:trailing_line_len() > MAX_LINE then
+            sep = ',\n    '
+          else
+            sep = ', '
+          end
+          i = i + 1
+        end
+        if items_lua:is_multiline() then
+          lua:add(LuaCode:from(items_lua.source, tree.type, "{\n    ", items_lua, "\n}"))
+        else
+          lua:add(LuaCode:from(items_lua.source, tree.type, "{", items_lua, "}"))
+        end
+        chunks = chunks + 1
       end
-    elseif "DictEntry" == _exp_0 then
+    end
-      local key = tree[1]
+    return lua
+  elseif "Index" == _exp_0 then
+    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)
+    elseif sub(key_lua:text(), 1, 1) == "[" then
+      return LuaCode:from(tree.source, "[ ", key_lua, "]")
+    else
+      return LuaCode:from(tree.source, "[", key_lua, "]")
+    end
+  elseif "DictEntry" == _exp_0 then
+    local key = tree[1]
+    if key.type ~= "Index" then
+      key = SyntaxTree({
+        type = "Index",
+        source = key.source,
+        key
+      })
+    end
+    return LuaCode:from(tree.source, self:compile(key), "=", (tree[2] and self:compile(tree[2]) or "true"))
+  elseif "IndexChain" == _exp_0 then
+    local lua = self:compile(tree[1])
+    if lua:text():match("['\"}]$") or lua:text():match("]=*]$") then
+      lua:parenthesize()
+    end
+    for i = 2, #tree do
+      local key = tree[i]
       if key.type ~= "Index" then
         key = SyntaxTree({
           type = "Index",
@@ -452,39 +334,23 @@ local compile = setmetatable({
           key
         })
       end
-      return LuaCode:from(tree.source, compile(key), "=", (tree[2] and compile(tree[2]) or "true"))
+      lua:add(self:compile(key))
-    elseif "IndexChain" == _exp_0 then
-      local lua = compile(tree[1])
-      if lua:text():match("['\"}]$") or lua:text():match("]=*]$") then
-        lua:parenthesize()
-      end
-      for i = 2, #tree do
-        local key = tree[i]
-        if key.type ~= "Index" then
-          key = SyntaxTree({
-            type = "Index",
-            source = key.source,
-            key
-          })
-        end
-        lua:add(compile(key))
-      end
-      return lua
-    elseif "Number" == _exp_0 then
-      return LuaCode:from(tree.source, tostring(tree[1]))
-    elseif "Var" == _exp_0 then
-      return LuaCode:from(tree.source, tree:as_var():as_lua_id())
-    elseif "FileChunks" == _exp_0 then
-      return error("Can't convert FileChunks to a single block of lua, since each chunk's " .. "compilation depends on the earlier chunks")
-    elseif "Comment" == _exp_0 then
-      return LuaCode:from(tree.source, "-- ", (tree[1]:gsub('\n', '\n-- ')))
-    elseif "Error" == _exp_0 then
-      return error("Can't compile errors")
-    else
-      return error("Unknown type: " .. tostring(tree.type))
     end
+    return lua
+  elseif "Number" == _exp_0 then
+    return LuaCode:from(tree.source, tostring(tree[1]))
+  elseif "Var" == _exp_0 then
+    return LuaCode:from(tree.source, tree:as_var():as_lua_id())
+  elseif "FileChunks" == _exp_0 then
+    return error("Can't convert FileChunks to a single block of lua, since each chunk's " .. "compilation depends on the earlier chunks")
+  elseif "Comment" == _exp_0 then
+    return LuaCode:from(tree.source, "-- ", (tree[1]:gsub('\n', '\n-- ')))
+  elseif "Error" == _exp_0 then
+    return error("Can't compile errors")
+  else
+    return error("Unknown type: " .. tostring(tree.type))
   end
-})
+end
 return {
   compile = compile,
   compile_error = compile_error

nomsu_compiler.moon

@@ -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,137 +30,74 @@ 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({
+compile = (tree)=>
-    action: Importer{
+    switch tree.type
-        [""]: (compile, fn, ...)->
+        when "Action"
-            lua = LuaCode!
+            stub = tree.stub
-            fn_lua = compile(fn)
+            compile_action = @COMPILE_RULES[stub]
-            lua\add fn_lua
+            if not compile_action and math_expression\match(stub)
-            unless fn_lua\text!\match("^%(.*%)$") or fn_lua\text!\match("^[_a-zA-Z][_a-zA-Z0-9.]*$")
+                lua = LuaCode\from(tree.source)
-                lua\parenthesize!
+                for i,tok in ipairs tree
-            lua\add "("
+                    if type(tok) == 'string'
-            for i=1,select('#',...)
+                        lua\add tok
-                lua\add(", ") if i > 1
+                    else
-                lua\add compile((select(i, ...)))
+                        tok_lua = @compile(tok)
+                        -- TODO: this is overly eager, should be less aggressive
+                        tok_lua\parenthesize! if tok.type == "Action"
+                        lua\add tok_lua
+                    lua\add " " if i < #tree
+                return lua
+
+            if compile_action
+                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(@, unpack(args))
+                if ret == nil
+                    info = debug.getinfo(compile_action, "S")
+                    filename = Source\from_string(info.source).filename
+                    compile_error tree,
+                        "The compile-time action here (#{stub}) failed to return any value.",
+                        "Look at the implementation of (#{stub}) in #{filename}:#{info.linedefined} and make sure it's returning something."
+                unless SyntaxTree\is_instance(ret)
+                    ret.source or= tree.source
+                    return ret
+                if ret != tree
+                    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)
+                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
+                    lua\add(argnum > 1 and ",\n    " or "\n    ")
+                elseif argnum > 1
+                    lua\add ", "
+                lua\add arg_lua
             lua\add ")"
             return lua
 
-        ["Lua"]: (compile, code)->
+        when "MethodCall"
-            if not code
+            lua = LuaCode\from tree.source
-                return LuaCode("LuaCode()")
+            target_lua = @compile tree[1]
-            if code.type != "Text"
+            target_text = target_lua\text!
-                return LuaCode("LuaCode:from(", tostring(code.source)\as_lua!, ", ", compile(code), ")")
+            -- TODO: this parenthesizing is maybe overly conservative
+            if not (target_text\match("^%(.*%)$") or target_text\match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or
+                tree[1].type == "IndexChain")
+                target_lua\parenthesize!
 
-            operate_on_text = (text)->
+            for i=2,#tree
-                lua = LuaCode\from(text.source, "LuaCode:from(", tostring(text.source)\as_lua!)
+                lua\add "\n" if i > 2
-                for bit in *text
+                lua\add target_lua, ":"
-                    local bit_lua
+                lua\add((tree[i].stub)\as_lua_id!,"(")
-                    if type(bit) == "string"
+                for argnum, arg in ipairs tree[i]\get_args!
-                        bit_lua = bit\as_lua!
+                    arg_lua = @compile(arg)
-                    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)->
-        switch tree.type
-            when "Action"
-                stub = tree.stub
-                compile_action = compile.action[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)
-                            -- TODO: this is overly eager, should be less aggressive
-                            tok_lua\parenthesize! if tok.type == "Action"
-                            lua\add tok_lua
-                        lua\add " " if i < #tree
-                    return lua
-
-                if compile_action
-                    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))
-                    if ret == nil
-                        info = debug.getinfo(compile_action, "S")
-                        filename = Source\from_string(info.source).filename
-                        compile_error tree,
-                            "The compile-time action here (#{stub}) failed to return any value.",
-                            "Look at the implementation of (#{stub}) in #{filename}:#{info.linedefined} and make sure it's returning something."
-                    unless SyntaxTree\is_instance(ret)
-                        ret.source or= tree.source
-                        return ret
-                    if ret != tree
-                        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)
                     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
@@ -184,207 +106,180 @@ compile = setmetatable({
                         lua\add ", "
                     lua\add arg_lua
                 lua\add ")"
-                return lua
+            return lua
 
-            when "MethodCall"
+        when "EscapedNomsu"
-                lua = LuaCode\from tree.source
+            lua = LuaCode\from tree.source, "SyntaxTree{"
-                target_lua = compile tree[1]
+            needs_comma, i = false, 1
-                target_text = target_lua\text!
+            as_lua = (x)->
-                -- TODO: this parenthesizing is maybe overly conservative
+                if type(x) == 'number'
-                if not (target_text\match("^%(.*%)$") or target_text\match("^[_a-zA-Z][_a-zA-Z0-9.]*$") or
+                    tostring(x)
-                    tree[1].type == "IndexChain")
+                elseif SyntaxTree\is_instance(x)
-                    target_lua\parenthesize!
+                    @compile(x)
+                elseif Source\is_instance(x)
+                    tostring(x)\as_lua!
+                else x\as_lua!
 
-                for i=2,#tree
+            for k,v in pairs((SyntaxTree\is_instance(tree[1]) and tree[1].type == "EscapedNomsu" and tree) or tree[1])
-                    lua\add "\n" if i > 2
+                entry_lua = LuaCode!
-                    lua\add target_lua, ":"
+                if k == i
-                    lua\add((tree[i].stub)\as_lua_id!,"(")
+                    i += 1
-                    for argnum, arg in ipairs tree[i]\get_args!
+                elseif type(k) == 'string' and match(k,"[_a-zA-Z][_a-zA-Z0-9]*")
-                        arg_lua = compile(arg)
+                    entry_lua\add(k, "= ")
-                        if arg.type == "Block"
+                else
-                            arg_lua = LuaCode\from(arg.source, "(function()\n    ", arg_lua, "\nend)()")
+                    entry_lua\add("[", as_lua(k), "]= ")
-                        if lua\trailing_line_len! + #arg_lua\text! > MAX_LINE
+                entry_lua\add as_lua(v)
-                            lua\add(argnum > 1 and ",\n    " or "\n    ")
+                if needs_comma then lua\add ","
-                        elseif argnum > 1
+                if lua\trailing_line_len! + #(entry_lua\text!\match("^[\n]*")) > MAX_LINE
-                            lua\add ", "
+                    lua\add "\n    "
-                        lua\add arg_lua
+                elseif needs_comma
-                    lua\add ")"
+                    lua\add " "
-                return lua
+                lua\add entry_lua
+                needs_comma = true
+            lua\add "}"
+            return lua
+        
+        when "Block"
+            lua = LuaCode\from(tree.source)
+            for i, line in ipairs tree
+                if i > 1 then lua\add "\n"
+                lua\add @compile(line)
+            return lua
 
-            when "EscapedNomsu"
+        when "Text"
-                lua = LuaCode\from tree.source, "SyntaxTree{"
+            lua = LuaCode\from(tree.source)
-                needs_comma, i = false, 1
+            added = 0
-                as_lua = (x)->
+            string_buffer = ""
-                    if type(x) == 'number'
+            add_bit = (bit)->
-                        tostring(x)
+                if added > 0
-                    elseif SyntaxTree\is_instance(x)
+                    if lua\trailing_line_len! + #bit > MAX_LINE
-                        compile(x)
+                        lua\add "\n  "
-                    elseif Source\is_instance(x)
+                    lua\add ".."
-                        tostring(x)\as_lua!
+                lua\add bit
-                    else x\as_lua!
+                added += 1
-
-                for k,v in pairs((SyntaxTree\is_instance(tree[1]) and tree[1].type == "EscapedNomsu" and tree) or tree[1])
-                    entry_lua = LuaCode!
-                    if k == i
-                        i += 1
-                    elseif type(k) == 'string' and match(k,"[_a-zA-Z][_a-zA-Z0-9]*")
-                        entry_lua\add(k, "= ")
-                    else
-                        entry_lua\add("[", as_lua(k), "]= ")
-                    entry_lua\add as_lua(v)
-                    if needs_comma then lua\add ","
-                    if lua\trailing_line_len! + #(entry_lua\text!\match("^[\n]*")) > MAX_LINE
-                        lua\add "\n    "
-                    elseif needs_comma
-                        lua\add " "
-                    lua\add entry_lua
-                    needs_comma = true
-                lua\add "}"
-                return lua
-            
-            when "Block"
-                lua = LuaCode\from(tree.source)
-                for i, line in ipairs tree
-                    if i > 1 then lua\add "\n"
-                    lua\add compile(line)
-                return lua
-
-            when "Text"
-                lua = LuaCode\from(tree.source)
-                added = 0
-                string_buffer = ""
-                add_bit = (bit)->
-                    if added > 0
-                        if lua\trailing_line_len! + #bit > MAX_LINE
-                            lua\add "\n  "
-                        lua\add ".."
-                    lua\add bit
-                    added += 1
-
-                for i, bit in ipairs tree
-                    if type(bit) == "string"
-                        string_buffer ..= bit
-                        continue
-                    if string_buffer != ""
-                        for i=1,#string_buffer,MAX_LINE
-                            add_bit string_buffer\sub(i, i+MAX_LINE-1)\as_lua!
-                        string_buffer = ""
-
-                    bit_lua = compile(bit)
-                    if bit.type == "Block" and #bit == 1
-                        bit = bit[1]
-                    if bit.type == "Block"
-                        bit_lua = LuaCode\from bit.source, "List(function(add)",
-                            "\n    ", bit_lua,
-                            "\nend):joined()"
-                    elseif bit.type != "Text"
-                        bit_lua = LuaCode\from(bit.source, "tostring(",bit_lua,")")
-                    add_bit bit_lua
 
+            for i, bit in ipairs tree
+                if type(bit) == "string"
+                    string_buffer ..= bit
+                    continue
                 if string_buffer != ""
                     for i=1,#string_buffer,MAX_LINE
                         add_bit string_buffer\sub(i, i+MAX_LINE-1)\as_lua!
                     string_buffer = ""
 
-                if added == 0
+                bit_lua = @compile(bit)
-                    add_bit '""'
+                if bit.type == "Block" and #bit == 1
-                if added > 1
+                    bit = bit[1]
-                    lua\parenthesize!
+                if bit.type == "Block"
-                return lua
+                    bit_lua = LuaCode\from bit.source, "List(function(add)",
+                        "\n    ", bit_lua,
+                        "\nend):joined()"
+                elseif bit.type != "Text"
+                    bit_lua = LuaCode\from(bit.source, "tostring(",bit_lua,")")
+                add_bit bit_lua
 
-            when "List", "Dict"
+            if string_buffer != ""
-                if #tree == 0
+                for i=1,#string_buffer,MAX_LINE
-                    return LuaCode\from tree.source, tree.type, "{}"
+                    add_bit string_buffer\sub(i, i+MAX_LINE-1)\as_lua!
+                string_buffer = ""
 
-                lua = LuaCode\from tree.source
+            if added == 0
-                chunks = 0
+                add_bit '""'
-                i = 1
+            if added > 1
-                while tree[i]
+                lua\parenthesize!
-                    if tree[i].type == 'Block'
+            return lua
-                        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)"
-                        chunks += 1
-                        i += 1
-                    else
-                        lua\add " + " if chunks > 0
-                        sep = ''
-                        items_lua = LuaCode\from tree[i].source
-                        while tree[i]
-                            if tree[i].type == "Block"
-                                break
-                            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'
-                                item_lua = LuaCode\from tree[i].source, item_lua, "=true"
-                            items_lua\add sep, item_lua
-                            if tree[i].type == "Comment"
-                                items_lua\add "\n"
-                                sep = ''
-                            elseif items_lua\trailing_line_len! > MAX_LINE
-                                sep = ',\n    '
-                            else
-                                sep = ', '
-                            i += 1
-                        if items_lua\is_multiline!
-                            lua\add LuaCode\from items_lua.source, tree.type, "{\n    ", items_lua, "\n}"
-                        else
-                            lua\add LuaCode\from items_lua.source, tree.type, "{", items_lua, "}"
-                        chunks += 1
-                
-                return lua
 
-            when "Index"
+        when "List", "Dict"
-                key_lua = compile(tree[1])
+            if #tree == 0
-                key_str = match(key_lua\text!, '^"([a-zA-Z_][a-zA-Z0-9_]*)"$')
+                return LuaCode\from tree.source, tree.type, "{}"
-                return if key_str and key_str\is_lua_id!
+
-                    LuaCode\from tree.source, ".", key_str
+            lua = LuaCode\from tree.source
-                elseif sub(key_lua\text!,1,1) == "["
+            chunks = 0
-                    -- NOTE: this *must* use a space after the [ to avoid freaking out
+            i = 1
-                    -- Lua's parser if the inner expression is a long string. Lua
+            while tree[i]
-                    -- parses x[[[y]]] as x("[y]"), not as x["y"]
+                if tree[i].type == 'Block'
-                    LuaCode\from tree.source, "[ ",key_lua,"]"
+                    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)"
+                    chunks += 1
+                    i += 1
                 else
-                    LuaCode\from tree.source, "[",key_lua,"]"
+                    lua\add " + " if chunks > 0
+                    sep = ''
+                    items_lua = LuaCode\from tree[i].source
+                    while tree[i]
+                        if tree[i].type == "Block"
+                            break
+                        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'
+                            item_lua = LuaCode\from tree[i].source, item_lua, "=true"
+                        items_lua\add sep, item_lua
+                        if tree[i].type == "Comment"
+                            items_lua\add "\n"
+                            sep = ''
+                        elseif items_lua\trailing_line_len! > MAX_LINE
+                            sep = ',\n    '
+                        else
+                            sep = ', '
+                        i += 1
+                    if items_lua\is_multiline!
+                        lua\add LuaCode\from items_lua.source, tree.type, "{\n    ", items_lua, "\n}"
+                    else
+                        lua\add LuaCode\from items_lua.source, tree.type, "{", items_lua, "}"
+                    chunks += 1
+            
+            return lua
 
-            when "DictEntry"
+        when "Index"
-                key = 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
+            elseif sub(key_lua\text!,1,1) == "["
+                -- NOTE: this *must* use a space after the [ to avoid freaking out
+                -- Lua's parser if the inner expression is a long string. Lua
+                -- parses x[[[y]]] as x("[y]"), not as x["y"]
+                LuaCode\from tree.source, "[ ",key_lua,"]"
+            else
+                LuaCode\from tree.source, "[",key_lua,"]"
+
+        when "DictEntry"
+            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")
+        
+        when "IndexChain"
+            lua = @compile(tree[1])
+            if lua\text!\match("['\"}]$") or lua\text!\match("]=*]$")
+                lua\parenthesize!
+            for i=2,#tree
+                key = tree[i]
+                -- TODO: remove this shim
                 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")
+                lua\add @compile(key)
-            
+            return lua
-            when "IndexChain"
-                lua = compile(tree[1])
-                if lua\text!\match("['\"}]$") or lua\text!\match("]=*]$")
-                    lua\parenthesize!
-                for i=2,#tree
-                    key = tree[i]
-                    -- TODO: remove this shim
-                    if key.type != "Index"
-                        key = SyntaxTree{type:"Index", source:key.source, key}
-                    lua\add compile(key)
-                return lua
 
-            when "Number"
+        when "Number"
-                return LuaCode\from(tree.source, tostring(tree[1]))
+            return LuaCode\from(tree.source, tostring(tree[1]))
 
-            when "Var"
+        when "Var"
-                return LuaCode\from(tree.source, tree\as_var!\as_lua_id!)
+            return LuaCode\from(tree.source, tree\as_var!\as_lua_id!)
 
-            when "FileChunks"
+        when "FileChunks"
-                error("Can't convert FileChunks to a single block of lua, since each chunk's "..
+            error("Can't convert FileChunks to a single block of lua, since each chunk's "..
-                    "compilation depends on the earlier chunks")
+                "compilation depends on the earlier chunks")
-            
+        
-            when "Comment"
+        when "Comment"
-                return LuaCode\from(tree.source, "-- ", (tree[1]\gsub('\n', '\n-- ')))
+            return LuaCode\from(tree.source, "-- ", (tree[1]\gsub('\n', '\n-- ')))
-            
+        
-            when "Error"
+        when "Error"
-                error("Can't compile errors")
+            error("Can't compile errors")
 
-            else
+        else
-                error("Unknown type: #{tree.type}")
+            error("Unknown type: #{tree.type}")
-
-})
 
 return {:compile, :compile_error}

nomsu_decompiler.lua

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

nomsu_decompiler.moon

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

nomsu_environment.lua

@@ -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 pegpath = package.nomsupath:gsub("%.nom", ".peg")
-      local _continue_0 = false
+    do
-      repeat
+      local path = package.searchpath("nomsu." .. tostring(version), pegpath, "/")
-        if path == "." and package.nomsupath ~= "." then
+      if path then
-          _continue_0 = true
+        peg_file = io.open(path)
-          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
       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({
+local nomsu_environment
-  NOMSU_COMPILER_VERSION = 12,
+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 self:run(to_run)
-      return ret
     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 self:run(tree)
-      return ret
     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 = { },
+  new_environment = function()
-  run_file_1_in = function(path, environment, optimization, prefix)
+    local env = { }
-    if prefix == nil then
+    do
-      prefix = nil
+      local _tbl_0 = { }
-    end
+      for k, v in pairs(nomsu_environment) do
-    if not optimization then
+        _tbl_0[k] = v
-      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
-        do
-          local full_path = nomsupath == "." and path or nomsupath .. "/" .. path
-          local files = Files.list(full_path)
-          if not (files) then
-            _continue_0 = true
-            break
-          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
-              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)
-              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
+      _module_imports[env] = _tbl_0
     end
-    if not (did_anything) then
+    env[jit and "_G" or "_ENV"] = env
-      error("File not found: " .. tostring(path) .. "\n(searched in " .. tostring(package.nomsupath) .. ")", 0)
+    setmetatable(env, getmetatable(nomsu_environment))
-    end
+    return env
-    import_to_1_from(environment, mod, prefix)
+  end
-    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

nomsu_environment.moon

@@ -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("[^;]+")
+        pegpath = package.nomsupath\gsub("%.nom", ".peg")
-            continue if path == "." and package.nomsupath != "."
+        if path = package.searchpath("nomsu.#{version}", pegpath, "/")
-            peg_file = io.open(path.."/nomsu.#{version}.peg")
+            peg_file = io.open(path)
-            break if peg_file
     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{
+local nomsu_environment
-    NOMSU_COMPILER_VERSION: 12, NOMSU_SYNTAX_VERSION: max_parser_version
+_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,
+    compile: compile, compile_error_at:compile_error,
-    :_1_forked, :import_to_1_from, exit:os.exit, quit:os.exit,
+    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 @run(to_run)
-            return ret
         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 @run(tree)
-            return ret
         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
+    new_environment: ->
-        for nomsupath in package.nomsupath\gmatch("[^;]+")
+        env = {}
-            full_path = nomsupath == "." and path or nomsupath.."/"..path
+        _module_imports[env] = {k,v for k,v in pairs(nomsu_environment)}
-            files = Files.list(full_path)
+        env[jit and "_G" or "_ENV"] = env
-            continue unless files
+        setmetatable(env, getmetatable(nomsu_environment))
-            for filename in *files
+        return env
-                lua_filename = filename\gsub("%.nom$", ".lua")
+}, {
-                -- Need to check here to prevent re-running files
+    __index: (k)=> _module_imports[@][k]
-                if environment.FILE_CACHE[filename]
+})
-                    import_to_1_from(environment, environment.FILE_CACHE[filename], prefix)
+nomsu_environment[jit and "_G" or "_ENV"] = nomsu_environment
-                    did_anything = true
+nomsu_environment.COMPILE_RULES = require('bootstrap')
-                    continue
+_module_imports[nomsu_environment] = {}
-                -- 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
 
 -- Hacky use of globals:
 export SOURCE_MAP

tools/find.nom

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

tools/format.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

tools/parse.nom

@@ -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"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

tools/repl.nom

@@ -2,8 +2,8 @@
 #
     This file defines a Read-Evaluate-Print-Loop (REPL) for Nomsu
     
-use "lib/consolecolor.nom"
+use "lib/consolecolor"
-use "lib/os.nom"
+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":

tools/replace.nom

@@ -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/os"
-use "lib/consolecolor.nom"
+use "lib/consolecolor"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

tools/test.nom

@@ -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/os"
-use "lib/consolecolor.nom"
+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,14 +19,13 @@ for $filename in $(COMMAND LINE ARGS).extras:
             ]*)
         ")
     $file_tests = []
-    for $src = $test in $tests:
+    for $src = $test in $(test environment).TESTS:
-        if ($src.filename == $filename):
+        if $version:
-            if $version:
+            $test = ("
-                $test = ("
+                #!/usr/bin/env nomsu -V\$version
-                    #!/usr/bin/env nomsu -V\$version
+                \$test
-                    \$test
+            ")
-                ")
+        $file_tests, add {.test = $test, .source = $src}
-            $file_tests, add {.test = $test, .source = $src}
     
     unless ($file_tests is empty):
         sort $file_tests by $ -> $.source
@@ -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")

tools/upgrade.nom

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