Refactor compat53 and compat53.module Lua modules.

The new compat53.module module contains only changes that don't affect
other files, and it is supposed to be used in modules like this:

    local _ENV = require( "compat53.module" )
    if setfenv then setfenv( 1, _ENV ) end

compat53.module does not change string/file metatables, and it also
doesn't support yielding from (x)pcall.

The compat53 module copies all functions from compat53.module to the
global environment, and additionally sets string/file metatables and
implements yieldable (x)pcall.

1 files changed, 234 insertions, 13 deletions

diff --git a/compat53/init.lua b/compat53/init.lua
index cdd5f34..e5f7692 100644
--- a/compat53/init.lua
+++ b/compat53/init.lua
@@ -1,7 +1,7 @@
 local _G, _VERSION, type, pairs, require =
       _G, _VERSION, type, pairs, require
 
-local M = require("compat53.base")
+local M = require("compat53.module")
 local lua_version = _VERSION:sub(-3)
 
 
@@ -9,9 +9,15 @@ local lua_version = _VERSION:sub(-3)
 if lua_version == "5.1" then
 
    -- cache globals
-   local error, rawset, select, setmetatable, type, unpack =
-         error, rawset, select, setmetatable, type, unpack
-   local debug, io, package, string = debug, io, package, string
+   local error, pcall, rawset, select, setmetatable, tostring, type, unpack, xpcall =
+         error, pcall, rawset, select, setmetatable, tostring, type, 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
@@ -20,6 +26,8 @@ if lua_version == "5.1" then
 
    -- 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
@@ -80,24 +88,237 @@ if lua_version == "5.1" then
       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 _G.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 _G.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)
-   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
+   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)
 
-return _G
-
 -- vi: set expandtab softtabstop=3 shiftwidth=3 :