Auto-upgraded everything.

compatibility/2.3.nom

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

compatibility/2.4.nom

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

compatibility/2.5.5.5.nom

@@ -1,12 +1,12 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines upgrades from Nomsu <2.5.5.5 to Nomsu 2.5.5.5
 
 use "compatibility/compatibility.nom"
 
 upgrade action [hash %, sha1 %] to "2.5.5.5" as (..)
-    =lua ".."
+    =lua "\
-        \(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)
+        ..\(base64 decode (hash %)):gsub('.', function(c) return ('%x02'):format(c) end)"
 
 upgrade action [file with hash %] to "2.5.5.5" as (..)
     file with hash (..)

compatibility/2.5.nom

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

compatibility/2.nom

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

compatibility/3.5.5.6.nom

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

compatibility/3.6.nom

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

compatibility/3.7.nom

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

compatibility/3.nom

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

compatibility/compatibility.nom

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

core/collections.nom

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

core/control_flow.nom

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

core/coroutines.nom

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

core/errors.nom

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

core/id.nom

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

core/io.nom

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

core/math.nom

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

core/metaprogramming.nom

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

core/operators.nom

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

core/scopes.nom

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

core/text.nom

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

examples/how_do_i.nom

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

lib/base64.nom

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

lib/consolecolor.nom

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

lib/file_hash.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     This file defines some actions for hashing files and looking up files by hash.
 
@@ -8,21 +8,21 @@ use "lib/base64.nom"
 lua> "local \%use_sha1, \%hashlib = pcall(require, 'openssl.digest')"
 
 test:
-    assume ((hash "hello world") == (hash "hello world"))
+    assume (hash "hello world") == (hash "hello world")
-    assume ((hash "hello world") != (hash "goodbye")) or barf ".."
+    assume ((hash "hello world") != (hash "goodbye")) or barf "\
-        Hash collision:
+        ..Hash collision:
             (hash "hello world") = \(hash "hello world")
-            (hash "goodbye") = \(hash "goodbye")
+            (hash "goodbye") = \(hash "goodbye")"
     
     assume (..)
         (..)
-            hash ".."
+            hash "\
-                This is a really long string meant to stress test the hashing function and
+                ..This is a really long string meant to stress test the hashing function and
-                ensure that it's not overflowing with long inputs.
+                ensure that it's not overflowing with long inputs."
         ..!= "inf"
     
-    assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf ".."
+    assume ((hash "\000") != (hash "\000\000\000\000\000")) or barf "\
-        Incorrect hashing of null strings
+        ..Incorrect hashing of null strings"
     if %use_sha1:
         assume ((hash "hello world") == "Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
 if %use_sha1:
@@ -31,8 +31,8 @@ if %use_sha1:
         return (base64 %hash)
 ..else:
     # TODO: remove warning?
-    say ".."
+    say "\
-        \027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m
+        ..\027[31;1mWARNING: OpenSSL module not found. Defaulting to a non-cryptographically secure hash function.\027[0m"
     action [hash %]:
         %bytes = (%::bytes)
         %hash = (%bytes.1 << 7)

lib/object.nom

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

lib/os.nom

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

lib/training_wheels.nom

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

lib/version.nom

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

nomsu.4.peg

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

nomsu.lua

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

nomsu.moon

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

nomsu_compiler.lua

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

nomsu_compiler.moon

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

pretty_errors.lua

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

pretty_errors.moon

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

syntax_tree.lua

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

syntax_tree.moon

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

tools/autoformat.nom

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

tools/find_action.nom

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

tools/parse.nom

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

tools/replace.nom

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

tools/test.nom

@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V3.8.7.6
+#!/usr/bin/env nomsu -V4.8.8.6
 #
     Tool to run all tests in a file (i.e. the code block inside a call to 'test %'). Usage:
         nomsu tools/test.nom file1 file2 directory1 ...

tools/upgrade.nom

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