Merge branch 'isolated'

Conflicts:
	README.md

4 files changed, 559 insertions, 383 deletions

diff --git a/README.md b/README.md
index 8f45ccb..93bc4c8 100644
--- a/README.md
+++ b/README.md
@@ -42,6 +42,22 @@ string packing modules automatically. If unsuccessful, pure Lua
 versions of the new `table` functions are used as a fallback, and
 [Roberto's struct library][1] is tried for string packing.
 
+#### Lua submodules
+
+```lua
+local _ENV = require("compat53.module")
+if setfenv then setfenv(1, _ENV) end
+```
+
+The `compat53.module` module does not modify the global environment,
+and so it is safe to use in modules without affecting other Lua files.
+It is supposed to be set as the current environment (see above), i.e.
+cherry picking individual functions from this module is expressly
+*not* supported!). Not all features are available when using this
+module (e.g. yieldable (x)pcall support, string/file methods, etc.),
+so it is recommended to use plain `require("compat53")` whenever
+possible.
+
 ### C code
 
 There are two ways of adding the C API compatibility functions/macros to
@@ -67,7 +83,7 @@ your project:
   5.3 sources or from the `struct` module. (`struct` is not 100%
   compatible to Lua 5.3's string packing!) (See [here][4])
 * `math.maxinteger` and `math.mininteger`, `math.tointeger`, `math.type`,
-  and `math.ult` (See [here][5])
+  and `math.ult` (see [here][5])
 * `ipairs` respects `__index` metamethod
 * `table.move`
 * `table` library respects metamethods
diff --git a/compat53/init.lua b/compat53/init.lua
new file mode 100644
index 0000000..31085be
--- /dev/null
+++ b/compat53/init.lua
@@ -0,0 +1,324 @@
+local _G, _VERSION, type, pairs, require =
+      _G, _VERSION, type, pairs, require
+
+local M = require("compat53.module")
+local lua_version = _VERSION:sub(-3)
+
+
+-- apply other global effects
+if lua_version == "5.1" then
+
+   -- cache globals
+   local error, pcall, rawset, select, setmetatable, tostring, unpack, xpcall =
+         error, pcall, rawset, select, setmetatable, tostring, unpack, xpcall
+   local coroutine, debug, io, package, string =
+         coroutine, debug, io, package, string
+   local coroutine_create = coroutine.create
+   local coroutine_resume = coroutine.resume
+   local coroutine_running = coroutine.running
+   local coroutine_status = coroutine.status
+   local coroutine_yield = coroutine.yield
+   local io_type, io_stdout = io.type, io.stdout
+
+   -- select the most powerful getmetatable function available
+   local gmt = type(debug) == "table" and debug.getmetatable or
+               getmetatable or function() return false end
+
+   -- detect LuaJIT (including LUAJIT_ENABLE_LUA52COMPAT compilation flag)
+   local is_luajit = (string.dump(function() end) or ""):sub(1, 3) == "\027LJ"
+   local is_luajit52 = is_luajit and
+     #setmetatable({}, { __len = function() return 1 end }) == 1
+
+
+   -- make package.searchers available as an alias for package.loaders
+   local p_index = { searchers = package.loaders }
+   setmetatable(package, {
+      __index = p_index,
+      __newindex = function(p, k, v)
+         if k == "searchers" then
+            rawset(p, "loaders", v)
+            p_index.searchers = v
+         else
+            rawset(p, k, v)
+         end
+      end
+   })
+
+
+   if not is_luajit then
+      local function helper(st, var_1, ...)
+         if var_1 == nil then
+            if (...) ~= nil then
+               error((...), 2)
+            end
+         end
+         return var_1, ...
+      end
+
+      local function lines_iterator(st)
+         return helper(st, st.f:read(unpack(st, 1, st.n)))
+      end
+
+      local valid_format = { ["*l"] = true, ["*n"] = true, ["*a"] = true }
+
+      local file_meta = gmt(io_stdout)
+      if type(file_meta) == "table" and type(file_meta.__index) == "table" then
+         local file_write = file_meta.__index.write
+         file_meta.__index.write = function(self, ...)
+            local res, msg, errno = file_write(self, ...)
+            if res then
+               return self
+            else
+               return nil, msg, errno
+            end
+         end
+
+         file_meta.__index.lines = function(self, ...)
+            if io_type(self) == "closed file" then
+               error("attempt to use a closed file", 2)
+            end
+            local st = { f=self, n=select('#', ...), ... }
+            for i = 1, st.n do
+               if type(st[i]) ~= "number" and not valid_format[st[i]] then
+                  error("bad argument #"..(i+1).." to 'for iterator' (invalid format)", 2)
+               end
+            end
+            return lines_iterator, st
+         end
+      end
+   end -- not luajit
+
+
+   -- the (x)pcall implementations start a new coroutine internally
+   -- to allow yielding even in Lua 5.1. to allow for accurate
+   -- stack traces we keep track of the nested coroutine activations
+   -- in the weak tables below:
+   local weak_meta = { __mode = "kv" }
+   -- maps the internal pcall coroutines to the user coroutine that
+   -- *should* be running if pcall didn't use coroutines internally
+   local pcall_mainOf = setmetatable({}, weak_meta)
+   -- table that maps each running coroutine started by pcall to
+   -- the coroutine that resumed it (user coroutine *or* pcall
+   -- coroutine!)
+   local pcall_previous = setmetatable({}, weak_meta)
+   -- reverse of `pcall_mainOf`. maps a user coroutine to the
+   -- currently active pcall coroutine started within it
+   local pcall_callOf = setmetatable({}, weak_meta)
+   -- similar to `pcall_mainOf` but is used only while executing
+   -- the error handler of xpcall (thus no nesting is necessary!)
+   local xpcall_running = setmetatable({}, weak_meta)
+
+   -- handle debug functions
+   if type(debug) == "table" then
+      local debug_getinfo = debug.getinfo
+      local debug_traceback = debug.traceback
+
+      if not is_luajit then
+         local function calculate_trace_level(co, level)
+            if level ~= nil then
+               for out = 1, 1/0 do
+                  local info = (co==nil) and debug_getinfo(out, "") or debug_getinfo(co, out, "")
+                  if info == nil then
+                     local max = out-1
+                     if level <= max then
+                        return level
+                     end
+                     return nil, level-max
+                  end
+               end
+            end
+            return 1
+         end
+
+         local stack_pattern = "\nstack traceback:"
+         local stack_replace = ""
+         function debug.traceback(co, msg, level)
+            local lvl
+            local nilmsg
+            if type(co) ~= "thread" then
+               co, msg, level = coroutine_running(), co, msg
+            end
+            if msg == nil then
+               msg = ""
+               nilmsg = true
+            elseif type(msg) ~= "string" then
+               return msg
+            end
+            if co == nil then
+               msg = debug_traceback(msg, level or 1)
+            else
+               local xpco = xpcall_running[co]
+               if xpco ~= nil then
+                  lvl, level = calculate_trace_level(xpco, level)
+                  if lvl then
+                     msg = debug_traceback(xpco, msg, lvl)
+                  else
+                     msg = msg..stack_pattern
+                  end
+                  lvl, level = calculate_trace_level(co, level)
+                  if lvl then
+                     local trace = debug_traceback(co, "", lvl)
+                     msg = msg..trace:gsub(stack_pattern, stack_replace)
+                  end
+               else
+                  co = pcall_callOf[co] or co
+                  lvl, level = calculate_trace_level(co, level)
+                  if lvl then
+                     msg = debug_traceback(co, msg, lvl)
+                  else
+                     msg = msg..stack_pattern
+                  end
+               end
+               co = pcall_previous[co]
+               while co ~= nil do
+                  lvl, level = calculate_trace_level(co, level)
+                  if lvl then
+                     local trace = debug_traceback(co, "", lvl)
+                     msg = msg..trace:gsub(stack_pattern, stack_replace)
+                  end
+                  co = pcall_previous[co]
+               end
+            end
+            if nilmsg then
+               msg = msg:gsub("^\n", "")
+            end
+            msg = msg:gsub("\n\t%(tail call%): %?", "\000")
+            msg = msg:gsub("\n\t%.%.%.\n", "\001\n")
+            msg = msg:gsub("\n\t%.%.%.$", "\001")
+            msg = msg:gsub("(%z+)\001(%z+)", function(some, other)
+               return "\n\t(..."..#some+#other.."+ tail call(s)...)"
+            end)
+            msg = msg:gsub("\001(%z+)", function(zeros)
+               return "\n\t(..."..#zeros.."+ tail call(s)...)"
+            end)
+            msg = msg:gsub("(%z+)\001", function(zeros)
+               return "\n\t(..."..#zeros.."+ tail call(s)...)"
+            end)
+            msg = msg:gsub("%z+", function(zeros)
+               return "\n\t(..."..#zeros.." tail call(s)...)"
+            end)
+            msg = msg:gsub("\001", function(zeros)
+               return "\n\t..."
+            end)
+            return msg
+         end
+      end -- is not luajit
+   end -- debug table available
+
+
+   local main_coroutine = coroutine_create(function() end)
+
+   if not is_luajit52 then
+      function M.coroutine.running()
+         local co = coroutine_running()
+         if co then
+            return pcall_mainOf[co] or co, false
+         else
+            return main_coroutine, true
+         end
+      end
+   end
+
+   if not is_luajit then
+      function M.coroutine.resume(co, ...)
+         if co == main_coroutine then
+            return false, "cannot resume non-suspended coroutine"
+         else
+            return coroutine_resume(co, ...)
+         end
+      end
+
+      function M.coroutine.status(co)
+         local notmain = coroutine_running()
+         if co == main_coroutine then
+            return notmain and "normal" or "running"
+         else
+            return coroutine_status(co)
+         end
+      end
+
+      local function pcall_results(current, call, success, ...)
+         if coroutine_status(call) == "suspended" then
+            return pcall_results(current, call, coroutine_resume(call, coroutine_yield(...)))
+         end
+         if pcall_previous then
+            pcall_previous[call] = nil
+            local main = pcall_mainOf[call]
+            if main == current then current = nil end
+            pcall_callOf[main] = current
+         end
+         pcall_mainOf[call] = nil
+         return success, ...
+      end
+
+      local function pcall_exec(current, call, ...)
+         local main = pcall_mainOf[current] or current
+         pcall_mainOf[call] = main
+         if pcall_previous then
+            pcall_previous[call] = current
+            pcall_callOf[main] = call
+         end
+         return pcall_results(current, call, coroutine_resume(call, ...))
+      end
+
+      local coroutine_create52 = M.coroutine.create
+
+      local function pcall_coroutine(func)
+         if type(func) ~= "function" then
+            local callable = func
+            func = function (...) return callable(...) end
+         end
+         return coroutine_create52(func)
+      end
+
+      function M.pcall(func, ...)
+         local current = coroutine_running()
+         if not current then return pcall(func, ...) end
+         return pcall_exec(current, pcall_coroutine(func), ...)
+      end
+
+      local function xpcall_catch(current, call, msgh, success, ...)
+         if not success then
+            xpcall_running[current] = call
+            local ok, result = pcall(msgh, ...)
+            xpcall_running[current] = nil
+            if not ok then
+               return false, "error in error handling ("..tostring(result)..")"
+            end
+            return false, result
+         end
+         return true, ...
+      end
+
+      function M.xpcall(f, msgh, ...)
+         local current = coroutine_running()
+         if not current then
+            local args, n = { ... }, select('#', ...)
+            return xpcall(function() return f(unpack(args, 1, n)) end, msgh)
+         end
+         local call = pcall_coroutine(f)
+         return xpcall_catch(current, call, msgh, pcall_exec(current, call, ...))
+      end
+   end -- not luajit
+
+end -- lua == 5.1
+
+
+-- handle exporting to global scope
+local function extend_table(from, to)
+   if from ~= to then
+      for k,v in pairs(from) do
+         if type(v) == "table" and
+            type(to[k]) == "table" and
+            v ~= to[k] then
+            extend_table(v, to[k])
+         else
+            to[k] = v
+         end
+      end
+   end
+end
+
+extend_table(M, _G)
+
+-- vi: set expandtab softtabstop=3 shiftwidth=3 :
diff --git a/compat53.lua b/compat53/module.lua
index 919ab33..0dd0317 100644
--- a/compat53.lua
+++ b/compat53/module.lua
@@ -1,8 +1,31 @@
+local _G, _VERSION = _G, _VERSION
 local lua_version = _VERSION:sub(-3)
 
+
+local M = _G
+
 if lua_version < "5.3" then
-   -- local aliases for commonly used functions
-   local type, select, error = type, select, error
+
+   -- cache globals in upvalues
+   local error, ipairs, pairs, pcall, require, select, setmetatable, type =
+         error, ipairs, pairs, pcall, require, select, setmetatable, type
+   local debug, math, package, string, table =
+         debug, math, package, string, table
+
+   -- create module table
+   M = {}
+   local M_meta = {
+      __index = _G,
+      -- __newindex is set at the end
+   }
+   setmetatable(M, M_meta)
+
+   -- create subtables
+   M.math = setmetatable({}, { __index = math })
+   M.string = setmetatable({}, { __index = string })
+   M.table = setmetatable({}, { __index = table })
+   M.utf8 = {}
+
 
    -- select the most powerful getmetatable function available
    local gmt = type(debug) == "table" and debug.getmetatable or
@@ -29,11 +52,13 @@ if lua_version < "5.3" then
    -- load utf8 library
    local utf8_ok, utf8lib = pcall(require, "compat53.utf8")
    if utf8_ok then
-      utf8 = utf8lib
-      package.loaded["utf8"] = utf8lib
       if lua_version == "5.1" then
          utf8lib.charpattern = "[%z\1-\127\194-\244][\128-\191]*"
       end
+      for k,v in pairs(utf8lib) do
+         M.utf8[k] = v
+      end
+      package.loaded["utf8"] = M.utf8
    end
 
 
@@ -41,7 +66,7 @@ if lua_version < "5.3" then
    local table_ok, tablib = pcall(require, "compat53.table")
    if table_ok then
       for k,v in pairs(tablib) do
-         table[k] = v
+         M.table[k] = v
       end
    end
 
@@ -50,7 +75,7 @@ if lua_version < "5.3" then
    local str_ok, strlib = pcall(require, "compat53.string")
    if str_ok then
       for k,v in pairs(strlib) do
-         string[k] = v
+         M.string[k] = v
       end
    end
 
@@ -60,9 +85,9 @@ if lua_version < "5.3" then
    if not str_ok then
       local struct_ok, struct = pcall(require, "struct")
       if struct_ok then
-         string.pack = struct.pack
-         string.packsize = struct.size
-         string.unpack = struct.unpack
+         M.string.pack = struct.pack
+         M.string.packsize = struct.size
+         M.string.unpack = struct.unpack
       end
    end
 
@@ -81,17 +106,17 @@ if lua_version < "5.3" then
          maxint = maxint
          minint = -maxint
       end
-      math.maxinteger = maxint
-      math.mininteger = minint
+      M.math.maxinteger = maxint
+      M.math.mininteger = minint
 
-      function math.tointeger(n)
+      function M.math.tointeger(n)
          if type(n) == "number" and n <= maxint and n >= minint and n % 1 == 0 then
             return n
          end
          return nil
       end
 
-      function math.type(n)
+      function M.math.type(n)
          if type(n) == "number" then
             if n <= maxint and n >= minint and n % 1 == 0 then
                return "integer"
@@ -116,7 +141,7 @@ if lua_version < "5.3" then
          end
       end
 
-      function math.ult(m, n)
+      function M.math.ult(m, n)
          m = checkinteger(m, "1", "math.ult")
          n = checkinteger(n, "2", "math.ult")
          if m >= 0 and n < 0 then
@@ -132,7 +157,6 @@ if lua_version < "5.3" then
 
    -- ipairs should respect __index metamethod
    do
-      local _ipairs = ipairs
       local function ipairs_iterator(st, var)
          var = var + 1
          local val = st[var]
@@ -140,11 +164,11 @@ if lua_version < "5.3" then
             return var, st[var]
          end
       end
-      function ipairs(t)
+      function M.ipairs(t)
          if gmt(t) ~= nil then -- t has metatable
             return ipairs_iterator, t, 0
          else
-            return _ipairs(t)
+            return ipairs(t)
          end
       end
    end
@@ -153,7 +177,12 @@ if lua_version < "5.3" then
    -- update table library (if C module not available)
    if not table_ok then
       local table_concat = table.concat
-      function table.concat(list, sep, i, j)
+      local table_insert = table.insert
+      local table_remove = table.remove
+      local table_sort = table.sort
+      local table_unpack = lua_version == "5.1" and unpack or table.unpack
+
+      function M.table.concat(list, sep, i, j)
          local mt = gmt(list)
          if type(mt) == "table" and type(mt.__len) == "function" then
             local src = list
@@ -165,8 +194,7 @@ if lua_version < "5.3" then
          return table_concat(list, sep, i, j)
       end
 
-      local table_insert = table.insert
-      function table.insert(list, ...)
+      function M.table.insert(list, ...)
          local mt = gmt(list)
          local has_mt = type(mt) == "table"
          local has_len = has_mt and type(mt.__len) == "function"
@@ -191,7 +219,7 @@ if lua_version < "5.3" then
          end
       end
 
-      function table.move(a1, f, e, t, a2)
+      function M.table.move(a1, f, e, t, a2)
          a2 = a2 or a1
          f = checkinteger(f, "2", "table.move")
          argcheck(f > 0, "2", "table.move",
@@ -208,8 +236,7 @@ if lua_version < "5.3" then
          return a2
       end
 
-      local table_remove = table.remove
-      function table.remove(list, pos)
+      function M.table.remove(list, pos)
          local mt = gmt(list)
          local has_mt = type(mt) == "table"
          local has_len = has_mt and type(mt.__len) == "function"
@@ -282,8 +309,7 @@ if lua_version < "5.3" then
             end
          end
 
-         local table_sort = table.sort
-         function table.sort(list, cmp)
+         function M.table.sort(list, cmp)
             local mt = gmt(list)
             local has_mt = type(mt) == "table"
             local has_len = has_mt and type(mt.__len) == "function"
@@ -297,7 +323,6 @@ if lua_version < "5.3" then
          end
       end
 
-      local table_unpack = lua_version == "5.1" and unpack or table.unpack
       local function unpack_helper(list, i, j, ...)
          if j < i then
             return ...
@@ -305,7 +330,7 @@ if lua_version < "5.3" then
             return unpack_helper(list, i, j-1, list[j], ...)
          end
       end
-      function table.unpack(list, i, j)
+      function M.table.unpack(list, i, j)
          local mt = gmt(list)
          local has_mt = type(mt) == "table"
          local has_len = has_mt and type(mt.__len) == "function"
@@ -319,7 +344,6 @@ if lua_version < "5.3" then
    end -- update table library
 
 
-
    -- bring Lua 5.1 (and LuaJIT) up to speed with Lua 5.2
    if lua_version == "5.1" then
       -- detect LuaJIT (including LUAJIT_ENABLE_LUA52COMPAT compilation flag)
@@ -327,31 +351,45 @@ if lua_version < "5.3" then
       local is_luajit52 = is_luajit and
         #setmetatable({}, { __len = function() return 1 end }) == 1
 
-
-      -- the (x)pcall implementations start a new coroutine internally
-      -- to allow yielding even in Lua 5.1. to allow for accurate
-      -- stack traces we keep track of the nested coroutine activations
-      -- in the weak tables below:
-      local weak_meta = { __mode = "kv" }
-      -- table that maps each running coroutine started by pcall to
-      -- the coroutine that resumed it (user coroutine *or* pcall
-      -- coroutine!)
-      local pcall_previous = setmetatable({}, weak_meta)
-      -- reverse of `pcall_mainOf`. maps a user coroutine to the
-      -- currently active pcall coroutine started within it
-      local pcall_callOf = setmetatable({}, weak_meta)
-      -- similar to `pcall_mainOf` but is used only while executing
-      -- the error handler of xpcall (thus no nesting is necessary!)
-      local xpcall_running = setmetatable({}, weak_meta)
+      -- cache globals in upvalues
+      local load, loadfile, loadstring, setfenv, unpack, xpcall =
+            load, loadfile, loadstring, setfenv, unpack, xpcall
+      local coroutine, io, os = coroutine, io, os
+      local coroutine_create = coroutine.create
+      local coroutine_resume = coroutine.resume
       local coroutine_running = coroutine.running
+      local coroutine_status = coroutine.status
+      local coroutine_yield = coroutine.yield
+      local io_input = io.input
+      local io_open = io.open
+      local io_output = io.output
+      local io_write = io.write
+      local math_log = math.log
+      local os_execute = os.execute
+      local string_find = string.find
+      local string_format = string.format
+      local string_gmatch = string.gmatch
+      local string_gsub = string.gsub
+      local string_match = string.match
+      local string_rep = string.rep
+      local table_concat = table.concat
+
+      -- create subtables
+      M.coroutine = setmetatable({}, { __index = coroutine })
+      M.io = setmetatable({}, { __index = io })
+      M.os = setmetatable({}, { __index = os })
+      M.package = setmetatable({}, { __index = package })
 
       -- handle debug functions
       if type(debug) == "table" then
+         local debug_setfenv = debug.setfenv
+         local debug_getfenv = debug.getfenv
+         local debug_setmetatable = debug.setmetatable
+
+         M.debug = setmetatable({}, { __index = debug })
 
          if not is_luajit52 then
-            local _G, package = _G, package
-            local debug_setfenv = debug.setfenv
-            function debug.setuservalue(obj, value)
+            function M.debug.setuservalue(obj, value)
                if type(obj) ~= "userdata" then
                   error("bad argument #1 to 'setuservalue' (userdata expected, got "..
                         type(obj)..")", 2)
@@ -364,8 +402,7 @@ if lua_version < "5.3" then
                return debug_setfenv(obj, value)
             end
 
-            local debug_getfenv = debug.getfenv
-            function debug.getuservalue(obj)
+            function M.debug.getuservalue(obj)
                if type(obj) ~= "userdata" then
                   return nil
                else
@@ -377,116 +414,21 @@ if lua_version < "5.3" then
                end
             end
 
-            local debug_setmetatable = debug.setmetatable
-            function debug.setmetatable(value, tab)
+            function M.debug.setmetatable(value, tab)
                debug_setmetatable(value, tab)
                return value
             end
          end -- not luajit with compat52 enabled
-
-         if not is_luajit then
-            local debug_getinfo = debug.getinfo
-            local function calculate_trace_level(co, level)
-               if level ~= nil then
-                  for out = 1, 1/0 do
-                     local info = (co==nil) and debug_getinfo(out, "") or debug_getinfo(co, out, "")
-                     if info == nil then
-                        local max = out-1
-                        if level <= max then
-                           return level
-                        end
-                        return nil, level-max
-                     end
-                  end
-               end
-               return 1
-            end
-
-            local stack_pattern = "\nstack traceback:"
-            local stack_replace = ""
-            local debug_traceback = debug.traceback
-            function debug.traceback(co, msg, level)
-               local lvl
-               local nilmsg
-               if type(co) ~= "thread" then
-                  co, msg, level = coroutine_running(), co, msg
-               end
-               if msg == nil then
-                  msg = ""
-                  nilmsg = true
-               elseif type(msg) ~= "string" then
-                  return msg
-               end
-               if co == nil then
-                  msg = debug_traceback(msg, level or 1)
-               else
-                  local xpco = xpcall_running[co]
-                  if xpco ~= nil then
-                     lvl, level = calculate_trace_level(xpco, level)
-                     if lvl then
-                        msg = debug_traceback(xpco, msg, lvl)
-                     else
-                        msg = msg..stack_pattern
-                     end
-                     lvl, level = calculate_trace_level(co, level)
-                     if lvl then
-                        local trace = debug_traceback(co, "", lvl)
-                        msg = msg..trace:gsub(stack_pattern, stack_replace)
-                     end
-                  else
-                     co = pcall_callOf[co] or co
-                     lvl, level = calculate_trace_level(co, level)
-                     if lvl then
-                        msg = debug_traceback(co, msg, lvl)
-                     else
-                        msg = msg..stack_pattern
-                     end
-                  end
-                  co = pcall_previous[co]
-                  while co ~= nil do
-                     lvl, level = calculate_trace_level(co, level)
-                     if lvl then
-                        local trace = debug_traceback(co, "", lvl)
-                        msg = msg..trace:gsub(stack_pattern, stack_replace)
-                     end
-                     co = pcall_previous[co]
-                  end
-               end
-               if nilmsg then
-                  msg = msg:gsub("^\n", "")
-               end
-               msg = msg:gsub("\n\t%(tail call%): %?", "\000")
-               msg = msg:gsub("\n\t%.%.%.\n", "\001\n")
-               msg = msg:gsub("\n\t%.%.%.$", "\001")
-               msg = msg:gsub("(%z+)\001(%z+)", function(some, other)
-                  return "\n\t(..."..#some+#other.."+ tail call(s)...)"
-               end)
-               msg = msg:gsub("\001(%z+)", function(zeros)
-                  return "\n\t(..."..#zeros.."+ tail call(s)...)"
-               end)
-               msg = msg:gsub("(%z+)\001", function(zeros)
-                  return "\n\t(..."..#zeros.."+ tail call(s)...)"
-               end)
-               msg = msg:gsub("%z+", function(zeros)
-                  return "\n\t(..."..#zeros.." tail call(s)...)"
-               end)
-               msg = msg:gsub("\001", function(zeros)
-                  return "\n\t..."
-               end)
-               return msg
-            end
-         end -- is not luajit
       end -- debug table available
 
 
       if not is_luajit52 then
-         local _pairs = pairs
-         function pairs(t)
+         function M.pairs(t)
             local mt = gmt(t)
             if type(mt) == "table" and type(mt.__pairs) == "function" then
                return mt.__pairs(t)
             else
-               return _pairs(t)
+               return pairs(t)
             end
          end
       end
@@ -506,9 +448,7 @@ if lua_version < "5.3" then
             end
          end
 
-         local setfenv = setfenv
-         local _load, _loadstring = load, loadstring
-         function load(ld, source, mode, env)
+         function M.load(ld, source, mode, env)
             mode = mode or "bt"
             local chunk, msg
             if type( ld ) == "string" then
@@ -516,7 +456,7 @@ if lua_version < "5.3" then
                   local merr = check_mode(mode, ld)
                   if merr then return nil, merr end
                end
-               chunk, msg = _loadstring(ld, source)
+               chunk, msg = loadstring(ld, source)
             else
                local ld_type = type(ld)
                if ld_type ~= "function" then
@@ -536,10 +476,10 @@ if lua_version < "5.3" then
                         return v
                      end
                   end
-                  chunk, msg = _load(checked_ld, source)
+                  chunk, msg = load(checked_ld, source)
                   if merr then return nil, merr end
                else
-                  chunk, msg = _load(ld, source)
+                  chunk, msg = load(ld, source)
                end
             end
             if not chunk then
@@ -551,11 +491,9 @@ if lua_version < "5.3" then
             return chunk
          end
 
-         loadstring = load
+         M.loadstring = load
 
-         local _loadfile = loadfile
-         local io_open = io.open
-         function loadfile(file, mode, env)
+         function M.loadfile(file, mode, env)
             mode = mode or "bt"
             if mode ~= "bt" then
                local f = io_open(file, "rb")
@@ -568,7 +506,7 @@ if lua_version < "5.3" then
                   end
                end
             end
-            local chunk, msg = _loadfile(file)
+            local chunk, msg = loadfile(file)
             if not chunk then
                return chunk, msg
             end
@@ -581,7 +519,7 @@ if lua_version < "5.3" then
 
 
       if not is_luajit52 then
-         function rawlen(v)
+         function M.rawlen(v)
             local t = type(v)
             if t ~= "string" and t ~= "table" then
                error("bad argument #1 to 'rawlen' (table or string expected)", 2)
@@ -591,33 +529,38 @@ if lua_version < "5.3" then
       end
 
 
+      if not is_luajit then
+         function M.xpcall(f, msgh, ...)
+            local args, n = { ... }, select('#', ...)
+            return xpcall(function() return f(unpack(args, 1, n)) end, msgh)
+         end
+      end
+
+
       if not is_luajit52 then
-         local os_execute = os.execute
-         function os.execute(cmd)
+         function M.os.execute(cmd)
             local code = os_execute(cmd)
             -- Lua 5.1 does not report exit by signal.
             if code == 0 then
                return true, "exit", code
             else
-               return nil, "exit", code/256 -- only correct on POSIX!
+               return nil, "exit", code/256 -- only correct on Linux!
             end
          end
       end
 
 
       if not table_ok and not is_luajit52 then
-         table.pack = function(...)
+         M.table.pack = function(...)
             return { n = select('#', ...), ... }
          end
       end
 
 
-      local main_coroutine = coroutine.create(function() end)
+      local main_coroutine = coroutine_create(function() end)
 
-      local _pcall = pcall
-      local coroutine_create = coroutine.create
-      function coroutine.create(func)
-         local success, result = _pcall(coroutine_create, func)
+      function M.coroutine.create(func)
+         local success, result = pcall(coroutine_create, func)
          if not success then
             if type(func) ~= "function" then
                error("bad argument #1 (function expected)", 0)
@@ -627,23 +570,18 @@ if lua_version < "5.3" then
          return result
       end
 
-      -- maps the internal pcall coroutines to the user coroutine that
-      -- *should* be running if pcall didn't use coroutines internally
-      local pcall_mainOf = setmetatable({}, weak_meta)
-
       if not is_luajit52 then
-         function coroutine.running()
+         function M.coroutine.running()
             local co = coroutine_running()
             if co then
-               return pcall_mainOf[co] or co, false
+               return co, false
             else
                return main_coroutine, true
             end
          end
       end
 
-      local coroutine_yield = coroutine.yield
-      function coroutine.yield(...)
+      function M.coroutine.yield(...)
          local co, flag = coroutine_running()
          if co and not flag then
             return coroutine_yield(...)
@@ -653,8 +591,7 @@ if lua_version < "5.3" then
       end
 
       if not is_luajit then
-         local coroutine_resume = coroutine.resume
-         function coroutine.resume(co, ...)
+         function M.coroutine.resume(co, ...)
             if co == main_coroutine then
                return false, "cannot resume non-suspended coroutine"
             else
@@ -662,8 +599,7 @@ if lua_version < "5.3" then
             end
          end
 
-         local coroutine_status = coroutine.status
-         function coroutine.status(co)
+         function M.coroutine.status(co)
             local notmain = coroutine_running()
             if co == main_coroutine then
                return notmain and "normal" or "running"
@@ -671,73 +607,11 @@ if lua_version < "5.3" then
                return coroutine_status(co)
             end
          end
-
-         local function pcall_results(current, call, success, ...)
-            if coroutine_status(call) == "suspended" then
-               return pcall_results(current, call, coroutine_resume(call, coroutine_yield(...)))
-            end
-            if pcall_previous then
-               pcall_previous[call] = nil
-               local main = pcall_mainOf[call]
-               if main == current then current = nil end
-               pcall_callOf[main] = current
-            end
-            pcall_mainOf[call] = nil
-            return success, ...
-         end
-         local function pcall_exec(current, call, ...)
-            local main = pcall_mainOf[current] or current
-            pcall_mainOf[call] = main
-            if pcall_previous then
-               pcall_previous[call] = current
-               pcall_callOf[main] = call
-            end
-            return pcall_results(current, call, coroutine_resume(call, ...))
-         end
-         local coroutine_create52 = coroutine.create
-         local function pcall_coroutine(func)
-            if type(func) ~= "function" then
-               local callable = func
-               func = function (...) return callable(...) end
-            end
-            return coroutine_create52(func)
-         end
-         function pcall(func, ...)
-            local current = coroutine_running()
-            if not current then return _pcall(func, ...) end
-            return pcall_exec(current, pcall_coroutine(func), ...)
-         end
-
-         local _tostring = tostring
-         local function xpcall_catch(current, call, msgh, success, ...)
-            if not success then
-               xpcall_running[current] = call
-               local ok, result = _pcall(msgh, ...)
-               xpcall_running[current] = nil
-               if not ok then
-                  return false, "error in error handling (".._tostring(result)..")"
-               end
-               return false, result
-            end
-            return true, ...
-         end
-         local _xpcall = xpcall
-         local _unpack = unpack
-         function xpcall(f, msgh, ...)
-            local current = coroutine_running()
-            if not current then
-               local args, n = { ... }, select('#', ...)
-               return _xpcall(function() return f(_unpack(args, 1, n)) end, msgh)
-            end
-            local call = pcall_coroutine(f)
-            return xpcall_catch(current, call, msgh, pcall_exec(current, call, ...))
-         end
       end -- not luajit
 
 
       if not is_luajit then
-         local math_log = math.log
-         math.log = function(x, base)
+         M.math.log = function(x, base)
             if base ~= nil then
                return math_log(x)/math_log(base)
             else
@@ -747,11 +621,8 @@ if lua_version < "5.3" then
       end
 
 
-      local package = package
       if not is_luajit then
-         local io_open = io.open
-         local table_concat = table.concat
-         function package.searchpath(name, path, sep, rep)
+         function M.package.searchpath(name, path, sep, rep)
             sep = (sep or "."):gsub("(%p)", "%%%1")
             rep = (rep or package.config:sub(1, 1)):gsub("(%%)", "%%%1")
             local pname = name:gsub(sep, rep):gsub("(%%)", "%%%1")
@@ -769,48 +640,29 @@ if lua_version < "5.3" then
          end
       end
 
-      local p_index = { searchers = package.loaders }
-      local rawset = rawset
-      setmetatable(package, {
-         __index = p_index,
-         __newindex = function(p, k, v)
-            if k == "searchers" then
-               rawset(p, "loaders", v)
-               p_index.searchers = v
-            else
-               rawset(p, k, v)
-            end
-         end
-      })
-
 
-      local string_gsub = string.gsub
       local function fix_pattern(pattern)
          return (string_gsub(pattern, "%z", "%%z"))
       end
 
-      local string_find = string.find
-      function string.find(s, pattern, ...)
+      function M.string.find(s, pattern, ...)
          return string_find(s, fix_pattern(pattern), ...)
       end
 
-      local string_gmatch = string.gmatch
-      function string.gmatch(s, pattern)
+      function M.string.gmatch(s, pattern)
          return string_gmatch(s, fix_pattern(pattern))
       end
 
-      function string.gsub(s, pattern, ...)
+      function M.string.gsub(s, pattern, ...)
          return string_gsub(s, fix_pattern(pattern), ...)
       end
 
-      local string_match = string.match
-      function string.match(s, pattern, ...)
+      function M.string.match(s, pattern, ...)
          return string_match(s, fix_pattern(pattern), ...)
       end
 
       if not is_luajit then
-         local string_rep = string.rep
-         function string.rep(s, n, sep)
+         function M.string.rep(s, n, sep)
             if sep ~= nil and sep ~= "" and n >= 2 then
                return s .. string_rep(sep..s, n-1)
             else
@@ -820,7 +672,6 @@ if lua_version < "5.3" then
       end
 
       if not is_luajit then
-         local string_format = string.format
          do
             local addqt = {
                ["\n"] = "\\\n",
@@ -832,15 +683,14 @@ if lua_version < "5.3" then
                return addqt[c] or string_format("\\%03d", c:byte())
             end
 
-            local _unpack = unpack
-            function string.format(fmt, ...)
+            function M.string.format(fmt, ...)
                local args, n = { ... }, select('#', ...)
                local i = 0
                local function adjust_fmt(lead, mods, kind)
                   if #lead % 2 == 0 then
                      i = i + 1
                      if kind == "s" then
-                        args[i] = tostring(args[i])
+                        args[i] = _G.tostring(args[i])
                      elseif kind == "q" then
                         args[i] = '"'..string_gsub(args[i], "[%z%c\\\"\n]", addquoted)..'"'
                         return lead.."%"..mods.."s"
@@ -848,16 +698,13 @@ if lua_version < "5.3" then
                   end
                end
                fmt = string_gsub(fmt, "(%%*)%%([%d%.%-%+%# ]*)(%a)", adjust_fmt)
-               return string_format(fmt, _unpack(args, 1, n))
+               return string_format(fmt, unpack(args, 1, n))
             end
          end
       end
 
 
-      local io_open = io.open
-      local io_write = io.write
-      local io_output = io.output
-      function io.write(...)
+      function M.io.write(...)
          local res, msg, errno = io_write(...)
          if res then
             return io_output()
@@ -867,28 +714,23 @@ if lua_version < "5.3" then
       end
 
       if not is_luajit then
-         local lines_iterator
-         do
-            local function helper( st, var_1, ... )
-               if var_1 == nil then
-                  if st.doclose then st.f:close() end
-                  if (...) ~= nil then
-                     error((...), 2)
-                  end
+         local function helper(st, var_1, ...)
+            if var_1 == nil then
+               if st.doclose then st.f:close() end
+               if (...) ~= nil then
+                  error((...), 2)
                end
-               return var_1, ...
             end
+            return var_1, ...
+         end
 
-            local _unpack = unpack
-            function lines_iterator(st)
-               return helper(st, st.f:read(_unpack(st, 1, st.n)))
-            end
+         local function lines_iterator(st)
+            return helper(st, st.f:read(unpack(st, 1, st.n)))
          end
 
          local valid_format = { ["*l"] = true, ["*n"] = true, ["*a"] = true }
 
-         local io_input = io.input
-         function io.lines(fname, ...)
+         function M.io.lines(fname, ...)
             local doclose, file, msg
             if fname ~= nil then
                doclose, file, msg = true, io_open(fname, "r")
@@ -904,41 +746,17 @@ if lua_version < "5.3" then
             end
             return lines_iterator, st
          end
-
-         do
-            local io_stdout = io.stdout
-            local io_type = io.type
-            local file_meta = gmt(io_stdout)
-            if type(file_meta) == "table" and type(file_meta.__index) == "table" then
-               local file_write = file_meta.__index.write
-               file_meta.__index.write = function(self, ...)
-                  local res, msg, errno = file_write(self, ...)
-                  if res then
-                     return self
-                  else
-                     return nil, msg, errno
-                  end
-               end
-
-               file_meta.__index.lines = function(self, ...)
-                  if io_type(self) == "closed file" then
-                     error("attempt to use a closed file", 2)
-                  end
-                  local st = { f=self, doclose=false, n=select('#', ...), ... }
-                  for i = 1, st.n do
-                     if type(st[i]) ~= "number" and not valid_format[st[i]] then
-                        error("bad argument #"..(i+1).." to 'for iterator' (invalid format)", 2)
-                     end
-                  end
-                  return lines_iterator, st
-               end
-            end
-         end
       end -- not luajit
 
-
    end -- lua 5.1
 
+   -- further write should be forwarded to _G
+   M_meta.__newindex = _G
+
 end -- lua < 5.3
 
+
+-- return module table
+return M
+
 -- vi: set expandtab softtabstop=3 shiftwidth=3 :
diff --git a/tests/test.lua b/tests/test.lua
index 83e174e..856230b 100755
--- a/tests/test.lua
+++ b/tests/test.lua
@@ -36,14 +36,26 @@ end
 local V = _VERSION:gsub("^.*(%d+)%.(%d+)$", "%1%2")
 if jit then V = "jit" end
 
-print( "testing Lua API ..." )
-package.path = "../?.lua;"..package.path
+local mode = "global"
+if arg[1] == "module" then
+  mode = "module"
+end
+
+
+package.path = "../?.lua;../?/init.lua;"..package.path
 package.cpath = "./?-"..V..".so;./?-"..V..".dll;./?.so;./?.dll"
-require("compat53")
+if mode == "module" then
+  print( "testing Lua API using `compat53.module` ..." )
+  _ENV = require("compat53.module")
+  if setfenv then setfenv(1, _ENV) end
+else
+  print( "testing Lua API using `compat53` ..." )
+  require("compat53")
+end
 
 ___''
 do
-  local t = setmetatable( {}, { __index = { 1, false, "three" } } )
+  local t = setmetatable({}, { __index = { 1, false, "three" } })
   for i,v in ipairs(t) do
     print("ipairs", i, v)
   end
@@ -338,22 +350,24 @@ do
    print("xpcall()", xpcall(func, debug.traceback, false))
    print("xpcall()", xpcall(func, debug.traceback, true))
    print("xpcall()", xpcall(func, tb, true))
-   local function func2(cb)
-     print("xpcall()", xpcall(cb, debug.traceback, "str"))
-   end
-   local function func3(cb)
-     print("pcall()", pcall(cb, "str"))
+   if mode ~= "module" then
+     local function func2(cb)
+       print("xpcall()", xpcall(cb, debug.traceback, "str"))
+     end
+     local function func3(cb)
+       print("pcall()", pcall(cb, "str"))
+     end
+     local function cb(arg)
+        coroutine.yield(2)
+        return arg
+     end
+     local c = coroutine.wrap(func2)
+     print("xpcall()", c(cb))
+     print("xpcall()", c())
+     local c = coroutine.wrap(func3)
+     print("pcall()", c(cb))
+     print("pcall()", c())
    end
-   local function cb(arg)
-      coroutine.yield(2)
-      return arg
-   end
-   local c = coroutine.wrap(func2)
-   print("xpcall()", c(cb))
-   print("xpcall()", c())
-   local c = coroutine.wrap(func3)
-   print("pcall()", c(cb))
-   print("pcall()", c())
 end
 
 
@@ -387,9 +401,11 @@ do
    print("coroutine.running()", F(coroutine.running()))
    local main_co, co1, co2 = coroutine.running()
    -- coroutine.yield
-   print("coroutine.yield()", pcall(function()
-      coroutine.yield(1, 2, 3)
-   end))
+   if mode ~= "module" then
+     print("coroutine.yield()", pcall(function()
+        coroutine.yield(1, 2, 3)
+     end))
+   end
    print("coroutine.yield()", coroutine.wrap(function()
       coroutine.yield(1, 2, 3)
    end)())
@@ -428,13 +444,13 @@ do
    local path, prefix = "./?.lua;?/init.lua;../?.lua", "package.searchpath()"
    print(prefix, package.searchpath("no.such.module", path))
    print(prefix, package.searchpath("no.such.module", ""))
-   print(prefix, package.searchpath("compat52", path))
+   print(prefix, package.searchpath("compat53", path))
    print(prefix, package.searchpath("no:such:module", path, ":", "|"))
 end
 
 
 ___''
-do
+if mode ~= "module" then
    local function mod_func() return {} end
    local function my_searcher(name)
       if name == "my.module" then
@@ -462,19 +478,19 @@ end
 
 ___''
 do
-   print("string.find()", ("abc\0abc\0abc"):find("[^a\0]+"))
-   print("string.find()", ("abc\0abc\0abc"):find("%w+\0", 5))
-   for x in ("abc\0def\0ghi"):gmatch("[^\0]+") do
+   print("string.find()", string.find("abc\0abc\0abc", "[^a\0]+"))
+   print("string.find()", string.find("abc\0abc\0abc", "%w+\0", 5))
+   for x in string.gmatch("abc\0def\0ghi", "[^\0]+") do
       print("string.gmatch()", x)
    end
-   for x in ("abc\0def\0ghi"):gmatch("%w*\0") do
+   for x in string.gmatch("abc\0def\0ghi", "%w*\0") do
       print("string.gmatch()", #x)
    end
-   print("string.gsub()", ("abc\0def\0ghi"):gsub("[\0]", "X"))
-   print("string.gsub()", ("abc\0def\0ghi"):gsub("%w*\0", "X"))
-   print("string.gsub()", ("abc\0def\0ghi"):gsub("%A", "X"))
-   print("string.match()", ("abc\0abc\0abc"):match("([^\0a]+)"))
-   print("string.match()", #("abc\0abc\0abc"):match(".*\0"))
+   print("string.gsub()", string.gsub("abc\0def\0ghi", "[\0]", "X"))
+   print("string.gsub()", string.gsub("abc\0def\0ghi", "%w*\0", "X"))
+   print("string.gsub()", string.gsub("abc\0def\0ghi", "%A", "X"))
+   print("string.match()", string.match("abc\0abc\0abc", "([^\0a]+)"))
+   print("string.match()", #string.match("abc\0abc\0abc", ".*\0"))
    print("string.rep()", string.rep("a", 0))
    print("string.rep()", string.rep("b", 1))
    print("string.rep()", string.rep("c", 4))
@@ -533,30 +549,32 @@ do
    print("io.lines()", pcall(function()
       for l in io.lines("no_such_file.txt") do print(l) end
    end))
-   local f = assert(io.open("test.lua", "r"))
-   for a,b in f:lines(2, "*l") do
-      print("file:lines()", a, b)
-      break
+   if mode ~= "module" then
+     local f = assert(io.open("test.lua", "r"))
+     for a,b in f:lines(2, "*l") do
+        print("file:lines()", a, b)
+        break
+     end
+     f:close()
+     f = assert(io.open("data.txt", "r"))
+     for n1,n2,rest in f:lines("*n", "*n", "*a") do
+        print("file:lines()", n1, n2, rest)
+     end
+     f:close()
+     f = assert(io.open("data.txt", "r"))
+     for l in f:lines() do
+        print("file:lines()", l)
+     end
+     f:close()
+     print("file:lines()", pcall(function()
+        for l in f:lines() do print(l) end
+     end))
+     print("file:lines()", pcall(function()
+        local f = assert(io.open("data.txt", "r"))
+        for l in f:lines("*l", "*x") do print(l) end
+        f:close()
+     end))
    end
-   f:close()
-   f = assert(io.open("data.txt", "r"))
-   for n1,n2,rest in f:lines("*n", "*n", "*a") do
-      print("file:lines()", n1, n2, rest)
-   end
-   f:close()
-   f = assert(io.open("data.txt", "r"))
-   for l in f:lines() do
-      print("file:lines()", l)
-   end
-   f:close()
-   print("file:lines()", pcall(function()
-      for l in f:lines() do print(l) end
-   end))
-   print("file:lines()", pcall(function()
-      local f = assert(io.open("data.txt", "r"))
-      for l in f:lines("*l", "*x") do print(l) end
-      f:close()
-   end))
    os.remove("data.txt")
 end
 ___''