Merge lp:~widelands-dev/widelands/lua_eris into lp:widelands

[SirVer]

This is meant for merging after b18. It gets rid of some subtle persistence bugs in Lua like bug 1237016. This brings the following changes:

- kill our hacked and modified version of Pluto and instead include a pristine, unchanged version of Eris and use this for persistence (https://github.com/fnuecke/eris).
- This also means that we no longer depend on Lua 5.1 to be on the system as Eris brings Lua 5.2 with it. That also means that players with the same Widelands version use the exact same persistence and Lua logic - which is a good thing, though I am not aware that we had trouble with inconsistencies between Lua's minor versions before.
- Makes the necessary changes so that widelands runs with Lua 5.2. This brought a bunch of code simplifications with it - But **killed safegame compatibility for all safegames**.
- Some code cleanups and removal of bad c++ style like virtual inheritance.

This is meant for merging after b18. It gets rid of some subtle persistence bugs in Lua like bug 1237016. This brings the following changes:

- kill our hacked and modified version of Pluto and instead include a pristine, unchanged version of Eris and use this for persistence (https://github.com/fnuecke/eris).
- This also means that we no longer depend on Lua 5.1 to be on the system as Eris brings Lua 5.2 with it. That also means that players with the same Widelands version use the exact same persistence and Lua logic - which is a good thing, though I am not aware that we had trouble with inconsistencies between Lua's minor versions before.
- Makes the necessary changes so that widelands runs with Lua 5.2. This brought a bunch of code simplifications with it - But **killed safegame compatibility for all safegames**.
- Some code cleanups and removal of bad c++ style like virtual inheritance.

Todos:
- our Cmake setup is not equipped to compile .c files it seems, so I am not sure if the CFLAGS are set correctly (or at all). Works on my system though :P. Also, lua sets some cflags depending on which system it compiles, but they should not be needed. Jens, could you look into this?
- As this breaks safegame compatiblity anyways, we can use this to get rid of cruft - compatibilty wares, backwards compatible loading branches for old safegames and so on.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-12-29 16:10:29 +0000
+++ CMakeLists.txt	2014-02-22 14:58:17 +0000
@@ -477,9 +477,6 @@
   message(FATAL_ERROR "Required package SDL_gfx not found, please install and re-run cmake")
 endif (NOT SDLGFX_FOUND)
 
-find_package(Lua51 REQUIRED)
-include_directories(${LUA_INCLUDE_DIR})
-
 IF (WIN32)
   SET(GUI_TYPE WIN32)
 ENDIF (WIN32)

=== modified file 'CREDITS'
--- CREDITS	2012-06-20 09:59:07 +0000
+++ CREDITS	2014-02-22 14:58:17 +0000
@@ -75,9 +75,9 @@
     * http://www.lua.org
 
 
-    Pluto
-    * by Ben Sunshine-Hill, Rob Hoelz
-    * http://luaforge.net/projects/pluto/
+    Eris
+    * by Florian Nücke
+    * https://github.com/fnuecke/eris
 
 
     Lodepng (for testing, not in Widelands itself)

=== modified file 'doc/sphinx/source/implementation.rst'
--- doc/sphinx/source/implementation.rst	2012-06-20 09:07:10 +0000
+++ doc/sphinx/source/implementation.rst	2014-02-22 14:58:17 +0000
@@ -104,20 +104,18 @@
 -----------
 
 When a savegame is created, the current environment of Lua is persisted. For
-this, I used a library called Pluto_ which is in the public domain. It was
-heavily modified to work with widelands, the ``FileRead`` and ``FileWrite``
-classes and with the Luna class concepts.
+this, I used a library called Eris_.  
 
-.. _Pluto: http://luaforge.net/projects/pluto/
+.. _Eris: https://github.com/fnuecke
  
 The global environment is persisted into the file map/globals.dump. Everything
 is persisted except of the Lua build-in functions and everything in the ``wl``
-table. Those are c-functions that can not be written out to disk portably.
-Everything else can be saved, that is also everything in the auxiliary scripts
-are saved to disk, so save games only depend on the API defined inside the
-``wl`` module.
+table and some of our own global functions. Those are c-functions that can not
+be written out to disk portably. Everything else can be saved, that is also
+everything in the auxiliary scripts are saved to disk, so save games only
+depend on the API defined inside the Widelands.
 
-Coroutines are persisted together with their ``Cmd_LuaCoroutine`` package. 
+Coroutines are persisted in their ``Cmd_LuaCoroutine`` package. 
 
 Luna classes have to implement two functions to be properly persistable:
 
@@ -130,9 +128,10 @@
 ``__unpersist(lua_State *)``
    On loading, an instance of the user object is created via the default
    constructor. This function is then called with the table that was created
-   by ``__persist()`` on the top of the stack. The object is then expected to
-   recreate it's former state with this table. There are equivalent
-   unpersisting macros defined to help with this task (e.g. UNPERS_UINT32).
+   by ``__persist()`` as an upvalue (because it is inside a closure). The
+   object is then expected to recreate it's former state with this table.
+   There are equivalent unpersisting macros defined to help with this task
+   (e.g. UNPERS_UINT32).
 
 Widelands reassigns some serial number upon saving and restores them upon
 loading. Some Luna classes need this information (for example

=== modified file 'regression_test.py'
--- regression_test.py	2014-01-15 21:12:05 +0000
+++ regression_test.py	2014-02-22 14:58:17 +0000
@@ -36,6 +36,7 @@
             if os.path.exists(self.run_dir):
                 if not self.keep_output_around:
                     shutil.rmtree(self.run_dir)
+                    os.makedirs(self.run_dir)
             else:
                 os.makedirs(self.run_dir)
         self.widelands_returncode = 0

=== modified file 'scripting/format_help.lua'
--- scripting/format_help.lua	2012-03-06 22:14:31 +0000
+++ scripting/format_help.lua	2014-02-22 14:58:17 +0000
@@ -19,7 +19,7 @@
 	end
 
 	string = "image=" .. images[1]
-	for k,v in ipairs({unpack(images,2)}) do
+	for k,v in ipairs({table.unpack(images,2)}) do
 		string = string .. ";pics/arrow-right.png;" .. v
 	end
 
@@ -81,4 +81,4 @@
         tab_picture = "pics/medium.png",
      }
   }
-end
\ No newline at end of file
+end

=== modified file 'scripting/infrastructure.lua'
--- scripting/infrastructure.lua	2013-10-05 07:50:17 +0000
+++ scripting/infrastructure.lua	2014-02-22 14:58:17 +0000
@@ -44,7 +44,7 @@
       moves[#moves+1] = m:sub(1,-2)
       if(m:sub(-1) == '|') then
          moves[#moves+1] = true -- Force the road
-         r = p:place_road(start, unpack(moves))
+         r = p:place_road(start, table.unpack(moves))
          start = r.end_flag
          if create_carriers then
             r:set_workers("carrier", 1)

=== modified file 'scripting/lunit.lua'
--- scripting/lunit.lua	2013-10-10 20:39:19 +0000
+++ scripting/lunit.lua	2014-02-22 14:58:17 +0000
@@ -28,60 +28,18 @@
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+
+    This file was heavily modified for the internal use of Widelands.
+
 --]]--------------------------------------------------------------------------
 
-
-
-
------------------------
--- Intialize package --
------------------------
-
-local P = { }
-lunit = P
-
--- Import
-local type = type
-local print = print
-local ipairs = ipairs
-local pairs = pairs
-local string = string
-local table = table
-local pcall = pcall
-local xpcall = xpcall
-local debug = debug
-local assert = assert
-local error = error
-local setmetatable = setmetatable
-local rawset = rawset
-local getfenv = getfenv
-local setfenv = setfenv
-local tostring = tostring
-
-
--- Start package scope
-setfenv(1, P)
-
-
-
-
---------------------------------
--- Private data and functions --
---------------------------------
-
-local run_testcase
-local do_assert, check_msg
-local stats = { }
-local testcases = { }
-local stats_inc, tc_mt
-
-
-
+lunit = {}
+lunit.testcases = {}
+lunit.stats = {}
 
 --------------------------
 -- Type check functions --
 --------------------------
-
 function is_nil(x)
   return type(x) == "nil"
 end
@@ -114,229 +72,198 @@
   return type(x) == "userdata"
 end
 
-
-
-
 ----------------------
 -- Assert functions --
 ----------------------
-
 function assert_fail(msg)
-  stats_inc("assertions")
-  check_msg("assert_fail", msg)
-  do_assert(false, "failure", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_fail", msg)
+  lunit_do_assert(false, "failure", msg)
 end
 
-
 function assert_true(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_true", msg)
-  do_assert(is_boolean(actual), "true expected but was a "..type(actual), msg)
-  do_assert(actual == true, "true expected but was false", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_true", msg)
+  lunit_do_assert(is_boolean(actual), "true expected but was a "..type(actual), msg)
+  lunit_do_assert(actual == true, "true expected but was false", msg)
   return actual
 end
 
-
 function assert_false(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_false", msg)
-  do_assert(is_boolean(actual), "false expected but was a "..type(actual), msg)
-  do_assert(actual == false, "false expected but was true", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_false", msg)
+  lunit_do_assert(is_boolean(actual), "false expected but was a "..type(actual), msg)
+  lunit_do_assert(actual == false, "false expected but was true", msg)
   return actual
 end
 
-
 function assert_equal(expected, actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_equal", msg)
-  do_assert(expected == actual, "expected '"..tostring(expected).."' but was '"..tostring(actual).."'", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_equal", msg)
+  lunit_do_assert(expected == actual, "expected '"..tostring(expected).."' but was '"..tostring(actual).."'", msg)
   return actual
 end
 
-
 function assert_not_equal(unexpected, actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_equal", msg)
-  do_assert(unexpected ~= actual, "'"..tostring(expected).."' not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_equal", msg)
+  lunit_do_assert(unexpected ~= actual, "'"..tostring(expected).."' not expected but was one", msg)
   return actual
 end
 
-
 function assert_match(pattern, actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_match", msg)
-  do_assert(is_string(pattern), "assert_match expects the pattern as a string")
-  do_assert(is_string(actual), "expected a string to match pattern '"..pattern.."' but was a '"..type(actual).."'", msg)
-  do_assert(not not string.find(actual, pattern), "expected '"..actual.."' to match pattern '"..pattern.."' but doesn't", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_match", msg)
+  lunit_do_assert(is_string(pattern), "assert_match expects the pattern as a string")
+  lunit_do_assert(is_string(actual), "expected a string to match pattern '"..pattern.."' but was a '"..type(actual).."'", msg)
+  lunit_do_assert(not not string.find(actual, pattern), "expected '"..actual.."' to match pattern '"..pattern.."' but doesn't", msg)
   return actual
 end
 
-
 function assert_not_match(pattern, actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_match", msg)
-  do_assert(is_string(actual), "expected a string to not match pattern '"..pattern.."' but was a '"..type(actual).."'", msg)
-  do_assert(string.find(actual, pattern) == nil, "expected '"..actual.."' to not match pattern '"..pattern.."' but it does", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_match", msg)
+  lunit_do_assert(is_string(actual), "expected a string to not match pattern '"..pattern.."' but was a '"..type(actual).."'", msg)
+  lunit_do_assert(string.find(actual, pattern) == nil, "expected '"..actual.."' to not match pattern '"..pattern.."' but it does", msg)
   return actual
 end
 
-
 function assert_nil(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_nil", msg)
-  do_assert(is_nil(actual), "nil expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_nil", msg)
+  lunit_do_assert(is_nil(actual), "nil expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_nil(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_nil", msg)
-  do_assert(not is_nil(actual), "nil not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_nil", msg)
+  lunit_do_assert(not is_nil(actual), "nil not expected but was one", msg)
   return actual
 end
 
-
 function assert_boolean(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_boolean", msg)
-  do_assert(is_boolean(actual), "boolean expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_boolean", msg)
+  lunit_do_assert(is_boolean(actual), "boolean expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_boolean(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_boolean", msg)
-  do_assert(not is_boolean(actual), "boolean not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_boolean", msg)
+  lunit_do_assert(not is_boolean(actual), "boolean not expected but was one", msg)
   return actual
 end
 
-
 function assert_number(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_number", msg)
-  do_assert(is_number(actual), "number expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_number", msg)
+  lunit_do_assert(is_number(actual), "number expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_number(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_number", msg)
-  do_assert(not is_number(actual), "number not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_number", msg)
+  lunit_do_assert(not is_number(actual), "number not expected but was one", msg)
   return actual
 end
 
-
 function assert_string(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_string", msg)
-  do_assert(is_string(actual), "string expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_string", msg)
+  lunit_do_assert(is_string(actual), "string expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_string(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_string", msg)
-  do_assert(not is_string(actual), "string not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_string", msg)
+  lunit_do_assert(not is_string(actual), "string not expected but was one", msg)
   return actual
 end
 
-
 function assert_table(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_table", msg)
-  do_assert(is_table(actual), "table expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_table", msg)
+  lunit_do_assert(is_table(actual), "table expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_table(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_table", msg)
-  do_assert(not is_table(actual), "table not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_table", msg)
+  lunit_do_assert(not is_table(actual), "table not expected but was one", msg)
   return actual
 end
 
-
 function assert_function(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_function", msg)
-  do_assert(is_function(actual), "function expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_function", msg)
+  lunit_do_assert(is_function(actual), "function expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_function(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_function", msg)
-  do_assert(not is_function(actual), "function not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_function", msg)
+  lunit_do_assert(not is_function(actual), "function not expected but was one", msg)
   return actual
 end
 
-
 function assert_thread(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_thread", msg)
-  do_assert(is_thread(actual), "thread expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_thread", msg)
+  lunit_do_assert(is_thread(actual), "thread expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_thread(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_thread", msg)
-  do_assert(not is_thread(actual), "thread not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_thread", msg)
+  lunit_do_assert(not is_thread(actual), "thread not expected but was one", msg)
   return actual
 end
 
-
 function assert_userdata(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_userdata", msg)
-  do_assert(is_userdata(actual), "userdata expected but was a "..type(actual), msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_userdata", msg)
+  lunit_do_assert(is_userdata(actual), "userdata expected but was a "..type(actual), msg)
   return actual
 end
 
-
 function assert_not_userdata(actual, msg)
-  stats_inc("assertions")
-  check_msg("assert_not_userdata", msg)
-  do_assert(not is_userdata(actual), "userdata not expected but was one", msg)
+  lunit_stats_inc("assertions")
+  lunit_check_msg("assert_not_userdata", msg)
+  lunit_do_assert(not is_userdata(actual), "userdata not expected but was one", msg)
   return actual
 end
 
-
 function assert_error(msg, func)
-  stats_inc("assertions")
+  lunit_stats_inc("assertions")
   if is_nil(func) then func, msg = msg, nil end
-  check_msg("assert_error", msg)
-  do_assert(is_function(func), "assert_error expects a function as the last argument but it was a "..type(func))
+  lunit_check_msg("assert_error", msg)
+  lunit_do_assert(is_function(func), "assert_error expects a function as the last argument but it was a "..type(func))
   local ok, errmsg = pcall(func)
-  do_assert(ok == false, "error expected but no error occurred", msg)
+  lunit_do_assert(ok == false, "error expected but no error occurred", msg)
 end
 
-
 function assert_pass(msg, func)
-  stats_inc("assertions")
+  lunit_stats_inc("assertions")
   if is_nil(func) then func, msg = msg, nil end
-  check_msg("assert_pass", msg)
-  do_assert(is_function(func), "assert_pass expects a function as the last argument but it was a "..type(func))
+  lunit_check_msg("assert_pass", msg)
+  lunit_do_assert(is_function(func), "assert_pass expects a function as the last argument but it was a "..type(func))
   local ok, errmsg = pcall(func)
-  if not ok then do_assert(ok == true, "no error expected but error was: "..errmsg, msg) end
+  if not ok then lunit_do_assert(ok == true, "no error expected but error was: "..errmsg, msg) end
 end
 
 
-
-
 -----------------------------------------------------------
 -- Assert implementation that assumes it was called from --
 -- lunit code which was called directly from user code.  --
 -----------------------------------------------------------
-
-function do_assert(assertion, base_msg, user_msg)
+function lunit_do_assert(assertion, base_msg, user_msg)
   assert(is_boolean(assertion))
   assert(is_string(base_msg))
   assert(is_string(user_msg) or is_nil(user_msg))
@@ -352,8 +279,7 @@
 -------------------------------------------
 -- Checks the msg argument in assert_xxx --
 -------------------------------------------
-
-function check_msg(name, msg)
+function lunit_check_msg(name, msg)
   assert(is_string(name))
   if not (is_nil(msg) or is_string(msg)) then
     error("lunit."..name.."() expects the optional message as a string but it was a "..type(msg).."!" ,3)
@@ -361,26 +287,23 @@
 end
 
 
-
-
 -------------------------------------
 -- Creates a new TestCase 'Object' --
 -------------------------------------
-
-function TestCase(name)
-  do_assert(is_string(name), "lunit.TestCase() needs a string as an argument")
+function lunit.TestCase(name)
+  lunit_do_assert(is_string(name), "lunit.TestCase() needs a string as an argument")
   local tc = {
     __lunit_name = name;
     __lunit_setup = nil;
     __lunit_tests = { };
     __lunit_teardown = nil;
   }
-  setmetatable(tc, tc_mt)
-  table.insert(testcases, tc)
+  setmetatable(tc, lunit.tc_mt)
+  table.insert(lunit.testcases, tc)
   return tc
 end
 
-tc_mt = {
+lunit.tc_mt = {
   __newindex = function(tc, key, value)
     rawset(tc, key, value)
     if is_string(key) and is_function(value) then
@@ -396,84 +319,69 @@
   end
 }
 
-
-
 -----------------------------------------
 -- Wrap Functions in a TestCase object --
 -----------------------------------------
-
 function wrap(name, ...)
   if is_function(name) then
     table.insert(arg, 1, name)
     name = "Anonymous Testcase"
   end
 
-  local tc = TestCase(name)
+  local tc = lunit.TestCase(name)
   for index, test in ipairs(arg) do
     tc["Test #"..tostring(index)] = test
   end
   return tc
 end
 
-
-
-
-
-
 ----------------------------------
 -- Runs the complete Test Suite --
 ----------------------------------
-
-function run()
-
+function lunit.run()
   ---------------------------
   -- Initialize statistics --
   ---------------------------
-
-  stats.testcases = 0	-- Total number of Test Cases
-  stats.tests = 0	-- Total number of all Tests in all Test Cases
-  stats.run = 0		-- Number of Tests run
-  stats.notrun = 0	-- Number of Tests not run
-  stats.failed = 0	-- Number of Tests failed
-  stats.passed = 0	-- Number of Test passed
-  stats.assertions = 0	-- Number of all assertions made in all Test in all Test Cases
+  lunit.stats.ntestcases = 0	-- Total number of Test Cases
+  lunit.stats.tests = 0	-- Total number of all Tests in all Test Cases
+  lunit.stats.run = 0		-- Number of Tests run
+  lunit.stats.notrun = 0	-- Number of Tests not run
+  lunit.stats.failed = 0	-- Number of Tests failed
+  lunit.stats.passed = 0	-- Number of Test passed
+  lunit.stats.assertions = 0	-- Number of all assertions made in all Test in all Test Cases
 
   --------------------------------
   -- Count Test Cases and Tests --
   --------------------------------
-
-  stats.testcases = table.getn(testcases)
-
-  for _, tc in ipairs(testcases) do
-    stats_inc("tests" , table.getn(tc.__lunit_tests))
+  lunit.stats.ntestcases = #lunit.testcases
+
+  for _, tc in ipairs(lunit.testcases) do
+    lunit_stats_inc("tests" , #tc.__lunit_tests)
   end
 
   ------------------
   -- Print Header --
   ------------------
-
   print()
-  print("#### Test Suite with "..stats.tests.." Tests in "..stats.testcases.." Test Cases loaded.")
+  print("#### Test Suite with "..lunit.stats.tests.." Tests in "..lunit.stats.ntestcases.." Test Cases loaded.")
 
   ------------------------
   -- Run all Test Cases --
   ------------------------
-
-  for _, tc in ipairs(testcases) do
-    run_testcase(tc)
+  for _, tc in ipairs(lunit.testcases) do
+    lunit_run_testcase(tc)
   end
 
   ------------------
   -- Print Footer --
   ------------------
-
   print()
   print("#### Test Suite finished.")
 
-  local msg_assertions = stats.assertions.." Assertions checked. "
-  local msg_passed     = stats.passed == stats.tests and "All Tests passed" or  stats.passed.." Tests passed"
-  local msg_failed     = stats.failed > 0 and ", "..stats.failed.." failed" or ""
-  local msg_run	       = stats.notrun > 0 and ", "..stats.notrun.." not run" or ""
+  local msg_assertions = lunit.stats.assertions.." Assertions checked. "
+  local msg_passed     = lunit.stats.passed == lunit.stats.tests and "All Tests passed" or  lunit.stats.passed.." Tests passed"
+  local msg_failed     = lunit.stats.failed > 0 and ", "..lunit.stats.failed.." failed" or ""
+  local msg_run	       = lunit.stats.notrun > 0 and ", "..lunit.stats.notrun.." not run" or ""
 
   print()
   print(msg_assertions..msg_passed..msg_failed..msg_run.."!")
@@ -481,23 +389,17 @@
   -----------------
   -- Return code --
   -----------------
-
-  if stats.passed == stats.tests then
+  if lunit.stats.passed == lunit.stats.tests then
     return 0
   else
     return 1
   end
 end
 
-
-
-
 -----------------------------
 -- Runs a single Test Case --
 -----------------------------
-
-function run_testcase(tc)
-
+function lunit_run_testcase(tc)
   assert(is_table(tc))
   assert(is_table(tc.__lunit_tests))
   assert(is_string(tc.__lunit_name))
@@ -507,7 +409,6 @@
   --------------------------------------------
   -- Protected call to a Test Case function --
   --------------------------------------------
-
   local function call(errprefix, func)
     assert(is_string(errprefix))
     assert(is_function(func))
@@ -522,7 +423,6 @@
   ------------------------------------
   -- Calls setup() on the Test Case --
   ------------------------------------
-
   local function setup()
     if tc.__lunit_setup then
       return call("ERROR: setup() failed", tc.__lunit_setup)
@@ -534,15 +434,14 @@
   ------------------------------------------
   -- Calls a single Test on the Test Case --
   ------------------------------------------
-
   local function run(testname)
     assert(is_string(testname))
     assert(is_function(tc[testname]))
     local ok = call("FAIL: "..testname, tc[testname])
     if not ok then
-      stats_inc("failed")
+      lunit_stats_inc("failed")
     else
-      stats_inc("passed")
+      lunit_stats_inc("passed")
     end
     return ok
   end
@@ -550,7 +449,6 @@
   ---------------------------------------
   -- Calls teardown() on the Test Case --
   ---------------------------------------
-
   local function teardown()
      if tc.__lunit_teardown then
        call("WARNING: teardown() failed", tc.__lunit_teardown)
@@ -560,117 +458,28 @@
   ---------------------------------
   -- Run all Tests on a TestCase --
   ---------------------------------
-
   print()
-  print("#### Running '"..tc.__lunit_name.."' ("..table.getn(tc.__lunit_tests).." Tests)...")
+  print("#### Running '"..tc.__lunit_name.."' ("..#tc.__lunit_tests.." Tests)...")
 
   for _, testname in ipairs(tc.__lunit_tests) do
     if setup() then
       run(testname)
-      stats_inc("run")
+      lunit_stats_inc("run")
       teardown()
     else
       print("WARN: Skipping '"..testname.."'...")
-      stats_inc("notrun")
-    end
-  end
-
-end
-
-
-
-
----------------------
--- Import function --
----------------------
-
-function import(name)
-
-  do_assert(is_string(name), "lunit.import() expects a single string as argument")
-
-  local user_env = getfenv(2)
-
-  --------------------------------------------------
-  -- Installs a specific function in the user env --
-  --------------------------------------------------
-
-  local function install(funcname)
-    user_env[funcname] = P[funcname]
-  end
-
-
-  ----------------------------------------------------------
-  -- Install functions matching a pattern in the user env --
-  ----------------------------------------------------------
-
-  local function install_pattern(pattern)
-    for funcname, _ in pairs(P) do
-      if string.find(funcname, pattern) then
-        install(funcname)
-      end
-    end
-  end
-
-  ------------------------------------------------------------
-  -- Installs assert() and all assert_xxx() in the user env --
-  ------------------------------------------------------------
-
-  local function install_asserts()
-    install_pattern("^assert.*")
-  end
-
-  -------------------------------------------
-  -- Installs all is_xxx() in the user env --
-  -------------------------------------------
-
-  local function install_tests()
-    install_pattern("^is_.+")
-  end
-
-  if name == "asserts" or name == "assertions" then
-    install_asserts()
-  elseif name == "tests" or name == "checks" then
-    install_tests()
-  elseif name == "all" then
-    install_asserts()
-    install_tests()
-    install("TestCase")
-  elseif string.find(name, "^assert.*") and P[name] then
-    install(name)
-  elseif string.find(name, "^is_.+") and P[name] then
-    install(name)
-  elseif name == "TestCase" then
-    install("TestCase")
-  else
-    error("luniit.import(): invalid function '"..name.."' to import", 2)
-  end
-end
-
-
-
-
---------------------------------------------------
--- Installs a private environment on the caller --
---------------------------------------------------
-
-function setprivfenv()
-  local new_env = { }
-  local new_env_mt = { __index = getfenv(2) }
-  setmetatable(new_env, new_env_mt)
-  setfenv(2, new_env)
-end
-
-
-
+      lunit_stats_inc("notrun")
+    end
+  end
+end
 
 --------------------------------------------------
 -- Increments a counter in the statistics table --
 --------------------------------------------------
-
-function stats_inc(varname, value)
-  assert(is_table(stats))
+function lunit_stats_inc(varname, value)
+  assert(is_table(lunit.stats))
   assert(is_string(varname))
   assert(is_nil(value) or is_number(value))
-  if not stats[varname] then return end
-  stats[varname] = stats[varname] + (value or 1)
+  if not lunit.stats[varname] then return end
+  lunit.stats[varname] = lunit.stats[varname] + (value or 1)
 end

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2012-11-30 18:16:47 +0000
+++ src/CMakeLists.txt	2014-02-22 14:58:17 +0000
@@ -36,10 +36,10 @@
     list (REMOVE_ITEM WL_SRCS_CC ${sourcefile})
     list (REMOVE_ITEM WL_SRCS_H ${sourcefile})
   endif (${sourcefile} MATCHES ".*/test/.*")
-  # exclude test sources from Codecheck, as well as the scripting/pdep sources from lua
-  if (NOT ${sourcefile} MATCHES ".*/scripting/pdep/.*" AND NOT ${sourcefile} MATCHES ".*/test/.*")
+  # exclude test sources from Codecheck, as well as the scripting/eris sources from lua
+  if (NOT ${sourcefile} MATCHES ".*/scripting/eris/.*" AND NOT ${sourcefile} MATCHES ".*/test/.*")
     list (APPEND WL_CODECHECK_SRCS ${sourcefile})
-  endif (NOT ${sourcefile} MATCHES ".*/scripting/pdep/.*" AND NOT ${sourcefile} MATCHES ".*/test/.*")
+  endif (NOT ${sourcefile} MATCHES ".*/scripting/eris/.*" AND NOT ${sourcefile} MATCHES ".*/test/.*")
 endforeach (sourcefile ${WL_SRCS_CC} ${WL_SRCS_H})
 foreach (sourcefile ${WL_SRCS_CPP})
   list (APPEND WL_CODECHECK_SRCS ${sourcefile})
@@ -91,29 +91,31 @@
   # Tests need to link with SDL library without main
   set(TEST_EXTRA_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/build_info.cc)
   set(TEST_EXTRA_LIBS ${SDL_LIBRARY} )
-  list(REMOVE_ITEM TEST_EXTRA_LIBS  ${SDLMAIN_LIBRARY}) 
+  list(REMOVE_ITEM TEST_EXTRA_LIBS  ${SDLMAIN_LIBRARY})
 
   add_subdirectory(economy)
   add_subdirectory(io)
-  add_subdirectory(scripting)
 endif (WL_UNIT_TESTS)
 
+add_subdirectory(scripting)
+
 if (NOT MINIZIP_FOUND)
   add_subdirectory(minizip)
   target_link_libraries(widelands_all wl_minizip)
 endif (NOT MINIZIP_FOUND)
 
+target_link_libraries(widelands_all eris)
 target_link_libraries(widelands_all ${SDLIMAGE_LIBRARY})
 target_link_libraries(widelands_all ${SDLMIXER_LIBRARY})
 target_link_libraries(widelands_all ${SDLNET_LIBRARY})
 target_link_libraries(widelands_all ${SDLTTF_LIBRARY})
 target_link_libraries(widelands_all ${SDLGFX_LIBRARY})
-target_link_libraries(widelands_all ${LUA_LIBRARY})
 target_link_libraries(widelands_all ${PNG_LIBRARY})
 target_link_libraries(widelands_all ${ZLIB_LIBRARY})
 target_link_libraries(widelands_all ${OPENGL_gl_LIBRARY})
 target_link_libraries(widelands_all ${GLEW_LIBRARY})
 target_link_libraries(widelands_all ${Boost_SIGNALS_LIBRARY})
+
 if (MINIZIP_FOUND)
   target_link_libraries(widelands_all ${MINIZIP_LIBRARY})
 endif (MINIZIP_FOUND)

=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2013-07-26 20:19:36 +0000
+++ src/ai/defaultai.cc	2014-02-22 14:58:17 +0000
@@ -279,7 +279,7 @@
 				bld.get_ismine() ? BuildingObserver::MINE :
 				BuildingObserver::PRODUCTIONSITE;
 
-			container_iterate_const(Ware_Types, prod.inputs(), j)
+			container_iterate_const(BillOfMaterials, prod.inputs(), j)
 				bo.inputs.push_back(j.current->first.value());
 
 			container_iterate_const

=== renamed file 'src/logic/ware_types.h' => 'src/logic/bill_of_materials.h'
--- src/logic/ware_types.h	2013-07-26 20:19:36 +0000
+++ src/logic/bill_of_materials.h	2014-02-22 14:58:17 +0000
@@ -25,12 +25,13 @@
 #include "logic/widelands.h"
 
 namespace Widelands {
-typedef std::vector<std::pair<Ware_Index, uint32_t> > Ware_Types;
+typedef std::pair<Ware_Index, uint32_t> WareAmount;
+typedef std::vector<WareAmount> BillOfMaterials;
 
 // range structure for iterating ware range with index
 struct ware_range
 {
-	ware_range(const Ware_Types & range) :
+	ware_range(const BillOfMaterials & range) :
 		i(0), current(range.begin()), end(range.end()) {}
 	ware_range & operator++ () {
 		++i; ++current; return *this;
@@ -39,9 +40,9 @@
 	operator bool() const {return not empty();}
 
 	uint8_t i;
-	Ware_Types::const_iterator current;
+	BillOfMaterials::const_iterator current;
 private:
-	Ware_Types::const_iterator const end;
+	BillOfMaterials::const_iterator const end;
 };
 
 }

=== modified file 'src/logic/building.h'
--- src/logic/building.h	2013-10-08 20:13:35 +0000
+++ src/logic/building.h	2014-02-22 14:58:17 +0000
@@ -28,10 +28,10 @@
 
 #include "ai/ai_hints.h"
 #include "io/filewrite.h"
+#include "logic/bill_of_materials.h"
 #include "logic/buildcost.h"
 #include "logic/immovable.h"
 #include "logic/soldier_counts.h"
-#include "logic/ware_types.h"
 #include "logic/wareworker.h"
 #include "logic/widelands.h"
 #include "workarea_info.h"

=== modified file 'src/logic/cmd_luacoroutine.cc'
--- src/logic/cmd_luacoroutine.cc	2013-07-26 20:19:36 +0000
+++ src/logic/cmd_luacoroutine.cc	2014-02-22 14:58:17 +0000
@@ -55,7 +55,7 @@
 	}
 }
 
-#define CMD_LUACOROUTINE_VERSION 1
+#define CMD_LUACOROUTINE_VERSION 2
 void Cmd_LuaCoroutine::Read
 	(FileRead & fr, Editor_Game_Base & egbase, Map_Map_Object_Loader & mol)
 {

=== modified file 'src/logic/editor_game_base.cc'
--- src/logic/editor_game_base.cc	2013-08-06 10:40:54 +0000
+++ src/logic/editor_game_base.cc	2014-02-22 14:58:17 +0000
@@ -69,7 +69,7 @@
 m_lasttrackserial   (0)
 {
 	if (not m_lua) // TODO SirVer: this is sooo ugly, I can't say
-		m_lua = create_LuaEditorInterface(this);
+		m_lua = new LuaEditorInterface(this);
 
 	g_sound_handler.m_egbase = this;
 

=== modified file 'src/logic/game.cc'
--- src/logic/game.cc	2013-10-16 19:29:35 +0000
+++ src/logic/game.cc	2014-02-22 14:58:17 +0000
@@ -128,7 +128,7 @@
 
 
 Game::Game() :
-	Editor_Game_Base(create_LuaGameInterface(this)),
+	Editor_Game_Base(new LuaGameInterface(this)),
 	m_syncwrapper         (*this, m_synchash),
 	m_ctrl                (0),
 	m_writereplay         (true),

=== modified file 'src/logic/production_program.cc'
--- src/logic/production_program.cc	2013-08-14 10:39:59 +0000
+++ src/logic/production_program.cc	2014-02-22 14:58:17 +0000
@@ -66,7 +66,7 @@
 	(char            * & parameters,
 	 Ware_Type_Group   & group,
 	 const Tribe_Descr & tribe,
-	 const Ware_Types  & inputs)
+	 const BillOfMaterials  & inputs)
 {
 	std::set<Ware_Index>::iterator last_insert_pos = group.first.end();
 	uint8_t count     = 1;
@@ -80,7 +80,7 @@
 		char const terminator = *parameters;
 		*parameters = '\0';
 		Ware_Index const ware_index = tribe.safe_ware_index(ware);
-		for (wl_const_range<Ware_Types> i(inputs);; ++i)
+		for (wl_const_range<BillOfMaterials> i(inputs);; ++i)
 			if (i.empty())
 				throw game_data_error
 					(_

=== modified file 'src/logic/production_program.h'
--- src/logic/production_program.h	2013-09-22 18:01:36 +0000
+++ src/logic/production_program.h	2014-02-22 14:58:17 +0000
@@ -31,9 +31,9 @@
 #include "container_iterate.h"
 #include "io/filewrite.h"
 #include "log.h"
+#include "logic/bill_of_materials.h"
 #include "logic/program_result.h"
 #include "logic/tattribute.h"
-#include "logic/ware_types.h"
 #include "logic/widelands.h"
 
 struct Profile;
@@ -80,7 +80,7 @@
 		(char            * & parameters,
 		 Ware_Type_Group   & group,
 		 const Tribe_Descr & tribe,
-		 const Ware_Types  & inputs);
+		 const BillOfMaterials  & inputs);
 
 	/// Returns from the program.
 	///

=== modified file 'src/logic/productionsite.cc'
--- src/logic/productionsite.cc	2013-09-23 18:47:02 +0000
+++ src/logic/productionsite.cc	2014-02-22 14:58:17 +0000
@@ -84,7 +84,7 @@
 		while (Section::Value const * const val = s->get_next_val())
 			try {
 				if (Ware_Index const idx = tribe().ware_index(val->get_name())) {
-					container_iterate_const(Ware_Types, inputs(), i)
+					container_iterate_const(BillOfMaterials, inputs(), i)
 						if (i.current->first == idx)
 							throw wexception("duplicated");
 					int32_t const value = val->get_int();
@@ -104,7 +104,7 @@
 		while (Section::Value const * const v = working_positions_s->get_next_val())
 			try {
 				if (Ware_Index const woi = tribe().worker_index(v->get_name())) {
-					container_iterate_const(Ware_Types, working_positions(), i)
+					container_iterate_const(BillOfMaterials, working_positions(), i)
 						if (i.current->first == woi)
 							throw wexception("duplicated");
 					m_working_positions.push_back(std::pair<Ware_Index, uint32_t>(woi, v->get_positive()));
@@ -365,8 +365,7 @@
 {
 	Building::init(egbase);
 
-
-	const Ware_Types & inputs = descr().inputs();
+	const BillOfMaterials & inputs = descr().inputs();
 	m_input_queues.resize(inputs.size());
 	for (ware_range i(inputs); i; ++i)
 		m_input_queues[i.i] =
@@ -377,7 +376,7 @@
 
 	//  Request missing workers.
 	Working_Position * wp = m_working_positions;
-	container_iterate_const(Ware_Types, descr().working_positions(), i) {
+	container_iterate_const(BillOfMaterials, descr().working_positions(), i) {
 		Ware_Index const worker_index = i.current->first;
 		for (uint32_t j = i.current->second; j; --j, ++wp)
 			if (Worker * const worker = wp->worker)
@@ -490,7 +489,7 @@
 	molog("%s leaving\n", w.descname().c_str());
 	Working_Position * wp = m_working_positions;
 
-	container_iterate_const(Ware_Types, descr().working_positions(), i) {
+	container_iterate_const(BillOfMaterials, descr().working_positions(), i) {
 		Ware_Index const worker_index = i.current->first;
 		for (uint32_t j = i.current->second; j; --j, ++wp) {
 			Worker * const worker = wp->worker;

=== modified file 'src/logic/productionsite.h'
--- src/logic/productionsite.h	2013-09-23 18:47:02 +0000
+++ src/logic/productionsite.h	2014-02-22 14:58:17 +0000
@@ -26,10 +26,10 @@
 #include <string>
 #include <vector>
 
+#include "logic/bill_of_materials.h"
 #include "logic/building.h"
 #include "logic/production_program.h"
 #include "logic/program_result.h"
-#include "logic/ware_types.h"
 
 namespace Widelands {
 
@@ -64,11 +64,11 @@
 
 	uint32_t nr_working_positions() const {
 		uint32_t result = 0;
-		container_iterate_const(Ware_Types, working_positions(), i)
+		container_iterate_const(BillOfMaterials, working_positions(), i)
 			result += i.current->second;
 		return result;
 	}
-	const Ware_Types & working_positions() const {
+	const BillOfMaterials & working_positions() const {
 		return m_working_positions;
 	}
 	bool is_output_ware_type  (const Ware_Index& i) const {
@@ -77,7 +77,7 @@
 	bool is_output_worker_type(const Ware_Index& i) const {
 		return m_output_worker_types.count(i);
 	}
-	const Ware_Types & inputs() const {return m_inputs;}
+	const BillOfMaterials & inputs() const {return m_inputs;}
 	typedef std::set<Ware_Index>                       Output;
 	const Output   & output_ware_types  () const {return m_output_ware_types;}
 	const Output   & output_worker_types() const {return m_output_worker_types;}
@@ -89,8 +89,8 @@
 	const std::vector<std::string> & compatibility_working_positions(const std::string & workername) const;
 
 private:
-	Ware_Types m_working_positions;
-	Ware_Types m_inputs;
+	BillOfMaterials m_working_positions;
+	BillOfMaterials m_inputs;
 	Output   m_output_ware_types;
 	Output   m_output_worker_types;
 	Programs m_programs;

=== modified file 'src/logic/tribe.cc'
--- src/logic/tribe.cc	2013-10-08 20:13:35 +0000
+++ src/logic/tribe.cc	2014-02-22 14:58:17 +0000
@@ -298,7 +298,7 @@
 			}
 
 			// Read initializations -- all scripts are initializations currently
-			ScriptContainer & scripts =
+			const ScriptContainer& scripts =
 				egbase.lua().get_scripts_for("tribe_" + tribename);
 			container_iterate_const(ScriptContainer, scripts, s) {
 				std::unique_ptr<LuaTable> t =
@@ -376,7 +376,7 @@
 	buf            += name;
 	buf            += "/conf";
 
-	LuaInterface * lua = create_LuaInterface();
+	LuaInterface lua;
 	FileRead f;
 	if (f.TryOpen(*g_fs, buf.c_str())) {
 		if (info)
@@ -389,30 +389,25 @@
 				std::string path = "tribes/" + name + "/scripting";
 				if (g_fs->IsDirectory(path)) {
 					std::unique_ptr<FileSystem> sub_fs(g_fs->MakeSubFileSystem(path));
-					lua->register_scripts(*sub_fs, "tribe_" + name, "");
+					lua.register_scripts(*sub_fs, "tribe_" + name, "");
 				}
 
-				ScriptContainer & scripts = lua->get_scripts_for("tribe_" + name);
+				const ScriptContainer& scripts = lua.get_scripts_for("tribe_" + name);
 				container_iterate_const(ScriptContainer, scripts, s) {
 					std::unique_ptr<LuaTable> t =
-						lua->run_script("tribe_" + name, s->first);
+						lua.run_script("tribe_" + name, s->first);
 
 					info->initializations.push_back
 						(TribeBasicInfo::Initialization
 						 	(s->first, t->get_string("name")));
 				}
 			} catch (const _wexception & e) {
-				delete lua;
 				throw game_data_error
 					("reading basic info for tribe \"%s\": %s",
 					 name.c_str(), e.what());
 			}
-
-		delete lua;
 		return true;
 	}
-
-	delete lua;
 	return false;
 }
 

=== modified file 'src/map_io/widelands_map_buildingdata_data_packet.cc'
--- src/map_io/widelands_map_buildingdata_data_packet.cc	2013-10-08 20:13:35 +0000
+++ src/map_io/widelands_map_buildingdata_data_packet.cc	2014-02-22 14:58:17 +0000
@@ -876,7 +876,7 @@
 			ProductionSite::Working_Position & wp_begin =
 				*productionsite.m_working_positions;
 			const ProductionSite_Descr & pr_descr = productionsite.descr();
-			const Ware_Types & working_positions = pr_descr.working_positions();
+			const BillOfMaterials & working_positions = pr_descr.working_positions();
 
 			uint16_t nr_worker_requests = fr.Unsigned16();
 			for (uint16_t i = nr_worker_requests; i; --i) {
@@ -892,7 +892,7 @@
 				//  Find a working position that matches this request.
 				ProductionSite::Working_Position * wp = &wp_begin;
 				for
-					(wl_const_range<Ware_Types>
+					(wl_const_range<BillOfMaterials>
 					 j(working_positions);;
 					 ++j)
 				{
@@ -973,7 +973,7 @@
 				const Worker_Descr & worker_descr = worker->descr();
 				ProductionSite::Working_Position * wp = &wp_begin;
 				for
-					(wl_const_range<Ware_Types> j(working_positions);;
+					(wl_const_range<BillOfMaterials> j(working_positions);;
 					 ++j)
 				{
 					if (j.empty())

=== modified file 'src/map_io/widelands_map_scripting_data_packet.cc'
--- src/map_io/widelands_map_scripting_data_packet.cc	2013-10-08 20:13:35 +0000
+++ src/map_io/widelands_map_scripting_data_packet.cc	2014-02-22 14:58:17 +0000
@@ -30,6 +30,9 @@
 
 namespace Widelands {
 
+namespace {
+const int SCRIPTING_DATA_PACKET_VERSION=1;
+}  // namespace
 /*
  * ========================================================================
  *            PUBLIC IMPLEMENTATION
@@ -51,6 +54,12 @@
 	upcast(Game, g, &egbase);
 	Widelands::FileRead fr;
 	if (g and fr.TryOpen(fs, "scripting/globals.dump")) {
+		const uint32_t	sentinel = fr.Unsigned32();
+		const uint32_t	packet_version = fr.Unsigned32();
+		if (sentinel != 0xDEADBEEF && packet_version != SCRIPTING_DATA_PACKET_VERSION) {
+			throw game_data_error(
+			   "This savegame is from an older version of Widelands and can not be loaded any more.");
+		}
 		upcast(LuaGameInterface, lgi, &g->lua());
 		lgi->read_global_env(fr, mol, fr.Unsigned32());
 	}
@@ -60,11 +69,11 @@
 void Map_Scripting_Data_Packet::Write
 	(FileSystem & fs, Editor_Game_Base & egbase, Map_Map_Object_Saver & mos)
 {
-	ScriptContainer & p = egbase.lua().get_scripts_for("map");
+	const ScriptContainer& p = egbase.lua().get_scripts_for("map");
 
 	fs.EnsureDirectoryExists("scripting");
 
-	for (ScriptContainer::iterator i = p.begin(); i != p.end(); ++i) {
+	for (ScriptContainer::const_iterator i = p.begin(); i != p.end(); ++i) {
 		std::string fname = "scripting/";
 		fname += i->first;
 		fname += ".lua";
@@ -74,9 +83,10 @@
 
 	// Dump the global environment if this is a game and not in the editor
 	if (upcast(Game, g, &egbase)) {
-
 		Widelands::FileWrite fw;
-		Widelands::FileWrite::Pos pos = fw.GetPos();
+		fw.Unsigned32(0xDEADBEEF);  // Sentinel, because there was no packet version.
+		fw.Unsigned32(SCRIPTING_DATA_PACKET_VERSION);
+		const Widelands::FileWrite::Pos pos = fw.GetPos();
 		fw.Unsigned32(0); // N bytes written, follows below
 
 		upcast(LuaGameInterface, lgi, &g->lua());

=== modified file 'src/network/netclient.cc'
--- src/network/netclient.cc	2013-09-20 17:47:29 +0000
+++ src/network/netclient.cc	2014-02-22 14:58:17 +0000
@@ -119,15 +119,14 @@
 	file = 0;
 
 	// Temporarily register win condition scripts to get the default
-	LuaInterface * lua = create_LuaInterface();
-	lua->register_scripts(*g_fs, "win_conditions", "scripting/win_conditions");
-	ScriptContainer sc = lua->get_scripts_for("win_conditions");
+	LuaInterface lua;
+	lua.register_scripts(*g_fs, "win_conditions", "scripting/win_conditions");
+	ScriptContainer sc = lua.get_scripts_for("win_conditions");
 	std::vector<std::string> win_conditions;
 	container_iterate_const(ScriptContainer, sc, wc)
 		win_conditions.push_back(wc->first);
 	assert(win_conditions.size());
 	d->settings.win_condition = win_conditions[0];
-	delete lua;
 }
 
 NetClient::~NetClient ()
@@ -906,16 +905,16 @@
 			info.name = packet.String();
 
 			// Get initializations (we have to do this locally, for translations)
-			LuaInterface * lua = create_LuaInterface();
+			LuaInterface lua;
 			std::string path = "tribes/" + info.name;
 			if (g_fs->IsDirectory(path)) {
 				std::unique_ptr<FileSystem> sub_fs(g_fs->MakeSubFileSystem(path));
-				lua->register_scripts(*sub_fs, "tribe_" + info.name, "scripting");
+				lua.register_scripts(*sub_fs, "tribe_" + info.name, "scripting");
 			}
 
 			for (uint8_t j = packet.Unsigned8(); j; --j) {
 				std::string const name = packet.String();
-				std::unique_ptr<LuaTable> t = lua->run_script
+				std::unique_ptr<LuaTable> t = lua.run_script
 					("tribe_" + info.name, name);
 				info.initializations.push_back
 					(TribeBasicInfo::Initialization(name, t->get_string("name")));

=== modified file 'src/network/nethost.cc'
--- src/network/nethost.cc	2013-10-08 20:13:35 +0000
+++ src/network/nethost.cc	2014-02-22 14:58:17 +0000
@@ -293,7 +293,7 @@
 		if (m_win_conditions.size() < 1) {
 			// Register win condition scripts
 			if (!m_lua)
-				m_lua = create_LuaInterface();
+				m_lua = new LuaInterface();
 			m_lua->register_scripts(*g_fs, "win_conditions", "scripting/win_conditions");
 
 			ScriptContainer sc = m_lua->get_scripts_for("win_conditions");

=== modified file 'src/scripting/CMakeLists.txt'
--- src/scripting/CMakeLists.txt	2010-11-01 03:43:56 +0000
+++ src/scripting/CMakeLists.txt	2014-02-22 14:58:17 +0000
@@ -1,4 +1,77 @@
+file(GLOB_RECURSE ERIS_SRCS_C *.c)
+file(GLOB_RECURSE ERIS_SRCS_H *.h)
+
+SET(ERIS_SOURCES
+  eris/eris.c
+  eris/lapi.c
+  eris/lauxlib.c
+  eris/lbaselib.c
+  eris/lbitlib.c
+  eris/lcode.c
+  eris/lcorolib.c
+  eris/lctype.c
+  eris/ldblib.c
+  eris/ldebug.c
+  eris/ldo.c
+  eris/ldump.c
+  eris/lfunc.c
+  eris/lgc.c
+  eris/linit.c
+  eris/liolib.c
+  eris/llex.c
+  eris/lmathlib.c
+  eris/lmem.c
+  eris/loadlib.c
+  eris/lobject.c
+  eris/lopcodes.c
+  eris/loslib.c
+  eris/lparser.c
+  eris/lstate.c
+  eris/lstring.c
+  eris/lstrlib.c
+  eris/ltable.c
+  eris/ltablib.c
+  eris/ltm.c
+  eris/lua.c
+  eris/luac.c
+  eris/lundump.c
+  eris/lvm.c
+  eris/lzio.c
+)
+
+SET(ERIS_HEADERS
+  eris/eris.h
+  eris/lapi.h
+  eris/lauxlib.h
+  eris/lcode.h
+  eris/lctype.h
+  eris/ldebug.h
+  eris/ldo.h
+  eris/lfunc.h
+  eris/lgc.h
+  eris/llex.h
+  eris/llimits.h
+  eris/lmem.h
+  eris/lobject.h
+  eris/lopcodes.h
+  eris/lparser.h
+  eris/lstate.h
+  eris/lstring.h
+  eris/ltable.h
+  eris/ltm.h
+  eris/lua.h
+  eris/luaconf.h
+  eris/lualib.h
+  eris/lundump.h
+  eris/lvm.h
+  eris/lzio.h
+)
+
+add_library(eris STATIC
+  ${ERIS_SOURCES}
+  ${ERIS_HEADERS}
+)
+
 if (WL_UNIT_TESTS)
   add_subdirectory(test)
 endif (WL_UNIT_TESTS)
-

=== modified file 'src/scripting/c_utils.cc'
--- src/scripting/c_utils.cc	2013-07-26 20:19:36 +0000
+++ src/scripting/c_utils.cc	2014-02-22 14:58:17 +0000
@@ -107,9 +107,8 @@
 	vsnprintf(buffer, sizeof(buffer), fmt, va);
 	va_end(va);
 
-
 	// Also create a traceback
-	lua_getfield(L, LUA_GLOBALSINDEX, "debug");
+	lua_getglobal(L, "debug");
 	if (!lua_istable(L, -1)) {
 		lua_pop(L, 1);
 		return 1;
@@ -127,4 +126,3 @@
 
 	return 0;
 }
-

=== modified file 'src/scripting/c_utils.h'
--- src/scripting/c_utils.h	2013-07-26 20:19:36 +0000
+++ src/scripting/c_utils.h	2014-02-22 14:58:17 +0000
@@ -20,12 +20,12 @@
 #ifndef C_UTILS_H
 #define C_UTILS_H
 
-#include <lua.hpp>
 
-#include "scripting/factory.h"
 #include "logic/game.h"
 #include "map_io/widelands_map_map_object_loader.h"
 #include "map_io/widelands_map_map_object_saver.h"
+#include "scripting/eris/lua.hpp"
+#include "scripting/factory.h"
 
 Factory & get_factory(lua_State *);
 Widelands::Game & get_game(lua_State *);

=== removed file 'src/scripting/coroutine_impl.cc'
--- src/scripting/coroutine_impl.cc	2013-07-26 20:19:36 +0000
+++ src/scripting/coroutine_impl.cc	1970-01-01 00:00:00 +0000
@@ -1,144 +0,0 @@
-/*
- * Copyright (C) 2006-2010 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- */
-
-#include "scripting/coroutine_impl.h"
-
-#include <csetjmp>
-
-#include <boost/lexical_cast.hpp>
-
-#include "log.h"
-#include "logic/player.h"
-#include "scripting/c_utils.h"
-#include "scripting/lua_game.h"
-#include "scripting/lua_map.h"
-#include "scripting/persistence.h"
-
-LuaCoroutine_Impl::LuaCoroutine_Impl(lua_State * ms)
-	: m_L(ms), m_idx(LUA_REFNIL), m_nargs(0)
-{
-	m_reference();
-}
-
-LuaCoroutine_Impl::~LuaCoroutine_Impl()
-{
-	m_unreference();
-}
-
-int LuaCoroutine_Impl::resume(uint32_t * sleeptime)
-{
-	int rv = lua_resume(m_L, m_nargs);
-	m_nargs = 0;
-	int n = lua_gettop(m_L);
-
-	uint32_t sleep_for = 0;
-	if (n == 1) {
-		sleep_for = luaL_checkint32(m_L, -1);
-		lua_pop(m_L, 1);
-	}
-
-	if (sleeptime)
-		*sleeptime = sleep_for;
-
-	if (rv != 0 && rv != YIELDED) {
-		// lua_error() never returns. prints error and exit program imediately
-		//return  lua_error(m_L);
-		const char * err = lua_tostring(m_L, -1);
-		throw LuaError(err);
-	}
-
-	return rv;
-}
-
-/*
- * Push an argument that will be passed to the coroutine the next time it is
- * resumed
- */
-void LuaCoroutine_Impl::push_arg(const Widelands::Player * plr) {
-	to_lua<LuaGame::L_Player>(m_L, new LuaGame::L_Player(plr->player_number()));
-	m_nargs++;
-}
-void LuaCoroutine_Impl::push_arg(const Widelands::Coords & coords) {
-	to_lua<LuaMap::L_Field>(m_L, new LuaMap::L_Field(coords));
-	++m_nargs;
-}
-
-#define COROUTINE_DATA_PACKET_VERSION 1
-uint32_t LuaCoroutine_Impl::write
-	(lua_State * parent, Widelands::FileWrite & fw,
-	 Widelands::Map_Map_Object_Saver & mos)
-{
-	fw.Unsigned8(COROUTINE_DATA_PACKET_VERSION);
-
-	// The current numbers of arguments on the stack
-	fw.Unsigned32(m_nargs);
-
-	// Empty table + object to persist on the stack Stack
-	lua_newtable(parent);
-	lua_pushthread(m_L);
-	lua_xmove (m_L, parent, 1);
-
-	return persist_object(parent, fw, mos);
-}
-
-void LuaCoroutine_Impl::read
-	(lua_State * parent, Widelands::FileRead & fr,
-	 Widelands::Map_Map_Object_Loader & mol, uint32_t size)
-{
-	uint8_t version = fr.Unsigned8();
-
-	if (version != COROUTINE_DATA_PACKET_VERSION)
-		throw wexception("Unknown data packet version: %i\n", version);
-
-	// The current numbers of arguments on the stack
-	m_nargs = fr.Unsigned32();
-
-	// Empty table + object to persist on the stack Stack
-	unpersist_object(parent, fr, mol, size);
-
-	m_L = luaL_checkthread(parent, -1);
-	lua_pop(parent, 1);
-
-	// Cache a lua reference to this object so that it does not
-	// get garbage collected
-	lua_pushthread(m_L);
-	m_idx = luaL_ref(m_L, LUA_REGISTRYINDEX);
-
-}
-
-/*
- * ========================================================================
- *                         PRIVATE FUNCTIONS
- * ========================================================================
- */
-/**
- * Cache a lua reference to this object so that it does not get garbage
- * collected
- */
-void LuaCoroutine_Impl::m_reference() {
-	if (m_L) {
-		lua_pushthread(m_L);
-		m_idx = luaL_ref(m_L, LUA_REGISTRYINDEX);
-	}
-}
-void LuaCoroutine_Impl::m_unreference() {
-	luaL_unref(m_L, LUA_REGISTRYINDEX, m_idx);
-}
-
-

=== removed file 'src/scripting/coroutine_impl.h'
--- src/scripting/coroutine_impl.h	2013-09-22 18:01:36 +0000
+++ src/scripting/coroutine_impl.h	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2006-2010 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- */
-
-#ifndef COROUTINE_IMPL_H
-#define COROUTINE_IMPL_H
-
-#include "scripting/scripting.h"
-
-namespace Widelands {
-	class Player;
-}
-
-/*
-============================================
-       Lua Coroutine
-============================================
-*/
-class LuaCoroutine_Impl : public LuaCoroutine {
-public:
-	LuaCoroutine_Impl(lua_State * L);
-	virtual ~LuaCoroutine_Impl();
-
-	virtual int get_status() {return lua_status(m_L);}
-	virtual int resume(uint32_t * sleeptime = 0);
-
-	virtual uint32_t write
-		(lua_State *, Widelands::FileWrite &,
-		 Widelands::Map_Map_Object_Saver &);
-	virtual void read
-		(lua_State *, Widelands::FileRead &,
-		 Widelands::Map_Map_Object_Loader &, uint32_t);
-
-	virtual void push_arg(const Widelands::Player *);
-	virtual void push_arg(const Widelands::Coords &);
-
-private:
-	void m_reference();
-	void m_unreference();
-
-private:
-	lua_State * m_L;
-	uint32_t m_idx;
-	uint32_t m_nargs;
-};
-
-
-#endif /* end of include guard: COROUTINE_IMPL_H */

=== added directory 'src/scripting/eris'
=== added file 'src/scripting/eris.h'
--- src/scripting/eris.h	1970-01-01 00:00:00 +0000
+++ src/scripting/eris.h	2014-02-22 14:58:17 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2006-2013 by the Widelands Development Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef WL_ERIS_H
+#define WL_ERIS_H
+
+// We need eris in a cpp context. Include it as such.
+extern "C" {
+#include "scripting/eris/eris.h"
+}
+
+
+#endif /* end of include guard: WL_ERIS_H */

=== renamed file 'src/scripting/README.pluto' => 'src/scripting/eris/README.eris'
--- src/scripting/README.pluto	2010-01-30 14:54:27 +0000
+++ src/scripting/eris/README.eris	2014-02-22 14:58:17 +0000
@@ -1,11 +1,11 @@
-Our scripting support contains the stripped down essentials of pluto[1]. You
-find the complete source and README of pluto on the github repo from one of
-it's authors Rob Hoelz at [2]. Our version of pluto has been heavily modified
-to create system agnostic files and to work with the widelands file streaming.
-The Widelands Team wishes to expresses total and complete gratitude to the
-authors of Pluto for making it public domain. 
-
-[1] http://luaforge.net/projects/pluto/
-[2] http://github.com/hoelzro/pluto
+This directory contains a verbatim copy of Eris by Florian Nücke.
+
+URL: https://github.com/fnuecke/eris
+VERSION: 2e39ecc7dcb73120dde775929227fa661fbc6bc0
+
+We use this for heavy persistence and it also brings with it the Lua version
+that we use in Widelands. The Widelands Team wishes to expresses total and
+complete gratitude to the authors of Eris for making it available under the MIT
+License. 
 
    -- SirVer, in behalf of the Widelands Team

=== added file 'src/scripting/eris/eris.c'
--- src/scripting/eris/eris.c	1970-01-01 00:00:00 +0000
+++ src/scripting/eris/eris.c	2014-02-22 14:58:17 +0000
@@ -0,0 +1,2658 @@
+/*
+Eris - Heavy-duty persistence for Lua 5.2.2 - Based on Pluto
+Copyright (c) 2013 by Florian Nuecke.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+/* Standard library headers. */
+#include <assert.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Not using stdbool because Visual Studio lives in the past... */
+typedef int bool;
+#define false 0
+#define true 1
+
+/* Mark us as part of the Lua core to get access to what we need. */
+#define LUA_CORE
+
+/* Public Lua headers. */
+#include "lua.h"
+#include "lauxlib.h"
+#include "lualib.h"
+
+/* Internal Lua headers. */
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "lzio.h"
+
+/* Eris header. */
+#include "eris.h"
+
+/*
+** {===========================================================================
+** Default settings.
+** ============================================================================
+*/
+
+/* Note that these are the default settings. They can be changed either from C
+ * by calling eris_g|set_setting() or from Lua using eris.settings(). */
+
+/* The metatable key we use to allow customized persistence for tables and
+ * userdata. */
+static const char *const kPersistKey = "__persist";
+
+/* Whether to pass the IO object (reader/writer) to the special function
+ * defined in the metafield or not. This is disabled per default because it
+ * mey allow Lua scripts to do more than they should. Enable this as needed. */
+static const bool kPassIOToPersist = false;
+
+/* Whether to persist debug information such as line numbers and upvalue and
+ * local variable names. */
+static const bool kWriteDebugInformation = true;
+
+/* Generate a human readable "path" that is shown together with error messages
+ * to indicate where in the object the error occurred. For example:
+ * eris.persist({false, bad = setmetatable({}, {__persist = false})})
+ * Will produce: main:1: attempt to persist forbidden table (root.bad)
+ * This can be used for debugging, but is disabled per default due to the
+ * processing and memory overhead this introduces. */
+static const bool kGeneratePath = false;
+
+/* The maximum object complexity. This is the number of allowed recursions when
+ * persisting or unpersisting an object, for example for nested tables. This is
+ * used to avoid segfaults when writing or reading user data. */
+static const lua_Unsigned kMaxComplexity = 10000;
+
+/*
+** ============================================================================
+** Lua internals interfacing.
+** ============================================================================
+*/
+
+/* Lua internals we use. We define these as macros to make it easier to swap
+ * them out, should the need ever arise. For example, the later Pluto versions
+ * copied these function to own files (presumably to allow building it as an
+ * extra shared library). These should be all functions we use that are not
+ * declared in lua.h or lauxlib.h. If there are some still directly in the code
+ * they were missed and should be replaced with a macro added here instead. */
+/* I'm quite sure we won't ever want to do this, because Eris needs a slightly
+ * patched Lua version to be able to persist some of the library functions,
+ * anyway: it needs to put the continuation C functions in the perms table. */
+/* ldebug.h */
+#define eris_ci_func ci_func
+/* ldo.h */
+#define eris_incr_top incr_top
+#define eris_savestack savestack
+#define eris_restorestack restorestack
+#define eris_reallocstack luaD_reallocstack
+/* lfunc.h */
+#define eris_newproto luaF_newproto
+#define eris_newLclosure luaF_newLclosure
+#define eris_newupval luaF_newupval
+#define eris_findupval luaF_findupval
+/* lgc.h */
+#define eris_barrierproto luaC_barrierproto
+/* lmem.h */
+#define eris_reallocvector luaM_reallocvector
+/* lobject.h */
+#define eris_ttypenv ttypenv
+#define eris_setnilvalue setnilvalue
+#define eris_setclLvalue setclLvalue
+#define eris_setobj setobj
+#define eris_setsvalue2n setsvalue2n
+/* lstate.h */
+#define eris_isLua isLua
+#define eris_gch gch
+#define eris_gco2uv gco2uv
+#define eris_obj2gco obj2gco
+#define eris_extendCI luaE_extendCI
+/* lstring. h */
+#define eris_newlstr luaS_newlstr
+/* lzio.h */
+#define eris_initbuffer luaZ_initbuffer
+#define eris_buffer luaZ_buffer
+#define eris_sizebuffer luaZ_sizebuffer
+#define eris_bufflen luaZ_bufflen
+#define eris_init luaZ_init
+#define eris_read luaZ_read
+
+/* These are required for cross-platform support, since the size of TValue may
+ * differ, so the byte offset used by savestack/restorestack in Lua it is not a
+ * valid measure. */
+#define eris_savestackidx(L, p) ((p) - (L)->stack)
+#define eris_restorestackidx(L, n) ((L)->stack + (n))
+
+/* Enabled if we have a patched version of Lua (for accessing internals). */
+#if 1
+
+/* Functions in Lua libraries used to access C functions we need to add to the
+ * permanents table to fully support yielded coroutines. */
+extern void eris_permbaselib(lua_State *L, bool forUnpersist);
+extern void eris_permcorolib(lua_State *L, bool forUnpersist);
+extern void eris_permloadlib(lua_State *L, bool forUnpersist);
+extern void eris_permiolib(lua_State *L, bool forUnpersist);
+extern void eris_permstrlib(lua_State *L, bool forUnpersist);
+
+/* Utility macro for populating the perms table with internal C functions. */
+#define populateperms(L, forUnpersist) {\
+  eris_permbaselib(L, forUnpersist);\
+  eris_permcorolib(L, forUnpersist);\
+  eris_permloadlib(L, forUnpersist);\
+  eris_permiolib(L, forUnpersist);\
+  eris_permstrlib(L, forUnpersist);\
+}
+
+#else
+
+/* Does nothing if we don't have a patched version of Lua. */
+#define populateperms(L, forUnpersist) ((void)0)
+
+#endif
+
+/*
+** ============================================================================
+** Constants, settings, types and forward declarations.
+** ============================================================================
+*/
+
+/* The "type" we write when we persist a value via a replacement from the
+ * permanents table. This is just an arbitrary number, but it must we lower
+ * than the reference offset (below) and outside the range Lua uses for its
+ * types (> LUA_TOTALTAGS). */
+#define ERIS_PERMANENT (LUA_TOTALTAGS + 1)
+
+/* This is essentially the first reference we'll use. We do this to save one
+ * field in our persisted data: if the value is smaller than this, the object
+ * itself follows, otherwise we have a reference to an already unpersisted
+ * object. Note that in the reftable the actual entries are still stored
+ * starting at the first array index to have a sequence (when unpersisting). */
+#define ERIS_REFERENCE_OFFSET (ERIS_PERMANENT + 1)
+
+/* Avoids having to write the NULL all the time, plus makes it easier adding
+ * a custom error message should you ever decide you want one. */
+#define eris_checkstack(L, n) luaL_checkstack(L, n, NULL)
+
+/* Used for internal consistency checks, for debugging. These are true asserts
+ * in the sense that they should never fire, even for bad inputs. */
+#if 0
+#define eris_assert(c) assert(c)
+#define eris_ifassert(e) e
+#else
+#define eris_assert(c) ((void)0)
+#define eris_ifassert(e) ((void)0)
+#endif
+
+/* State information when persisting an object. */
+typedef struct PersistInfo {
+  lua_Writer writer;
+  void *ud;
+  const char *metafield;
+  bool writeDebugInfo;
+} PersistInfo;
+
+/* State information when unpersisting an object. */
+typedef struct UnpersistInfo {
+  ZIO zio;
+  size_t sizeof_int;
+  size_t sizeof_size_t;
+} UnpersistInfo;
+
+/* Info shared in persist and unpersist. */
+typedef struct Info {
+  lua_State *L;
+  lua_Unsigned level;
+  int refcount; /* int because rawseti/rawgeti takes an int. */
+  lua_Unsigned maxComplexity;
+  bool generatePath;
+  bool passIOToPersist;
+  /* Which one it really is will always be clear from the context. */
+  union {
+    PersistInfo pi;
+    UnpersistInfo upi;
+  } u;
+} Info;
+
+/* Type names, used for error messages. */
+static const char *const kTypenames[] = {
+  "nil", "boolean", "lightuserdata", "number", "string",
+  "table", "function", "userdata", "thread", "proto", "upval",
+  "deadkey", "permanent"
+};
+
+/* Setting names as used in eris.settings / eris_g|set_setting. Also, the
+ * addresses of these static variables are used as keys in the registry of Lua
+ * states to save the current values of the settings (as light userdata). */
+static const char *const kSettingMetafield = "spkey";
+static const char *const kSettingPassIOToPersist = "spio";
+static const char *const kSettingGeneratePath = "path";
+static const char *const kSettingWriteDebugInfo = "debug";
+static const char *const kSettingMaxComplexity = "maxrec";
+
+/* Header we prefix to persisted data for a quick check when unpersisting. */
+static char const kHeader[] = { 'E', 'R', 'I', 'S' };
+#define HEADER_LENGTH sizeof(kHeader)
+
+/* Floating point number used to check compatibility of loaded data. */
+static const lua_Number kHeaderNumber = (lua_Number)-1.234567890;
+
+/* Stack indices of some internal values/tables, to avoid magic numbers. */
+#define PERMIDX 1
+#define REFTIDX 2
+#define BUFFIDX 3
+#define PATHIDX 4
+
+/* }======================================================================== */
+
+/*
+** {===========================================================================
+** Utility functions.
+** ============================================================================
+*/
+
+/* Pushes an object into the reference table when unpersisting. This creates an
+ * entry pointing from the id the object is referenced by to the object. */
+static int
+registerobject(Info *info) {                          /* perms reftbl ... obj */
+  const int reference = ++(info->refcount);
+  eris_checkstack(info->L, 1);
+  lua_pushvalue(info->L, -1);                     /* perms reftbl ... obj obj */
+  lua_rawseti(info->L, REFTIDX, reference);           /* perms reftbl ... obj */
+  return reference;
+}
+
+/** ======================================================================== */
+
+/* Pushes a TString* onto the stack if it holds a value, nil if it is NULL. */
+static void
+pushtstring(lua_State* L, TString *ts) {                               /* ... */
+  if (ts) {
+    eris_setsvalue2n(L, L->top, ts);
+    eris_incr_top(L);                                              /* ... str */
+  }
+  else {
+    lua_pushnil(L);                                                /* ... nil */
+  }
+}
+
+/* Creates a copy of the string on top of the stack and sets it as the value
+ * of the specified TString**. */
+static void
+copytstring(lua_State* L, TString **ts) {
+  size_t length;
+  const char *value = lua_tolstring(L, -1, &length);
+  *ts = eris_newlstr(L, value, length);
+}
+
+/** ======================================================================== */
+
+/* Pushes the specified segment to the current path, if we're generating one.
+ * This supports formatting strings using Lua's formatting capabilities. */
+static void
+pushpath(Info *info, const char* fmt, ...) {     /* perms reftbl var path ... */
+  if (!info->generatePath) {
+    return;
+  }
+  else {
+    va_list argp;
+    eris_checkstack(info->L, 1);
+    va_start(argp, fmt);
+    lua_pushvfstring(info->L, fmt, argp);    /* perms reftbl var path ... str */
+    va_end(argp);
+    lua_rawseti(info->L, PATHIDX, luaL_len(info->L, PATHIDX) + 1);
+  }                                              /* perms reftbl var path ... */
+}  
+
+/* Pops the last added segment from the current path if we're generating one. */
+static void
+poppath(Info *info) {                            /* perms reftbl var path ... */
+  if (!info->generatePath) {
+    return;
+  }
+  eris_checkstack(info->L, 1);
+  lua_pushnil(info->L);                      /* perms reftbl var path ... nil */
+  lua_rawseti(info->L, PATHIDX, luaL_len(info->L, PATHIDX));
+}                                                /* perms reftbl var path ... */
+
+/* Concatenates all current path segments into one string, pushes it and
+ * returns it. This is relatively inefficient, but it's for errors only and
+ * keeps the stack small, so it's better this way. */
+static const char*
+path(Info *info) {                               /* perms reftbl var path ... */
+  if (!info->generatePath) {
+    return "";
+  }
+  eris_checkstack(info->L, 3);
+  lua_pushstring(info->L, "");               /* perms reftbl var path ... str */
+  lua_pushnil(info->L);                  /* perms reftbl var path ... str nil */
+  while (lua_next(info->L, PATHIDX)) {   /* perms reftbl var path ... str k v */
+    lua_insert(info->L, -2);             /* perms reftbl var path ... str v k */
+    lua_insert(info->L, -3);             /* perms reftbl var path ... k str v */
+    lua_concat(info->L, 2);                /* perms reftbl var path ... k str */
+    lua_insert(info->L, -2);               /* perms reftbl var path ... str k */
+  }                                          /* perms reftbl var path ... str */
+  return lua_tostring(info->L, -1);
+}
+
+/* Generates an error message with the appended path, if available. */
+static int
+eris_error(Info *info, const char *fmt, ...) {                         /* ... */
+    va_list argp;
+    eris_checkstack(info->L, 5);
+
+    luaL_where(info->L, 1);                                     /* ... where */
+    va_start(argp, fmt);
+    lua_pushvfstring(info->L, fmt, argp);                    /* ... where str */
+    va_end(argp);
+    if (info->generatePath) {
+      lua_pushstring(info->L, " (");                    /* ... where str " (" */
+      path(info);                                 /* ...  where str " (" path */
+      lua_pushstring(info->L, ")");            /* ... where str " (" path ")" */
+      lua_concat(info->L, 5);                                      /* ... msg */
+    }
+    else {
+      lua_concat(info->L, 2);                                      /* ... msg */
+    }
+    return lua_error(info->L);
+}
+
+/** ======================================================================== */
+
+/* Tries to get a setting from the registry. */
+static bool
+get_setting(lua_State *L, void *key) {                                 /* ... */
+  eris_checkstack(L, 1);
+  lua_pushlightuserdata(L, key);                                   /* ... key */
+  lua_gettable(L, LUA_REGISTRYINDEX);                        /* ... value/nil */
+  if (lua_isnil(L, -1)) {                                          /* ... nil */
+    lua_pop(L, 1);                                                     /* ... */
+    return false;
+  }                                                              /* ... value */
+  return true;
+}
+
+/* Stores a setting in the registry (or removes it if the value is nil). */
+static void
+set_setting(lua_State *L, void *key) {                           /* ... value */
+  eris_checkstack(L, 2);
+  lua_pushlightuserdata(L, key);                             /* ... value key */
+  lua_insert(L, -2);                                         /* ... key value */
+  lua_settable(L, LUA_REGISTRYINDEX);                                  /* ... */
+}
+
+/* Used as a callback for luaL_opt to check boolean setting values. */
+static void
+checkboolean(lua_State *L, int narg) {                       /* ... bool? ... */
+  if (!lua_isboolean(L, narg)) {                                /* ... :( ... */
+    luaL_argerror(L, narg, lua_pushfstring(L,
+      "boolean expected, got %s", lua_typename(L, lua_type(L, narg))));
+  }                                                           /* ... bool ... */
+}
+
+/* }======================================================================== */
+
+/*
+** {===========================================================================
+** Persist and unpersist.
+** ============================================================================
+*/
+
+/* I have macros and I'm not afraid to use them! These are highly situational
+ * and assume an Info* named 'info' is available. */
+
+/* Writes a raw memory block with the specified size. */
+#define WRITE_RAW(value, size) {\
+  if (info->u.pi.writer(info->L, (value), (size), info->u.pi.ud)) \
+    eris_error(info, "could not write data"); }
+
+/* Writes a single value with the specified type. */
+#define WRITE_VALUE(value, type) write_##type(info, value)
+
+/* Writes a typed array with the specified length. */
+#define WRITE(value, length, type) { \
+    int i; for (i = 0; i < length; ++i) WRITE_VALUE((value)[i], type); }
+
+/** ======================================================================== */
+
+/* Reads a raw block of memory with the specified size. */
+#define READ_RAW(value, size) {\
+  if (eris_read(&info->u.upi.zio, (value), (size))) \
+    eris_error(info, "could not read data"); }
+
+/* Reads a single value with the specified type. */
+#define READ_VALUE(type) read_##type(info)
+
+/* Reads a typed array with the specified length. */
+#define READ(value, length, type) { \
+    int i; for (i = 0; i < length; ++i) (value)[i] = READ_VALUE(type); }
+
+/** ======================================================================== */
+
+static void
+write_uint8_t(Info *info, uint8_t value) {
+  WRITE_RAW(&value, sizeof(uint8_t));
+}
+
+static void
+write_uint16_t(Info *info, uint16_t value) {
+  write_uint8_t(info, value);
+  write_uint8_t(info, value >> 8);
+}
+
+static void
+write_uint32_t(Info *info, uint32_t value) {
+  write_uint8_t(info, value);
+  write_uint8_t(info, value >> 8);
+  write_uint8_t(info, value >> 16);
+  write_uint8_t(info, value >> 24);
+}
+
+static void
+write_uint64_t(Info *info, uint64_t value) {
+  write_uint8_t(info, value);
+  write_uint8_t(info, value >> 8);
+  write_uint8_t(info, value >> 16);
+  write_uint8_t(info, value >> 24);
+  write_uint8_t(info, value >> 32);
+  write_uint8_t(info, value >> 40);
+  write_uint8_t(info, value >> 48);
+  write_uint8_t(info, value >> 56);
+}
+
+static void
+write_int16_t(Info *info, int16_t value) {
+  write_uint16_t(info, (uint16_t)value);
+}
+
+static void
+write_int32_t(Info *info, int32_t value) {
+  write_uint32_t(info, (uint32_t)value);
+}
+
+static void
+write_int64_t(Info *info, int64_t value) {
+  write_uint64_t(info, (uint64_t)value);
+}
+
+static void
+write_float32(Info *info, float value) {
+  uint32_t rep;
+  memcpy(&rep, &value, sizeof(float));
+  write_uint32_t(info, rep);
+}
+
+static void
+write_float64(Info *info, double value) {
+  uint64_t rep;
+  memcpy(&rep, &value, sizeof(double));
+  write_uint64_t(info, rep);
+}
+
+/* Note regarding the following: any decent compiler should be able
+ * to reduce these to just the write call, since sizeof is constant. */
+
+static void
+write_int(Info *info, int value) {
+  if (sizeof(int) == sizeof(int16_t)) {
+    write_int16_t(info, value);
+  }
+  else if (sizeof(int) == sizeof(int32_t)) {
+    write_int32_t(info, value);
+  }
+  else if (sizeof(int) == sizeof(int64_t)) {
+    write_int64_t(info, value);
+  }
+  else {
+    eris_error(info, "unsupported int type");
+  }
+}
+
+static void
+write_size_t(Info *info, size_t value) {
+  if (sizeof(size_t) == sizeof(uint16_t)) {
+    write_uint16_t(info, value);
+  }
+  else if (sizeof(size_t) == sizeof(uint32_t)) {
+    write_uint32_t(info, value);
+  }
+  else if (sizeof(size_t) == sizeof(uint64_t)) {
+    write_uint64_t(info, value);
+  }
+  else {
+    eris_error(info, "unsupported size_t type");
+  }
+}
+
+static void
+write_lua_Number(Info *info, lua_Number value) {
+  if (sizeof(lua_Number) == sizeof(uint32_t)) {
+    write_float32(info, value);
+  }
+  else if (sizeof(lua_Number) == sizeof(uint64_t)) {
+    write_float64(info, value);
+  }
+  else {
+    eris_error(info, "unsupported lua_Number type");
+  }
+}
+
+/* Note that Lua only ever uses 32 bits of the Instruction type, so we can
+ * assert that there will be no truncation, even if the underlying type has
+ * more bits (might be the case on some 64 bit systems). */
+
+static void
+write_Instruction(Info *info, Instruction value) {
+  if (sizeof(Instruction) == sizeof(uint32_t)) {
+    write_uint32_t(info, value);
+  }
+  else {
+    uint32_t pvalue = (uint32_t)value;
+    /* Lua only uses 32 bits for its instructions. */
+    eris_assert((Instruction)pvalue == value);
+    write_uint32_t(info, pvalue);
+  }
+}
+
+/** ======================================================================== */
+
+static uint8_t
+read_uint8_t(Info *info) {
+  uint8_t value;
+  READ_RAW(&value, sizeof(uint8_t));
+  return value;
+}
+
+static uint16_t
+read_uint16_t(Info *info) {
+  return  (uint16_t)read_uint8_t(info) |
+         ((uint16_t)read_uint8_t(info) << 8);
+}
+
+static uint32_t
+read_uint32_t(Info *info) {
+  return  (uint32_t)read_uint8_t(info) |
+         ((uint32_t)read_uint8_t(info) << 8) |
+         ((uint32_t)read_uint8_t(info) << 16) |
+         ((uint32_t)read_uint8_t(info) << 24);
+}
+
+static uint64_t
+read_uint64_t(Info *info) {
+  return  (uint64_t)read_uint8_t(info) |
+         ((uint64_t)read_uint8_t(info) << 8) |
+         ((uint64_t)read_uint8_t(info) << 16) |
+         ((uint64_t)read_uint8_t(info) << 24) |
+         ((uint64_t)read_uint8_t(info) << 32) |
+         ((uint64_t)read_uint8_t(info) << 40) |
+         ((uint64_t)read_uint8_t(info) << 48) |
+         ((uint64_t)read_uint8_t(info) << 56);
+}
+
+static int16_t
+read_int16_t(Info *info) {
+  return (int16_t)read_uint16_t(info);
+}
+
+static int32_t
+read_int32_t(Info *info) {
+  return (int32_t)read_uint32_t(info);
+}
+
+static int64_t
+read_int64_t(Info *info) {
+  return (int64_t)read_uint64_t(info);
+}
+
+static float
+read_float32(Info *info) {
+  float value;
+  uint32_t rep = read_uint32_t(info);
+  memcpy(&value, &rep, sizeof(float));
+  return value;
+}
+
+static double
+read_float64(Info *info) {
+  double value;
+  uint64_t rep = read_uint64_t(info);
+  memcpy(&value, &rep, sizeof(double));
+  return value;
+}
+
+/* Note regarding the following: unlike with writing the sizeof check will be
+ * impossible to optimize away, since it depends on the input; however, the
+ * truncation check may be optimized away in the case where the read data size
+ * equals the native one, so reading data written on the same machine should be
+ * reasonably quick. Doing a (rather rudimentary) benchmark this did not have
+ * any measurable impact on performance. */
+
+static int
+read_int(Info *info) {
+  int value;
+  if (info->u.upi.sizeof_int == sizeof(int16_t)) {
+    int16_t pvalue = read_int16_t(info);
+    value = (int)pvalue;
+    if ((int32_t)value != pvalue) {
+      eris_error(info, "int value would get truncated");
+    }
+  }
+  else if (info->u.upi.sizeof_int == sizeof(int32_t)) {
+    int32_t pvalue = read_int32_t(info);
+    value = (int)pvalue;
+    if ((int32_t)value != pvalue) {
+      eris_error(info, "int value would get truncated");
+    }
+  }
+  else if (info->u.upi.sizeof_int == sizeof(int64_t)) {
+    int64_t pvalue = read_int64_t(info);
+    value = (int)pvalue;
+    if ((int64_t)value != pvalue) {
+      eris_error(info, "int value would get truncated");
+    }
+  }
+  else {
+    eris_error(info, "unsupported int type");
+    value = 0; /* not reached */
+  }
+  return value;
+}
+
+static size_t
+read_size_t(Info *info) {
+  size_t value;
+  if (info->u.upi.sizeof_size_t == sizeof(uint16_t)) {
+    uint16_t pvalue = read_uint16_t(info);
+    value = (size_t)pvalue;
+    if ((uint32_t)value != pvalue) {
+      eris_error(info, "size_t value would get truncated");
+    }
+  }
+  else if (info->u.upi.sizeof_size_t == sizeof(uint32_t)) {
+    uint32_t pvalue = read_uint32_t(info);
+    value = (size_t)pvalue;
+    if ((uint32_t)value != pvalue) {
+      eris_error(info, "size_t value would get truncated");
+    }
+  }
+  else if (info->u.upi.sizeof_size_t == sizeof(uint64_t)) {
+    uint64_t pvalue = read_uint64_t(info);
+    value = (size_t)pvalue;
+    if ((uint64_t)value != pvalue) {
+      eris_error(info, "size_t value would get truncated");
+    }
+  }
+  else {
+    eris_error(info, "unsupported size_t type");
+    value = 0; /* not reached */
+  }
+  return value;
+}
+
+static lua_Number
+read_lua_Number(Info *info) {
+  if (sizeof(lua_Number) == sizeof(uint32_t)) {
+    return read_float32(info);
+  }
+  else if (sizeof(lua_Number) == sizeof(uint64_t)) {
+    return read_float64(info);
+  }
+  else {
+    eris_error(info, "unsupported lua_Number type");
+    return 0; /* not reached */
+  }
+}
+
+static Instruction
+read_Instruction(Info *info) {
+  return (Instruction)read_uint32_t(info);
+}
+
+/** ======================================================================== */
+
+/* Forward declarations for recursively called top-level functions. */
+static void persist_keyed(Info*, int type);
+static void persist(Info*);
+static void unpersist(Info*);
+
+/*
+** ============================================================================
+** Simple types.
+** ============================================================================
+*/
+
+static void
+p_boolean(Info *info) {                                           /* ... bool */
+  WRITE_VALUE(lua_toboolean(info->L, -1), uint8_t);
+}
+
+static void
+u_boolean(Info *info) {                                                /* ... */
+  eris_checkstack(info->L, 1);
+  lua_pushboolean(info->L, READ_VALUE(uint8_t));                  /* ... bool */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TBOOLEAN);
+}
+
+/** ======================================================================== */
+
+static void
+p_pointer(Info *info) {                                         /* ... ludata */
+  WRITE_VALUE((size_t)lua_touserdata(info->L, -1), size_t);
+}
+
+static void
+u_pointer(Info *info) {                                                /* ... */
+  eris_checkstack(info->L, 1);
+  lua_pushlightuserdata(info->L, (void*)READ_VALUE(size_t));    /* ... ludata */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
+}
+
+/** ======================================================================== */
+
+static void
+p_number(Info *info) {                                             /* ... num */
+  WRITE_VALUE(lua_tonumber(info->L, -1), lua_Number);
+}
+
+static void
+u_number(Info *info) {                                                 /* ... */
+  eris_checkstack(info->L, 1);
+  lua_pushnumber(info->L, READ_VALUE(lua_Number));                 /* ... num */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TNUMBER);
+}
+
+/** ======================================================================== */
+
+static void
+p_string(Info *info) {                                             /* ... str */
+  size_t length;
+  const char *value = lua_tolstring(info->L, -1, &length);
+  WRITE_VALUE(length, size_t);
+  WRITE_RAW(value, length);
+}
+
+static void
+u_string(Info *info) {                                                 /* ... */
+  eris_checkstack(info->L, 2);
+  {
+    /* TODO Can we avoid this copy somehow? (Without it getting too nasty) */
+    const size_t length = READ_VALUE(size_t);
+    char *value = lua_newuserdata(info->L, length * sizeof(char)); /* ... tmp */
+    READ_RAW(value, length);
+    lua_pushlstring(info->L, value, length);                   /* ... tmp str */
+    lua_replace(info->L, -2);                                      /* ... str */
+  }
+  registerobject(info);
+
+  eris_assert(lua_type(info->L, -1) == LUA_TSTRING);
+}
+
+/*
+** ============================================================================
+** Tables and userdata.
+** ============================================================================
+*/
+
+static void
+p_metatable(Info *info) {                                          /* ... obj */
+  eris_checkstack(info->L, 1);
+  pushpath(info, "@metatable");
+  if (!lua_getmetatable(info->L, -1)) {                        /* ... obj mt? */
+    lua_pushnil(info->L);                                      /* ... obj nil */
+  }                                                         /* ... obj mt/nil */
+  persist(info);                                            /* ... obj mt/nil */
+  lua_pop(info->L, 1);                                             /* ... obj */
+  poppath(info);
+}
+
+static void
+u_metatable(Info *info) {                                          /* ... tbl */
+  eris_checkstack(info->L, 1);
+  pushpath(info, "@metatable");
+  unpersist(info);                                         /* ... tbl mt/nil? */
+  if (lua_istable(info->L, -1)) {                               /* ... tbl mt */
+    lua_setmetatable(info->L, -2);                                 /* ... tbl */
+  }
+  else if (lua_isnil(info->L, -1)) {                           /* ... tbl nil */
+    lua_pop(info->L, 1);                                           /* ... tbl */
+  }
+  else {                                                            /* tbl :( */
+    eris_error(info, "bad metatable, not nil or table");
+  }
+  poppath(info);
+}
+
+/** ======================================================================== */
+
+static void
+p_literaltable(Info *info) {                                       /* ... tbl */
+  eris_checkstack(info->L, 3);
+
+  /* Persist all key / value pairs. */
+  lua_pushnil(info->L);                                        /* ... tbl nil */
+  while (lua_next(info->L, -2)) {                              /* ... tbl k v */
+    lua_pushvalue(info->L, -2);                              /* ... tbl k v k */
+
+    if (info->generatePath) {
+      if (lua_type(info->L, -1) == LUA_TSTRING) {
+        const char *key = lua_tostring(info->L, -1);
+        pushpath(info, ".%s", key);
+      }
+      else {
+        const char *key = luaL_tolstring(info->L, -1, NULL);
+        pushpath(info, "[%s]", key);
+        lua_pop(info->L, 1);
+      }
+    }
+
+    persist(info);                                           /* ... tbl k v k */
+    lua_pop(info->L, 1);                                       /* ... tbl k v */
+    persist(info);                                             /* ... tbl k v */
+    lua_pop(info->L, 1);                                         /* ... tbl k */
+
+    poppath(info);
+  }                                                                /* ... tbl */
+
+  /* Terminate list. */
+  lua_pushnil(info->L);                                        /* ... tbl nil */
+  persist(info);                                               /* ... tbl nil */
+  lua_pop(info->L, 1);                                             /* ... tbl */
+
+  p_metatable(info);
+}
+
+static void
+u_literaltable(Info *info) {                                           /* ... */
+  eris_checkstack(info->L, 3);
+
+  lua_newtable(info->L);                                           /* ... tbl */
+
+  /* Preregister table for handling of cycles (keys, values or metatable). */
+  registerobject(info);
+
+  /* Unpersist all key / value pairs. */
+  for (;;) {
+    pushpath(info, "@key");
+    unpersist(info);                                       /* ... tbl key/nil */
+    poppath(info);
+    if (lua_isnil(info->L, -1)) {                              /* ... tbl nil */
+      lua_pop(info->L, 1);                                         /* ... tbl */
+      break;
+    }                                                          /* ... tbl key */
+
+    if (info->generatePath) {
+      if (lua_type(info->L, -1) == LUA_TSTRING) {
+        const char *key = lua_tostring(info->L, -1);
+        pushpath(info, ".%s", key);
+      }
+      else {
+        const char *key = luaL_tolstring(info->L, -1, NULL);
+        pushpath(info, "[%s]", key);
+        lua_pop(info->L, 1);
+      }
+    }
+
+    unpersist(info);                                    /* ... tbl key value? */
+    if (!lua_isnil(info->L, -1)) {                       /* ... tbl key value */
+      lua_rawset(info->L, -3);                                     /* ... tbl */
+    }
+    else {
+      eris_error(info, "bad table value, got a nil value");
+    }
+
+    poppath(info);
+  }
+
+  u_metatable(info);                                               /* ... tbl */
+}
+
+/** ======================================================================== */
+
+static void
+p_literaluserdata(Info *info) {                                  /* ... udata */
+  const size_t size = lua_rawlen(info->L, -1);
+  const void *value = lua_touserdata(info->L, -1);
+  WRITE_VALUE(size, size_t);
+  WRITE_RAW(value, size);
+  p_metatable(info);                                             /* ... udata */
+}
+
+static void
+u_literaluserdata(Info *info) {                                        /* ... */
+  eris_checkstack(info->L, 1);
+  {
+    size_t size = READ_VALUE(size_t);
+    void *value = lua_newuserdata(info->L, size);                /* ... udata */
+    READ_RAW(value, size);                                       /* ... udata */
+  }
+  registerobject(info);
+  u_metatable(info);
+}
+
+/** ======================================================================== */
+
+typedef void (*Callback) (Info*);
+
+static void
+p_special(Info *info, Callback literal) {                          /* ... obj */
+  int allow = (lua_type(info->L, -1) == LUA_TTABLE);
+  eris_checkstack(info->L, 4);
+
+  /* Check whether we should persist literally, or via the metafunction. */
+  if (lua_getmetatable(info->L, -1)) {                          /* ... obj mt */
+    lua_pushstring(info->L, info->u.pi.metafield);         /* ... obj mt pkey */
+    lua_rawget(info->L, -2);                           /* ... obj mt persist? */
+    switch (lua_type(info->L, -1)) {
+      /* No entry, act according to default. */
+      case LUA_TNIL:                                        /* ... obj mt nil */
+        lua_pop(info->L, 2);                                       /* ... obj */
+        break;
+
+      /* Boolean value, tells us whether allowed or not. */
+      case LUA_TBOOLEAN:                                   /* ... obj mt bool */
+        allow = lua_toboolean(info->L, -1);
+        lua_pop(info->L, 2);                                       /* ... obj */
+        break;
+
+      /* Function value, call it and don't persist literally. */
+      case LUA_TFUNCTION:                                  /* ... obj mt func */
+        lua_replace(info->L, -2);                             /* ... obj func */
+        lua_pushvalue(info->L, -2);                       /* ... obj func obj */
+
+        if (info->passIOToPersist) {
+          lua_pushlightuserdata(info->L, info->u.pi.writer);
+                                                   /* ... obj func obj writer */
+          lua_pushlightuserdata(info->L, info->u.pi.ud);
+                                                /* ... obj func obj writer ud */
+          lua_call(info->L, 3, 1);                           /* ... obj func? */
+        }
+        else {
+          lua_call(info->L, 1, 1);                           /* ... obj func? */
+        }
+        if (!lua_isfunction(info->L, -1)) {                     /* ... obj :( */
+          eris_error(info, "%s did not return a function",
+                     info->u.pi.metafield);
+        }                                                     /* ... obj func */
+
+        /* Special persistence, call this function when unpersisting. */
+        WRITE_VALUE(true, uint8_t);
+        persist(info);                                        /* ... obj func */
+        lua_pop(info->L, 1);                                       /* ... obj */
+        return;
+      default:                                               /* ... obj mt :( */
+        eris_error(info, "%d not nil, boolean, or function",
+                   info->u.pi.metafield);
+        return; /* not reached */
+    }
+  }
+
+  if (allow) {
+    /* Not special but literally persisted object. */
+    WRITE_VALUE(false, uint8_t);
+    literal(info);                                                 /* ... obj */
+  }
+  else if (lua_type(info->L, -1) == LUA_TTABLE) {
+    eris_error(info, "attempt to persist forbidden table");
+  }
+  else {
+    eris_error(info, "attempt to literally persist userdata");
+  }
+}
+
+static void
+u_special(Info *info, int type, Callback literal) {                    /* ... */
+  eris_checkstack(info->L, 2);
+  if (READ_VALUE(uint8_t)) {
+    int reference;
+    /* Reserve entry in the reftable before unpersisting the function to keep
+     * the reference order intact. We can set this to nil at first, because
+     * there's no way the special function would access this. */
+    lua_pushnil(info->L);                                          /* ... nil */
+    reference = registerobject(info);
+    lua_pop(info->L, 1);                                               /* ... */
+    /* Increment reference counter by one to compensate for the increment when
+     * persisting a special object. */
+    unpersist(info);                                           /* ... spfunc? */
+    if (!lua_isfunction(info->L, -1)) {                             /* ... :( */
+      eris_error(info, "invalid restore function");
+    }                                                           /* ... spfunc */
+
+    if (info->passIOToPersist) {
+      lua_pushlightuserdata(info->L, &info->u.upi.zio);     /* ... spfunc zio */
+      lua_call(info->L, 1, 1);                                    /* ... obj? */
+    } else {
+      lua_call(info->L, 0, 1);                                    /* ... obj? */
+    }
+
+    if (lua_type(info->L, -1) != type) {                            /* ... :( */
+      eris_error(info, "bad unpersist function (%s expected, returned %s)",
+                       kTypenames[type], kTypenames[lua_type(info->L, -1)]);
+    }                                                              /* ... obj */
+
+    /* Update the reftable entry. */
+    lua_pushvalue(info->L, -1);                                /* ... obj obj */
+    lua_rawseti(info->L, 2, reference);                            /* ... obj */
+  }
+  else {
+    literal(info);                                                 /* ... obj */
+  }
+}
+
+/** ======================================================================== */
+
+static void
+p_table(Info *info) {                                              /* ... tbl */
+  p_special(info, p_literaltable);                                 /* ... tbl */
+}
+
+static void
+u_table(Info *info) {                                                  /* ... */
+  u_special(info, LUA_TTABLE, u_literaltable);                     /* ... tbl */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TTABLE);
+}
+
+/** ======================================================================== */
+
+static void
+p_userdata(Info *info) {                            /* perms reftbl ... udata */
+  p_special(info, p_literaluserdata);
+}
+
+static void
+u_userdata(Info *info) {                                               /* ... */
+  u_special(info, LUA_TUSERDATA, u_literaluserdata);             /* ... udata */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TUSERDATA);
+}
+
+/*
+** ============================================================================
+** Closures and threads.
+** ============================================================================
+*/
+
+/* We track the actual upvalues themselves by pushing their "id" (meaning a
+ * pointer to them) as lightuserdata to the reftable. This is safe because
+ * lightuserdata will not normally end up in there, because simple value types
+ * are always persisted directly (because that'll be just as large, memory-
+ * wise as when pointing to the first instance). Same for protos. */
+
+static void
+p_proto(Info *info) {                                            /* ... proto */
+  int i;
+  const Proto *p = lua_touserdata(info->L, -1);
+  eris_checkstack(info->L, 3);
+
+  /* Write general information. */
+  WRITE_VALUE(p->linedefined, int);
+  WRITE_VALUE(p->lastlinedefined, int);
+  WRITE_VALUE(p->numparams, uint8_t);
+  WRITE_VALUE(p->is_vararg, uint8_t);
+  WRITE_VALUE(p->maxstacksize, uint8_t);
+
+  /* Write byte code. */
+  WRITE_VALUE(p->sizecode, int);
+  WRITE(p->code, p->sizecode, Instruction);
+
+  /* Write constants. */
+  WRITE_VALUE(p->sizek, int);
+  pushpath(info, ".constants");
+  for (i = 0; i < p->sizek; ++i) {
+    pushpath(info, "[%d]", i);
+    eris_setobj(info->L, info->L->top++, &p->k[i]);      /* ... lcl proto obj */
+    persist(info);                                       /* ... lcl proto obj */
+    lua_pop(info->L, 1);                                     /* ... lcl proto */
+    poppath(info);
+  }
+  poppath(info);
+
+  /* Write child protos. */
+  WRITE_VALUE(p->sizep, int);
+  pushpath(info, ".protos");
+  for (i = 0; i < p->sizep; ++i) {
+    pushpath(info, "[%d]", i);
+    lua_pushlightuserdata(info->L, p->p[i]);           /* ... lcl proto proto */
+    lua_pushvalue(info->L, -1);                  /* ... lcl proto proto proto */
+    persist_keyed(info, LUA_TPROTO);                   /* ... lcl proto proto */
+    lua_pop(info->L, 1);                                     /* ... lcl proto */
+    poppath(info);
+  }
+  poppath(info);
+
+  /* Write upvalues. */
+  WRITE_VALUE(p->sizeupvalues, int);
+  for (i = 0; i < p->sizeupvalues; ++i) {
+    WRITE_VALUE(p->upvalues[i].instack, uint8_t);
+    WRITE_VALUE(p->upvalues[i].idx, uint8_t);
+  }
+
+  /* If we don't have to persist debug information skip the rest. */
+  WRITE_VALUE(info->u.pi.writeDebugInfo, uint8_t);
+  if (!info->u.pi.writeDebugInfo) {
+    return;
+  }
+
+  /* Write function source code. */
+  pushtstring(info->L, p->source);                    /* ... lcl proto source */
+  persist(info);                                      /* ... lcl proto source */
+  lua_pop(info->L, 1);                                       /* ... lcl proto */
+
+  /* Write line information. */
+  WRITE_VALUE(p->sizelineinfo, int);
+  WRITE(p->lineinfo, p->sizelineinfo, int);
+
+  /* Write locals info. */
+  WRITE_VALUE(p->sizelocvars, int);
+  pushpath(info, ".locvars");
+  for (i = 0; i < p->sizelocvars; ++i) {
+    pushpath(info, "[%d]", i);
+    WRITE_VALUE(p->locvars[i].startpc, int);
+    WRITE_VALUE(p->locvars[i].endpc, int);
+    pushtstring(info->L, p->locvars[i].varname);     /* ... lcl proto varname */
+    persist(info);                                   /* ... lcl proto varname */
+    lua_pop(info->L, 1);                                     /* ... lcl proto */
+    poppath(info);
+  }
+  poppath(info);
+
+  /* Write upvalue names. */
+  pushpath(info, ".upvalnames");
+  for (i = 0; i < p->sizeupvalues; ++i) {
+    pushpath(info, "[%d]", i);
+    pushtstring(info->L, p->upvalues[i].name);          /* ... lcl proto name */
+    persist(info);                                      /* ... lcl proto name */
+    lua_pop(info->L, 1);                                     /* ... lcl proto */
+    poppath(info);
+  }
+  poppath(info);
+}
+
+static void
+u_proto(Info *info) {                                            /* ... proto */
+  int i, n;
+  Proto *p = lua_touserdata(info->L, -1);
+  eris_assert(p);
+
+  eris_checkstack(info->L, 2);
+
+  /* Preregister proto for handling of cycles (probably impossible, but
+   * maybe via the constants of the proto... not worth taking the risk). */
+  registerobject(info);
+
+  /* Read general information. */
+  p->linedefined = READ_VALUE(int);
+  p->lastlinedefined = READ_VALUE(int);
+  p->numparams = READ_VALUE(uint8_t);
+  p->is_vararg = READ_VALUE(uint8_t);
+  p->maxstacksize = READ_VALUE(uint8_t);
+
+  /* Read byte code. */
+  p->sizecode = READ_VALUE(int);
+  eris_reallocvector(info->L, p->code, 0, p->sizecode, Instruction);
+  READ(p->code, p->sizecode, Instruction);
+
+  /* Read constants. */
+  p->sizek = READ_VALUE(int);
+  eris_reallocvector(info->L, p->k, 0, p->sizek, TValue);
+  /* Set all values to nil to avoid confusing the GC. */
+  for (i = 0, n = p->sizek; i < n; ++i) {
+    eris_setnilvalue(&p->k[i]);
+  }
+  pushpath(info, ".constants");
+  for (i = 0, n = p->sizek; i < n; ++i) {
+    pushpath(info, "[%d]", i);
+    unpersist(info);                                         /* ... proto obj */
+    eris_setobj(info->L, &p->k[i], info->L->top - 1);
+    lua_pop(info->L, 1);                                         /* ... proto */
+    poppath(info);
+  }
+  poppath(info);
+
+  /* Read child protos. */
+  p->sizep = READ_VALUE(int);
+  eris_reallocvector(info->L, p->p, 0, p->sizep, Proto*);
+  /* Null all entries to avoid confusing the GC. */
+  memset(p->p, 0, p->sizep * sizeof(Proto*));
+  pushpath(info, ".protos");
+  for (i = 0, n = p->sizep; i < n; ++i) {
+    Proto *cp;
+    pushpath(info, "[%d]", i);
+    p->p[i] = eris_newproto(info->L);
+    lua_pushlightuserdata(info->L, p->p[i]);              /* ... proto nproto */
+    unpersist(info);                        /* ... proto nproto nproto/oproto */
+    cp = lua_touserdata(info->L, -1);
+    if (cp != p->p[i]) {                           /* ... proto nproto oproto */
+      /* Just overwrite it, GC will clean this up. */
+      p->p[i] = cp;
+    }
+    lua_pop(info->L, 2);                                         /* ... proto */
+    poppath(info);
+  }
+  poppath(info);
+
+  /* Read upvalues. */
+  p->sizeupvalues = READ_VALUE(int);
+  eris_reallocvector(info->L, p->upvalues, 0, p->sizeupvalues, Upvaldesc);
+  for (i = 0, n = p->sizeupvalues; i < n; ++i) {
+    p->upvalues[i].name = NULL;
+    p->upvalues[i].instack = READ_VALUE(uint8_t);
+    p->upvalues[i].idx = READ_VALUE(uint8_t);
+  }
+
+  /* Read debug information if any is present. */
+  if (!READ_VALUE(uint8_t)) {
+    return;
+  }
+
+  /* Read function source code. */
+  unpersist(info);                                           /* ... proto str */
+  copytstring(info->L, &p->source);
+  lua_pop(info->L, 1);                                           /* ... proto */
+
+  /* Read line information. */
+  p->sizelineinfo = READ_VALUE(int);
+  eris_reallocvector(info->L, p->lineinfo, 0, p->sizelineinfo, int);
+  READ(p->lineinfo, p->sizelineinfo, int);
+
+  /* Read locals info. */
+  p->sizelocvars = READ_VALUE(int);
+  eris_reallocvector(info->L, p->locvars, 0, p->sizelocvars, LocVar);
+  /* Null the variable names to avoid confusing the GC. */
+  for (i = 0, n = p->sizelocvars; i < n; ++i) {
+    p->locvars[i].varname = NULL;
+  }
+  pushpath(info, ".locvars");
+  for (i = 0, n = p->sizelocvars; i < n; ++i) {
+    pushpath(info, "[%d]", i);
+    p->locvars[i].startpc = READ_VALUE(int);
+    p->locvars[i].endpc = READ_VALUE(int);
+    unpersist(info);                                         /* ... proto str */
+    copytstring(info->L, &p->locvars[i].varname);
+    lua_pop(info->L, 1);                                         /* ... proto */
+    poppath(info);
+  }
+  poppath(info);
+
+  /* Read upvalue names. */
+  pushpath(info, ".upvalnames");
+  for (i = 0, n = p->sizeupvalues; i < n; ++i) {
+    pushpath(info, "[%d]", i);
+    unpersist(info);                                         /* ... proto str */
+    copytstring(info->L, &p->upvalues[i].name);
+    lua_pop(info->L, 1);                                         /* ... proto */
+    poppath(info);
+  }
+  poppath(info);
+  lua_pushvalue(info->L, -1);                              /* ... proto proto */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
+}
+
+/** ======================================================================== */
+
+static void
+p_upval(Info *info) {                                              /* ... obj */
+  persist(info);                                                   /* ... obj */
+}
+
+static void
+u_upval(Info *info) {                                                  /* ... */
+  eris_checkstack(info->L, 2);
+
+  /* Create the table we use to store the pointer to the actual upval (1), the
+   * value of the upval (2) and any pointers to the pointer to the upval (3+).*/
+  lua_createtable(info->L, 3, 0);                                  /* ... tbl */
+  registerobject(info);
+  unpersist(info);                                             /* ... tbl obj */
+  lua_rawseti(info->L, -2, 1);                                     /* ... tbl */
+
+  eris_assert(lua_type(info->L, -1) == LUA_TTABLE);
+}
+
+/** ======================================================================== */
+
+/* For Lua closures we write the upvalue ID, which is usually the memory
+ * address at which it is stored. This is used to tell which upvalues are
+ * identical when unpersisting. */
+/* In either case we store the upvale *values*, i.e. the actual objects they
+ * point to. As in Pluto, we will restore any upvalues of Lua closures as
+ * closed as first, i.e. the upvalue will store the TValue itself. When
+ * loading a thread containing the upvalue (meaning it's the actual owner of
+ * the upvalue) we open it, i.e. we point it to the thread's upvalue list.
+ * For C closures, upvalues are always closed. */
+static void
+p_closure(Info *info) {                              /* perms reftbl ... func */
+  int nup;
+  eris_checkstack(info->L, 2);
+  switch (ttype(info->L->top - 1)) {
+    case LUA_TLCF: /* light C function */
+      /* We cannot persist these, they have to be handled via the permtable. */
+      eris_error(info, "attempt to persist a light C function (%p)",
+                 lua_tocfunction(info->L, -1));
+      return; /* not reached */
+    case LUA_TCCL: /* C closure */ {                  /* perms reftbl ... ccl */
+      CClosure *cl = clCvalue(info->L->top - 1);
+      /* Mark it as a C closure. */
+      WRITE_VALUE(true, uint8_t);
+      /* Write the upvalue count first, since we have to know it when creating
+       * a new closure when unpersisting. */
+      WRITE_VALUE(cl->nupvalues, uint8_t);
+
+      /* We can only persist these if the underlying C function is in the
+       * permtable. So we try to persist it first as a light C function. If it
+       * isn't in the permtable that'll cause an error (in the case above). */
+      lua_pushcfunction(info->L, lua_tocfunction(info->L, -1));
+                                                /* perms reftbl ... ccl cfunc */
+      persist(info);                            /* perms reftbl ... ccl cfunc */
+      lua_pop(info->L, 1);                            /* perms reftbl ... ccl */
+
+      /* Persist the upvalues. Since for C closures all upvalues are always
+       * closed we can just write the actual values. */
+      pushpath(info, ".upvalues");
+      for (nup = 1; nup <= cl->nupvalues; ++nup) {
+        pushpath(info, "[%d]", nup);
+        lua_getupvalue(info->L, -1, nup);         /* perms reftbl ... ccl obj */
+        persist(info);                            /* perms reftbl ... ccl obj */
+        lua_pop(info->L, 1);                          /* perms reftbl ... ccl */
+        poppath(info);
+      }
+      poppath(info);
+      break;
+    }
+    case LUA_TLCL: /* Lua function */ {               /* perms reftbl ... lcl */
+      LClosure *cl = clLvalue(info->L->top - 1);
+      /* Mark it as a Lua closure. */
+      WRITE_VALUE(false, uint8_t);
+      /* Write the upvalue count first, since we have to know it when creating
+       * a new closure when unpersisting. */
+      WRITE_VALUE(cl->nupvalues, uint8_t);
+
+      /* Persist the function's prototype. Pass the proto as a parameter to
+       * p_proto so that it can access it and register it in the ref table. */
+      pushpath(info, ".proto");
+      lua_pushlightuserdata(info->L, cl->p);    /* perms reftbl ... lcl proto */
+      lua_pushvalue(info->L, -1);         /* perms reftbl ... lcl proto proto */
+      persist_keyed(info, LUA_TPROTO);          /* perms reftbl ... lcl proto */
+      lua_pop(info->L, 1);                            /* perms reftbl ... lcl */
+      poppath(info);
+
+      /* Persist the upvalues. We pretend to write these as their own type,
+       * to get proper identity preservation. We also pass them as a parameter
+       * to p_upval so it can register the upvalue in the reference table. */
+      pushpath(info, ".upvalues");
+      for (nup = 1; nup <= cl->nupvalues; ++nup) {
+        const char *name = lua_getupvalue(info->L, -1, nup);
+                                                  /* perms reftbl ... lcl obj */
+        pushpath(info, ".%s", name);
+        lua_pushlightuserdata(info->L, lua_upvalueid(info->L, -2, nup));
+                                               /* perms reftbl ... lcl obj id */
+        persist_keyed(info, LUA_TUPVAL);          /* perms reftbl ... lcl obj */
+        lua_pop(info->L, 1);                         /* perms reftble ... lcl */
+        poppath(info);
+      }
+      poppath(info);
+      break;
+    }
+    default:
+      eris_error(info, "attempt to persist unknown function type");
+      return; /* not reached */
+  }
+}
+
+static void
+u_closure(Info *info) {                                                /* ... */
+  int nup;
+  bool isCClosure = READ_VALUE(uint8_t);
+  lu_byte nups = READ_VALUE(uint8_t);
+  if (isCClosure) {
+    lua_CFunction f;
+
+    /* Reserve reference for the closure to avoid light C function or its
+     * perm table key going first. */
+    const int reference = ++(info->refcount);
+
+    /* nups is guaranteed to be >= 1, otherwise it'd be a light C function. */
+    eris_checkstack(info->L, nups < 2 ? 2 : nups);
+
+    /* Read the C function from the permanents table. */
+    unpersist(info);                                             /* ... cfunc */
+    if (!lua_iscfunction(info->L, -1)) {
+      eris_error(info, "bad C closure (C function expected, got %s)",
+                 kTypenames[lua_type(info->L, -1)]);
+    }
+    f = lua_tocfunction(info->L, -1);
+    if (!f) {
+      eris_error(info, "bad C closure (C function expected, got null)");
+    }
+    lua_pop(info->L, 1);                                               /* ... */
+
+    /* Now this is a little roundabout, but we want to create the closure
+     * before unpersisting the actual upvalues to avoid cycles. So we have to
+     * create it with all nil first, then fill the upvalues in afterwards. */
+    for (nup = 1; nup <= nups; ++nup) {
+      lua_pushnil(info->L);                        /* ... nil[1] ... nil[nup] */
+    }
+    lua_pushcclosure(info->L, f, nups);                            /* ... ccl */
+
+    /* Create the entry in the reftable. */
+    lua_pushvalue(info->L, -1);                   /* perms reftbl ... ccl ccl */
+    lua_rawseti(info->L, REFTIDX, reference);         /* perms reftbl ... ccl */
+
+    /* Unpersist actual upvalues. */
+    pushpath(info, ".upvalues");
+    for (nup = 1; nup <= nups; ++nup) {
+      pushpath(info, "[%d]", nup);
+      unpersist(info);                                         /* ... ccl obj */
+      lua_setupvalue(info->L, -2, nup);                            /* ... ccl */
+      poppath(info);
+    }
+    poppath(info);
+  }
+  else {
+    Closure *cl;
+    Proto *p;
+
+    eris_checkstack(info->L, 4);
+
+    /* Create closure and anchor it on the stack (avoid collection via GC). */
+    cl = eris_newLclosure(info->L, nups);
+    eris_setclLvalue(info->L, info->L->top, cl);                   /* ... lcl */
+    eris_incr_top(info->L);
+
+    /* Preregister closure for handling of cycles (upvalues). */
+    registerobject(info);
+
+    /* Read prototype. In general, we create protos (and upvalues) before
+     * trying to read them and pass a pointer to the instance along to the
+     * unpersist function. This way the instance is safely hooked up to an
+     * object, so we don't have to worry about it getting GCed. */
+    pushpath(info, ".proto");
+    cl->l.p = eris_newproto(info->L);
+    /* Push the proto into which to unpersist as a parameter to u_proto. */
+    lua_pushlightuserdata(info->L, cl->l.p);                /* ... lcl nproto */
+    unpersist(info);                          /* ... lcl nproto nproto/oproto */
+    eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
+    /* The proto we have now may differ, if we already unpersisted it before.
+     * In that case we now have a reference to the originally unpersisted
+     * proto so we'll use that. */
+    p = lua_touserdata(info->L, -1);
+    if (p != cl->l.p) {                              /* ... lcl nproto oproto */
+      /* Just overwrite the old one, GC will clean this up. */
+      cl->l.p = p;
+    }
+    lua_pop(info->L, 2);                                           /* ... lcl */
+    eris_assert(cl->l.p->sizeupvalues == nups);
+    poppath(info);
+
+    /* Unpersist all upvalues. */
+    pushpath(info, ".upvalues");
+    for (nup = 1; nup <= nups; ++nup) {
+      UpVal **uv = &cl->l.upvals[nup - 1];
+      /* Get the actual name of the upvalue, if possible. */
+      if (p->upvalues[nup - 1].name) {
+        pushpath(info, "[%s]", getstr(p->upvalues[nup - 1].name));
+      }
+      else {
+        pushpath(info, "[%d]", nup);
+      }
+      unpersist(info);                                         /* ... lcl tbl */
+      eris_assert(lua_type(info->L, -1) == LUA_TTABLE);
+      lua_rawgeti(info->L, -1, 2);                   /* ... lcl tbl upval/nil */
+      if (lua_isnil(info->L, -1)) {                        /* ... lcl tbl nil */
+        lua_pop(info->L, 1);                                   /* ... lcl tbl */
+        *uv = eris_newupval(info->L);
+        lua_pushlightuserdata(info->L, *uv);             /* ... lcl tbl upval */
+        lua_rawseti(info->L, -2, 2);                           /* ... lcl tbl */
+      }
+      else {                                             /* ... lcl tbl upval */
+        eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
+        *uv = (UpVal*)lua_touserdata(info->L, -1);
+        lua_pop(info->L, 1);                                   /* ... lcl tbl */
+      }
+
+      /* Set the upvalue's actual value and add our reference to the upvalue to
+       * the list, for pointer patching if we have to open the upvalue in
+       * u_thread. Either is only necessary if the upvalue is still closed. */
+      if ((*uv)->v == &(*uv)->u.value) {
+        /* Always update the value of the upvalue's value for closed upvalues,
+         * even if we re-used one - if we had a cycle, it might have been
+         * incorrectly initialized to nil before. */
+        lua_rawgeti(info->L, -1, 1);                       /* ... lcl tbl obj */
+        eris_setobj(info->L, &(*uv)->u.value, info->L->top - 1);
+        lua_pop(info->L, 1);                                   /* ... lcl tbl */
+
+        lua_pushlightuserdata(info->L, uv);             /* ... lcl tbl upvalp */
+        if (luaL_len(info->L, -2) >= 2) {
+          /* Got a valid sequence, insert at the end. */
+          lua_rawseti(info->L, -2, luaL_len(info->L, -2) + 1); /* ... lcl tbl */
+        }
+        else {                                          /* ... lcl tbl upvalp */
+          int i;
+          /* Find where to insert. This can happen if we have cycles, in which
+           * case the table is not fully initialized at this point, i.e. the
+           * value is not in it, yet (we work around that by always setting it,
+           * as seen above). */
+          for (i = 3;; ++i) {
+            lua_rawgeti(info->L, -2, i);     /* ... lcl tbl upvalp upvalp/nil */
+            if (lua_isnil(info->L, -1)) {           /* ... lcl tbl upvalp nil */
+              lua_pop(info->L, 1);                      /* ... lcl tbl upvalp */
+              lua_rawseti(info->L, -2, i);                     /* ... lcl tbl */
+              break;
+            }
+            else {
+              lua_pop(info->L, 1);                      /* ... lcl tbl upvalp */
+            }
+          }                                                    /* ... lcl tbl */
+        }
+      }
+
+      lua_pop(info->L, 1);                                         /* ... lcl */
+      poppath(info);
+    }
+    poppath(info);
+
+    eris_barrierproto(info->L, p, cl);
+    p->cache = cl; /* save it in cache for reuse, see lvm.c:416 */
+  }
+
+  eris_assert(lua_type(info->L, -1) == LUA_TFUNCTION);
+}
+
+/** ======================================================================== */
+
+static void
+p_thread(Info *info) {                                          /* ... thread */
+  lua_State* thread = lua_tothread(info->L, -1);
+  size_t level;
+  StkId o;
+  CallInfo *ci;
+  UpVal *uv;
+
+  eris_checkstack(info->L, 2);
+
+  /* We cannot persist any running threads, because by definition we *are* that
+   * running thread. And we use the stack. So yeah, really not a good idea. */
+  if (thread == info->L) {
+    eris_error(info, "cannot persist currently running thread");
+    return; /* not reached */
+  }
+
+  /* Persist the stack. Save the total size and used space first. */
+  WRITE_VALUE(thread->stacksize, int);
+  WRITE_VALUE(thread->top - thread->stack, size_t);
+
+  /* The Lua stack looks like this:
+   * stack ... top ... stack_last
+   * Where stack <= top <= stack_last, and "top" actually being the first free
+   * element, i.e. there's nothing stored there. So we stop one below that. */
+  pushpath(info, ".stack");
+  lua_pushnil(info->L);                                     /* ... thread nil */
+  level = 0;
+  for (o = thread->stack; o < thread->top; ++o) {
+    pushpath(info, "[%d]", level++);
+    eris_setobj(info->L, info->L->top - 1, o);              /* ... thread obj */
+    persist(info);                                          /* ... thread obj */
+    poppath(info);
+  }
+  lua_pop(info->L, 1);                                          /* ... thread */
+  poppath(info);
+
+  /* If the thread isn't running this must be the default value, which is 1. */
+  eris_assert(thread->nny == 1);
+
+  /* Error jump info should only be set while thread is running. */
+  eris_assert(thread->errorJmp == NULL);
+
+  /* thread->oldpc always seems to be uninitialized, at least gdb always shows
+   * it as 0xbaadf00d when I set a breakpoint here. */
+
+  /* Write general information. */
+  WRITE_VALUE(thread->status, uint8_t);
+  WRITE_VALUE(eris_savestackidx(thread,
+    eris_restorestack(thread, thread->errfunc)), size_t);
+  /* These are only used while a thread is being executed or can be deduced:
+  WRITE_VALUE(thread->nCcalls, uint16_t);
+  WRITE_VALUE(thread->allowhook, uint8_t); */
+
+  /* Hooks are not supported, bloody can of worms, those.
+  WRITE_VALUE(thread->hookmask, uint8_t);
+  WRITE_VALUE(thread->basehookcount, int);
+  WRITE_VALUE(thread->hookcount, int); */
+
+  if (thread->hook) {
+    /* TODO Warn that hooks are not persisted? */
+  }
+
+  /* Write call information (stack frames). In 5.2 CallInfo is stored in a
+   * linked list that originates in thead.base_ci. Upon initialization the
+   * thread.ci is set to thread.base_ci. During thread calls this is extended
+   * and always represents the tail of the callstack, though not necessarily of
+   * the linked list (which can be longer if the callstack was deeper earlier,
+   * but shrunk due to returns). */
+  pushpath(info, ".callinfo");
+  level = 0;
+  eris_assert(&thread->base_ci != thread->ci->next);
+  for (ci = &thread->base_ci; ci != thread->ci->next; ci = ci->next) {
+    pushpath(info, "[%d]", level++);
+    WRITE_VALUE(eris_savestackidx(thread, ci->func), size_t);
+    WRITE_VALUE(eris_savestackidx(thread, ci->top), size_t);
+    WRITE_VALUE(ci->nresults, int16_t);
+    WRITE_VALUE(ci->callstatus, uint8_t);
+    /* CallInfo.extra is used in two contexts: if L->status == LUA_YIELD and
+     * CallInfo is the one stored as L->ci, in which case ci->extra refers to
+     * the original value of L->ci->func, and when we have a yieldable pcall
+     * (ci->callstatus & CIST_YPCALL) where ci->extra holds the stack level
+     * of the function being called (see lua_pcallk). We save the ci->extra
+     * for L->ci after the loop, because we won't know which one it is when
+     * unpersisting. */
+    if (ci->callstatus & CIST_YPCALL) {
+      WRITE_VALUE(eris_savestackidx(thread,
+        eris_restorestack(thread, ci->extra)), size_t);
+    }
+
+    eris_assert(eris_isLua(ci) || (ci->callstatus & CIST_TAIL) == 0);
+    if (ci->callstatus & CIST_HOOKYIELD) {
+      eris_error(info, "cannot persist yielded hooks");
+    }
+
+    if (eris_isLua(ci)) {
+      const LClosure *lcl = eris_ci_func(ci);
+      WRITE_VALUE(eris_savestackidx(thread, ci->u.l.base), size_t);
+      WRITE_VALUE(ci->u.l.savedpc - lcl->p->code, size_t);
+    }
+    else {
+      WRITE_VALUE(ci->u.c.status, uint8_t);
+
+      /* These are only used while a thread is being executed:
+      WRITE_VALUE(ci->u.c.old_errfunc, ptrdiff_t);
+      WRITE_VALUE(ci->u.c.old_allowhook, uint8_t); */
+
+      /* TODO Is this really right? Hooks may be a problem? */
+      if (ci->callstatus & (CIST_YPCALL | CIST_YIELDED)) {
+        WRITE_VALUE(ci->u.c.ctx, int);
+        eris_assert(ci->u.c.k);
+        lua_pushcfunction(info->L, ci->u.c.k);             /* ... thread func */
+        persist(info);                                 /* ... thread func/nil */
+        lua_pop(info->L, 1);                                    /* ... thread */
+      }
+    }
+
+    /* Write whether there's more to come. */
+    WRITE_VALUE(ci->next == thread->ci->next, uint8_t);
+
+    poppath(info);
+  }
+  /** See comment on ci->extra in loop. */
+  if (thread->status == LUA_YIELD) {
+    WRITE_VALUE(eris_savestackidx(thread,
+        eris_restorestack(thread, thread->ci->extra)), size_t);
+  }
+  poppath(info);
+
+  pushpath(info, ".openupval");
+  lua_pushnil(info->L);                                     /* ... thread nil */
+  level = 0;
+  for (uv = eris_gco2uv(thread->openupval);
+       uv != NULL;
+       uv = eris_gco2uv(eris_gch(eris_obj2gco(uv))->next))
+  {
+    pushpath(info, "[%d]", level);
+    WRITE_VALUE(eris_savestackidx(thread, uv->v) + 1, size_t);
+    eris_setobj(info->L, info->L->top - 1, uv->v);          /* ... thread obj */
+    lua_pushlightuserdata(info->L, uv);                  /* ... thread obj id */
+    persist_keyed(info, LUA_TUPVAL);                        /* ... thread obj */
+    poppath(info);
+  }
+  WRITE_VALUE(0, size_t);
+  lua_pop(info->L, 1);                                          /* ... thread */
+  poppath(info);
+}
+
+/* Used in u_thread to validate read stack positions. */
+#define validate(stackpos, inclmax) \
+  if ((stackpos) < thread->stack || stackpos > (inclmax)) { \
+    (stackpos) = thread->stack; \
+    eris_error(info, "stack index out of bounds"); }
+
+/* I had so hoped to get by without any 'hacks', but I surrender. We mark the
+ * thread as incomplete to avoid the GC messing with it while we're building
+ * it. Otherwise it may try to shrink its stack. We do this by setting its
+ * stack field to null for every call that may trigger a GC run, since that
+ * field is what's used to determine whether threads should be shrunk. See
+ * lgc.c:699. Some of the locks could probably be joined (since nothing
+ * inbetween requires the stack field to be valid), but I prefer to keep the
+ * "invalid" blocks as small as possible to make it clearer. Also, locking and
+ * unlocking are really just variable assignments, so they're really cheap. */
+#define LOCK(L) (L->stack = NULL)
+#define UNLOCK(L) (L->stack = stack)
+
+static void
+u_thread(Info *info) {                                                 /* ... */
+  lua_State* thread;
+  size_t level;
+  StkId stack, o;
+
+  eris_checkstack(info->L, 3);
+
+  thread = lua_newthread(info->L);                              /* ... thread */
+  registerobject(info);
+
+  /* Unpersist the stack. Read size first and adjust accordingly. */
+  eris_reallocstack(thread, READ_VALUE(int));
+  stack = thread->stack; /* After the realloc in case the address changes. */
+  thread->top = thread->stack + READ_VALUE(size_t);
+  validate(thread->top, thread->stack_last);
+
+  /* Read the elements one by one. */
+  LOCK(thread);
+  pushpath(info, ".stack");
+  UNLOCK(thread);
+  level = 0;
+  for (o = stack; o < thread->top; ++o) {
+    LOCK(thread);
+    pushpath(info, "[%d]", level++);
+    unpersist(info);                                        /* ... thread obj */
+    UNLOCK(thread);
+    eris_setobj(thread, o, info->L->top - 1);
+    lua_pop(info->L, 1);                                        /* ... thread */
+    LOCK(thread);
+    poppath(info);
+    UNLOCK(thread);
+  }
+  LOCK(thread);
+  poppath(info);
+  UNLOCK(thread);
+
+  /* As in p_thread, just to make sure. */
+  eris_assert(thread->nny == 1);
+  eris_assert(thread->errorJmp == NULL);
+  eris_assert(thread->hook == NULL);
+
+  /* See comment in persist. */
+  thread->oldpc = NULL;
+
+  /* Read general information. */
+  thread->status = READ_VALUE(uint8_t);
+  thread->errfunc = eris_savestack(thread,
+    eris_restorestackidx(thread, READ_VALUE(size_t)));
+  if (thread->errfunc) {
+    o = eris_restorestack(thread, thread->errfunc);
+    validate(o, thread->top);
+    if (eris_ttypenv(o) != LUA_TFUNCTION) {
+      eris_error(info, "invalid errfunc");
+    }
+  }
+  /* These are only used while a thread is being executed or can be deduced:
+  thread->nCcalls = READ_VALUE(uint16_t);
+  thread->allowhook = READ_VALUE(uint8_t); */
+  eris_assert(thread->allowhook == 1);
+
+  /* Not supported.
+  thread->hookmask = READ_VALUE(uint8_t);
+  thread->basehookcount = READ_VALUE(int);
+  thread->hookcount = READ_VALUE(int); */
+
+  /* Read call information (stack frames). */
+  LOCK(thread);
+  pushpath(info, ".callinfo");
+  UNLOCK(thread);
+  thread->ci = &thread->base_ci;
+  level = 0;
+  for (;;) {
+    LOCK(thread);
+    pushpath(info, "[%d]", level++);
+    UNLOCK(thread);
+    thread->ci->func = eris_restorestackidx(thread, READ_VALUE(size_t));
+    validate(thread->ci->func, thread->top - 1);
+    thread->ci->top = eris_restorestackidx(thread, READ_VALUE(size_t));
+    validate(thread->ci->top, thread->stack_last);
+    thread->ci->nresults = READ_VALUE(int16_t);
+    thread->ci->callstatus = READ_VALUE(uint8_t);
+    /** See comment in p_thread. */
+    if (thread->ci->callstatus & CIST_YPCALL) {
+      thread->ci->extra = eris_savestack(thread,
+        eris_restorestackidx(thread, READ_VALUE(size_t)));
+      o = eris_restorestack(thread, thread->ci->extra);
+      validate(o, thread->top);
+      if (eris_ttypenv(o) != LUA_TFUNCTION) {
+        eris_error(info, "invalid callinfo");
+      }
+    }
+
+    if (eris_isLua(thread->ci)) {
+      LClosure *lcl = eris_ci_func(thread->ci);
+      thread->ci->u.l.base = eris_restorestackidx(thread, READ_VALUE(size_t));
+      validate(thread->ci->u.l.base, thread->top);
+      thread->ci->u.l.savedpc = lcl->p->code + READ_VALUE(size_t);
+      if (thread->ci->u.l.savedpc < lcl->p->code ||
+          thread->ci->u.l.savedpc > lcl->p->code + lcl->p->sizecode)
+      {
+        thread->ci->u.l.savedpc = lcl->p->code; /* Just to be safe. */
+        eris_error(info, "saved program counter out of bounds");
+      }
+    }
+    else {
+      thread->ci->u.c.status = READ_VALUE(uint8_t);
+
+      /* These are only used while a thread is being executed:
+      thread->ci->u.c.old_errfunc = READ_VALUE(ptrdiff_t);
+      thread->ci->u.c.old_allowhook = READ_VALUE(uint8_t); */
+      thread->ci->u.c.old_errfunc = 0;
+      thread->ci->u.c.old_allowhook = 0;
+
+      /* TODO Is this really right? */
+      if (thread->ci->callstatus & (CIST_YPCALL | CIST_YIELDED)) {
+        thread->ci->u.c.ctx = READ_VALUE(int);
+        LOCK(thread);
+        unpersist(info);                                  /* ... thread func? */
+        UNLOCK(thread);
+        if (lua_iscfunction(info->L, -1)) {                /* ... thread func */
+          thread->ci->u.c.k = lua_tocfunction(info->L, -1);
+        }
+        else {
+          eris_error(info, "bad C continuation function");
+          return; /* not reached */
+        }
+        lua_pop(info->L, 1);                                    /* ... thread */
+      }
+      else {
+        thread->ci->u.c.ctx = 0;
+        thread->ci->u.c.k = NULL;
+      }
+    }
+    LOCK(thread);
+    poppath(info);
+    UNLOCK(thread);
+
+    /* Read in value for check for next iteration. */
+    if (READ_VALUE(uint8_t)) {
+      break;
+    }
+    else {
+      thread->ci = eris_extendCI(thread);
+    }
+  }
+  if (thread->status == LUA_YIELD) {
+    thread->ci->extra = eris_savestack(thread,
+      eris_restorestackidx(thread, READ_VALUE(size_t)));
+    o = eris_restorestack(thread, thread->ci->extra);
+    validate(o, thread->top);
+    if (eris_ttypenv(o) != LUA_TFUNCTION) {
+      eris_error(info, "invalid callinfo");
+    }
+  }
+  LOCK(thread);
+  poppath(info);
+  UNLOCK(thread);
+
+  /* Get from context: only zero for dead threads, otherwise one. */
+  thread->nCcalls = thread->status != LUA_OK || lua_gettop(thread) != 0;
+
+  /* Proceed to open upvalues. These upvalues will already exist due to the
+   * functions using them having been unpersisted (they'll usually be in the
+   * stack of the thread). For this reason we store all previous references to
+   * the upvalue in a table that is returned when we try to unpersist an
+   * upvalue, so that we can adjust these pointers in here. */
+  LOCK(thread);
+  pushpath(info, ".openupval");
+  UNLOCK(thread);
+  level = 0;
+  for (;;) {
+    UpVal *nuv;
+    StkId stk;
+    /* Get the position of the upvalue on the stack. As a special value we pass
+     * zero to indicate there are no more upvalues. */
+    const size_t offset = READ_VALUE(size_t);
+    if (offset == 0) {
+      break;
+    }
+    LOCK(thread);
+    pushpath(info, "[%d]", level);
+    UNLOCK(thread);
+    stk = eris_restorestackidx(thread, offset - 1);
+    validate(stk, thread->top - 1);
+    LOCK(thread);
+    unpersist(info);                                        /* ... thread tbl */
+    UNLOCK(thread);
+    eris_assert(lua_type(info->L, -1) == LUA_TTABLE);
+
+    /* Create the open upvalue either way. */
+    LOCK(thread);
+    nuv = eris_findupval(thread, stk);
+    UNLOCK(thread);
+
+    /* Then check if we need to patch some pointers. */
+    lua_rawgeti(info->L, -1, 2);                  /* ... thread tbl upval/nil */
+    if (!lua_isnil(info->L, -1)) {                    /* ... thread tbl upval */
+      int i, n;
+      eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
+      /* Already exists, replace it. To do this we have to patch all the
+       * pointers to the already existing one, which we added to the table in
+       * u_closure, starting at index 3. */
+      lua_pop(info->L, 1);                                  /* ... thread tbl */
+      for (i = 3, n = luaL_len(info->L, -1); i <= n; ++i) {
+        lua_rawgeti(info->L, -1, i);                 /* ... thread tbl upvalp */
+        (*(UpVal**)lua_touserdata(info->L, -1)) = nuv;
+        lua_pop(info->L, 1);                                /* ... thread tbl */
+      }
+    }
+    else {                                              /* ... thread tbl nil */
+      eris_assert(lua_isnil(info->L, -1));
+      lua_pop(info->L, 1);                                  /* ... thread tbl */
+    }
+
+    /* Store open upvalue in table for future references. */
+    LOCK(thread);
+    lua_pushlightuserdata(info->L, nuv);              /* ... thread tbl upval */
+    lua_rawseti(info->L, -2, 2);                            /* ... thread tbl */
+    lua_pop(info->L, 1);                                        /* ... thread */
+    poppath(info);
+    UNLOCK(thread);
+  }
+  poppath(info);
+
+  eris_assert(lua_type(info->L, -1) == LUA_TTHREAD);
+}
+
+#undef UNLOCK
+#undef LOCK
+
+#undef validate
+
+/*
+** ============================================================================
+** Top-level delegator.
+** ============================================================================
+*/
+
+static void
+persist_typed(Info *info, int type) {                 /* perms reftbl ... obj */
+  eris_ifassert(const int top = lua_gettop(info->L));
+  if (info->level >= info->maxComplexity) {
+    eris_error(info, "object too complex");
+  }
+  ++info->level;
+
+  WRITE_VALUE(type, int);
+  switch(type) {
+    case LUA_TBOOLEAN:
+      p_boolean(info);
+      break;
+    case LUA_TLIGHTUSERDATA:
+      p_pointer(info);
+      break;
+    case LUA_TNUMBER:
+      p_number(info);
+      break;
+    case LUA_TSTRING:
+      p_string(info);
+      break;
+    case LUA_TTABLE:
+      p_table(info);
+      break;
+    case LUA_TFUNCTION:
+      p_closure(info);
+      break;
+    case LUA_TUSERDATA:
+      p_userdata(info);
+      break;
+    case LUA_TTHREAD:
+      p_thread(info);
+      break;
+    case LUA_TPROTO:
+      p_proto(info);
+      break;
+    case LUA_TUPVAL:
+      p_upval(info);
+      break;
+    default:
+      eris_error(info, "trying to persist unknown type");
+  }                                                   /* perms reftbl ... obj */
+
+  --info->level;
+  eris_assert(top == lua_gettop(info->L));
+}
+
+/* Second-level delegating persist function, used for cases when persisting
+ * data that's stored in the reftable with a key that is not the data itself,
+ * namely upvalues and protos. */
+static void
+persist_keyed(Info *info, int type) {          /* perms reftbl ... obj refkey */
+  eris_checkstack(info->L, 2);
+
+  /* Keep a copy of the key for pushing it to the reftable, if necessary. */
+  lua_pushvalue(info->L, -1);           /* perms reftbl ... obj refkey refkey */
+
+  /* If the object has already been written, write a reference to it. */
+  lua_rawget(info->L, REFTIDX);           /* perms reftbl ... obj refkey ref? */
+  if (!lua_isnil(info->L, -1)) {           /* perms reftbl ... obj refkey ref */
+    const int reference = lua_tointeger(info->L, -1);
+    WRITE_VALUE(reference + ERIS_REFERENCE_OFFSET, int);
+    lua_pop(info->L, 2);                              /* perms reftbl ... obj */
+    return;
+  }                                        /* perms reftbl ... obj refkey nil */
+  lua_pop(info->L, 1);                         /* perms reftbl ... obj refkey */
+
+  /* Copy the refkey for the perms check below. */
+  lua_pushvalue(info->L, -1);           /* perms reftbl ... obj refkey refkey */
+
+  /* Put the value in the reference table. This creates an entry pointing from
+   * the object (or its key) to the id the object is referenced by. */
+  lua_pushinteger(info->L, ++(info->refcount));
+                                    /* perms reftbl ... obj refkey refkey ref */
+  lua_rawset(info->L, REFTIDX);                /* perms reftbl ... obj refkey */
+
+  /* At this point, we'll give the permanents table a chance to play. */
+  lua_gettable(info->L, PERMIDX);            /* perms reftbl ... obj permkey? */
+  if (!lua_isnil(info->L, -1)) {              /* perms reftbl ... obj permkey */
+    type = lua_type(info->L, -2);
+    /* Prepend permanent "type" so that we know it's a permtable key. This will
+     * trigger u_permanent when unpersisting. Also write the original type, so
+     * that we can verify what we get in the permtable when unpersisting is of
+     * the same kind we had when persisting. */
+    WRITE_VALUE(ERIS_PERMANENT, int);
+    WRITE_VALUE(type, uint8_t);
+    persist(info);                            /* perms reftbl ... obj permkey */
+    lua_pop(info->L, 1);                              /* perms reftbl ... obj */
+  }
+  else {                                          /* perms reftbl ... obj nil */
+    /* No entry in the permtable for this object, persist it directly. */
+    lua_pop(info->L, 1);                              /* perms reftbl ... obj */
+    persist_typed(info, type);                        /* perms reftbl ... obj */
+  }                                                   /* perms reftbl ... obj */
+}
+
+/* Top-level delegating persist function. */
+static void
+persist(Info *info) {                                 /* perms reftbl ... obj */
+  /* Grab the object's type. */
+  const int type = lua_type(info->L, -1);
+
+  /* If the object is nil, only write its type. */
+  if (type == LUA_TNIL) {
+    WRITE_VALUE(type, int);
+  }
+  /* Write simple values directly, because writing a "reference" would take up
+   * just as much space and we can save ourselves work this way. */
+  else if (type == LUA_TBOOLEAN ||
+           type == LUA_TLIGHTUSERDATA ||
+           type == LUA_TNUMBER)
+  {
+    persist_typed(info, type);                        /* perms reftbl ... obj */
+  }
+  /* For all non-simple values we keep a record in the reftable, so that we
+   * keep references alive across persisting and unpersisting an object. This
+   * has the nice side-effect of saving some space. */
+  else {
+    eris_checkstack(info->L, 1);
+    lua_pushvalue(info->L, -1);                   /* perms reftbl ... obj obj */
+    persist_keyed(info, type);                        /* perms reftbl ... obj */
+  }
+}
+
+/** ======================================================================== */
+
+static void
+u_permanent(Info *info) {                                 /* perms reftbl ... */
+  const int type = READ_VALUE(uint8_t);
+  /* Reserve reference to avoid the key going first. */
+  const int reference = ++(info->refcount);
+  eris_checkstack(info->L, 1);
+  unpersist(info);                                /* perms reftbl ... permkey */
+  lua_gettable(info->L, PERMIDX);                    /* perms reftbl ... obj? */
+  if (lua_isnil(info->L, -1)) {                       /* perms reftbl ... nil */
+    /* Since we may need permanent values to rebuild other structures, namely
+     * closures and threads, we cannot allow perms to fail unpersisting. */
+    eris_error(info, "bad permanent value (no value)");
+  }
+  else if (lua_type(info->L, -1) != type) {            /* perms reftbl ... :( */
+    /* For the same reason that we cannot allow nil we must also require the
+     * unpersisted value to be of the correct type. */
+    eris_error(info, "bad permanent value (%s expected, got %s)",
+      kTypenames[type], kTypenames[lua_type(info->L, -1)]);
+  }                                                   /* perms reftbl ... obj */
+  /* Create the entry in the reftable. */
+  lua_pushvalue(info->L, -1);                     /* perms reftbl ... obj obj */
+  lua_rawseti(info->L, REFTIDX, reference);           /* perms reftbl ... obj */
+}
+
+static void
+unpersist(Info *info) {                                   /* perms reftbl ... */
+  eris_ifassert(const int top = lua_gettop(info->L));
+  if (info->level >= info->maxComplexity) {
+    eris_error(info, "object too complex");
+  }
+  ++info->level;
+
+  eris_checkstack(info->L, 1);
+  {
+    const int typeOrReference = READ_VALUE(int);
+    if (typeOrReference > ERIS_REFERENCE_OFFSET) {
+      const int reference = typeOrReference - ERIS_REFERENCE_OFFSET;
+      lua_rawgeti(info->L, REFTIDX, reference);   /* perms reftbl ud ... obj? */
+      if (lua_isnil(info->L, -1)) {                 /* perms reftbl ud ... :( */
+        eris_error(info, "invalid reference #%d", reference);
+      }                                            /* perms reftbl ud ... obj */
+    }
+    else {
+      const int type = typeOrReference;
+      switch (type) {
+        case LUA_TNIL:
+          lua_pushnil(info->L);
+          break;
+        case LUA_TBOOLEAN:
+          u_boolean(info);
+          break;
+        case LUA_TLIGHTUSERDATA:
+          u_pointer(info);
+          break;
+        case LUA_TNUMBER:
+          u_number(info);
+          break;
+        case LUA_TSTRING:
+          u_string(info);
+          break;
+        case LUA_TTABLE:
+          u_table(info);
+          break;
+        case LUA_TFUNCTION:
+          u_closure(info);
+          break;
+        case LUA_TUSERDATA:
+          u_userdata(info);
+          break;
+        case LUA_TTHREAD:
+          u_thread(info);
+          break;
+        case LUA_TPROTO:
+          u_proto(info);
+          break;
+        case LUA_TUPVAL:
+          u_upval(info);
+          break;
+        case ERIS_PERMANENT:
+          u_permanent(info);
+          break;
+        default:
+          eris_error(info, "trying to unpersist unknown type %d", type);
+      }                                              /* perms reftbl ... obj? */
+    }
+  }
+
+  --info->level;
+  eris_assert(top + 1 == lua_gettop(info->L));
+}
+
+/* }======================================================================== */
+
+/*
+** {===========================================================================
+** Writer and reader implementation for library calls.
+** ============================================================================
+*/
+
+/* Implementation note: we use the MBuffer struct, but we don't use the built-
+ * in reallocation functions since we'll keep our working copy on the stack, to
+ * allow for proper collection if we have to throw an error. This is very much
+ * what the auxlib does with its buffer functionality. Which we don't use since
+ * we cannot guarantee stack balance inbetween calls to luaL_add*. */
+
+static int
+writer(lua_State *L, const void *p, size_t sz, void *ud) {
+                                               /* perms reftbl buff path? ... */
+  const char *value = (const char*)p;
+  Mbuffer *buff = (Mbuffer*)ud;
+  const size_t size = eris_bufflen(buff);
+  const size_t capacity = eris_sizebuffer(buff);
+  if (capacity - size < sz) {
+    size_t newcapacity = capacity * 2; /* overflow checked below */
+    if (newcapacity - size < sz) {
+      newcapacity = capacity + sz; /* overflow checked below */
+    }
+    if (newcapacity <= capacity) {
+      /* Overflow in capacity, buffer size limit reached. */
+      return 1;
+    } else {
+      char *newbuff;
+      eris_checkstack(L, 1);
+      newbuff = (char*)lua_newuserdata(L, newcapacity * sizeof(char));
+                                         /* perms reftbl buff path? ... nbuff */
+      memcpy(newbuff, eris_buffer(buff), eris_bufflen(buff));
+      lua_replace(L, BUFFIDX);                /* perms reftbl nbuff path? ... */
+      eris_buffer(buff) = newbuff;
+      eris_sizebuffer(buff) = newcapacity;
+    }
+  }
+  memcpy(&eris_buffer(buff)[eris_bufflen(buff)], value, sz);
+  eris_bufflen(buff) += sz;
+  return 0;
+}
+
+/** ======================================================================== */
+
+/* Readonly, interface compatible with MBuffer macros. */
+typedef struct RBuffer {
+  const char *buffer;
+  size_t n;
+  size_t buffsize;
+} RBuffer;
+
+static const char*
+reader(lua_State *L, void *ud, size_t *sz) {
+  RBuffer *buff = (RBuffer*)ud;
+  (void) L; /* unused */
+  if (eris_bufflen(buff) == 0) {
+    return NULL;
+  }
+  *sz = eris_bufflen(buff);
+  eris_bufflen(buff) = 0;
+  return eris_buffer(buff);
+}
+
+/* }======================================================================== */
+
+/*
+** {===========================================================================
+** Library functions.
+** ============================================================================
+*/
+
+static void
+p_header(Info *info) {
+  WRITE_RAW(kHeader, HEADER_LENGTH);
+  WRITE_VALUE(sizeof(lua_Number), uint8_t);
+  WRITE_VALUE(kHeaderNumber, lua_Number);
+  WRITE_VALUE(sizeof(int), uint8_t);
+  WRITE_VALUE(sizeof(size_t), uint8_t);
+}
+
+static void
+u_header(Info *info) {
+  char header[HEADER_LENGTH];
+  uint8_t number_size;
+  READ_RAW(header, HEADER_LENGTH);
+  if (strncmp(kHeader, header, HEADER_LENGTH)) {
+    luaL_error(info->L, "invalid data");
+  }
+  number_size = READ_VALUE(uint8_t);
+  if (number_size == 0) {
+    /* Old 64-bit versions of eris wrote '\0' and then three random bytes. */
+    /* We skip them here for backwards compatibility. */
+    char throw_away[3];
+    READ_RAW(throw_away, 3);
+
+    number_size = READ_VALUE(uint8_t);
+  }
+  if (number_size != sizeof(lua_Number)) {
+    luaL_error(info->L, "incompatible floating point type");
+  }
+  /* In this case we really do want floating point equality. */
+  if (READ_VALUE(lua_Number) != kHeaderNumber) {
+    luaL_error(info->L, "incompatible floating point representation");
+  }
+  info->u.upi.sizeof_int = READ_VALUE(uint8_t);
+  info->u.upi.sizeof_size_t = READ_VALUE(uint8_t);
+}
+
+static void
+unchecked_persist(lua_State *L, lua_Writer writer, void *ud) {
+  Info info;                                            /* perms buff rootobj */
+  info.L = L;
+  info.level = 0;
+  info.refcount = 0;
+  info.maxComplexity = kMaxComplexity;
+  info.passIOToPersist = kPassIOToPersist;
+  info.generatePath = kGeneratePath;
+  info.u.pi.writer = writer;
+  info.u.pi.ud = ud;
+  info.u.pi.metafield = kPersistKey;
+  info.u.pi.writeDebugInfo = kWriteDebugInformation;
+
+  eris_checkstack(L, 3);
+
+  if (get_setting(L, (void*)&kSettingMaxComplexity)) {
+                                                  /* perms buff rootobj value */
+    info.maxComplexity = lua_tounsigned(L, -1);
+    lua_pop(L, 1);                                      /* perms buff rootobj */
+  }
+  if (get_setting(L, (void*)&kSettingGeneratePath)) {
+                                                  /* perms buff rootobj value */
+    info.generatePath = lua_toboolean(L, -1);
+    lua_pop(L, 1);                                      /* perms buff rootobj */
+  }
+  if (get_setting(L, (void*)&kSettingPassIOToPersist)) {
+                                                  /* perms buff rootobj value */
+    info.passIOToPersist = lua_toboolean(L, -1);
+    lua_pop(L, 1);                                      /* perms buff rootobj */
+  }
+  if (get_setting(L, (void*)&kSettingMetafield)) {/* perms buff rootobj value */
+    info.u.pi.metafield = lua_tostring(L, -1);
+    lua_pop(L, 1);                                      /* perms buff rootobj */
+  }
+  if (get_setting(L, (void*)&kSettingWriteDebugInfo)) {
+                                                  /* perms buff rootobj value */
+    info.u.pi.writeDebugInfo = lua_toboolean(L, -1);
+    lua_pop(L, 1);                                      /* perms buff rootobj */
+  }
+
+  lua_newtable(L);                               /* perms buff rootobj reftbl */
+  lua_insert(L, REFTIDX);                        /* perms reftbl buff rootobj */
+  if (info.generatePath) {
+    lua_newtable(L);                        /* perms reftbl buff rootobj path */
+    lua_insert(L, PATHIDX);                 /* perms reftbl buff path rootobj */
+    pushpath(&info, "root");
+  }
+
+  /* Populate perms table with Lua internals. */
+  lua_pushvalue(L, PERMIDX);         /* perms reftbl buff path? rootobj perms */
+  populateperms(L, false);
+  lua_pop(L, 1);                           /* perms reftbl buff path? rootobj */
+
+  p_header(&info);
+  persist(&info);                          /* perms reftbl buff path? rootobj */
+
+  if (info.generatePath) {                  /* perms reftbl buff path rootobj */
+    lua_remove(L, PATHIDX);                      /* perms reftbl buff rootobj */
+  }                                              /* perms reftbl buff rootobj */
+  lua_remove(L, REFTIDX);                               /* perms buff rootobj */
+}
+
+static void
+unchecked_unpersist(lua_State *L, lua_Reader reader, void *ud) {/* perms str? */
+  Info info;
+  info.L = L;
+  info.level = 0;
+  info.refcount = 0;
+  info.maxComplexity = kMaxComplexity;
+  info.generatePath = kGeneratePath;
+  info.passIOToPersist = kPassIOToPersist;
+  eris_init(L, &info.u.upi.zio, reader, ud);
+
+  eris_checkstack(L, 3);
+
+  if (get_setting(L, (void*)&kSettingMaxComplexity)) {
+                                                  /* perms buff rootobj value */
+    info.maxComplexity = lua_tounsigned(L, -1);
+    lua_pop(L, 1);                                      /* perms buff rootobj */
+  }
+  if (get_setting(L, (void*)&kSettingGeneratePath)) {
+                                                 /* perms buff? rootobj value */
+    info.generatePath = lua_toboolean(L, -1);
+    lua_pop(L, 1);                                     /* perms buff? rootobj */
+  }
+  if (get_setting(L, (void*)&kSettingPassIOToPersist)) {  /* perms str? value */
+    info.passIOToPersist = lua_toboolean(L, -1);
+    lua_pop(L, 1);                                              /* perms str? */
+  }
+
+  lua_newtable(L);                                       /* perms str? reftbl */
+  lua_insert(L, REFTIDX);                                /* perms reftbl str? */
+  if (info.generatePath) {
+    /* Make sure the path is always at index 4, so that it's the same for
+     * persist and unpersist. */
+    lua_pushnil(L);                                  /* perms reftbl str? nil */
+    lua_insert(L, BUFFIDX);                          /* perms reftbl nil str? */
+    lua_newtable(L);                            /* perms reftbl nil str? path */
+    lua_insert(L, PATHIDX);                     /* perms reftbl nil path str? */
+    pushpath(&info, "root");
+  }
+
+  /* Populate perms table with Lua internals. */
+  lua_pushvalue(L, PERMIDX);            /* perms reftbl nil? path? str? perms */
+  populateperms(L, true);
+  lua_pop(L, 1);                              /* perms reftbl nil? path? str? */
+
+  u_header(&info);
+  unpersist(&info);                   /* perms reftbl nil? path? str? rootobj */
+  if (info.generatePath) {              /* perms reftbl nil path str? rootobj */
+    lua_remove(L, PATHIDX);                  /* perms reftbl nil str? rootobj */
+    lua_remove(L, BUFFIDX);                      /* perms reftbl str? rootobj */
+  }                                              /* perms reftbl str? rootobj */
+  lua_remove(L, REFTIDX);                               /* perms str? rootobj */
+}
+
+/** ======================================================================== */
+
+static int
+l_persist(lua_State *L) {                             /* perms? rootobj? ...? */
+  Mbuffer buff;
+
+  /* See if we have anything at all. */
+  luaL_checkany(L, 1);
+
+  /* If we only have one object we assume it is the root object and that there
+   * is no perms table, so we create an empty one for internal use. */
+  if (lua_gettop(L) == 1) {                                        /* rootobj */
+    eris_checkstack(L, 1);
+    lua_newtable(L);                                         /* rootobj perms */
+    lua_insert(L, PERMIDX);                                  /* perms rootobj */
+  }
+  else {
+    luaL_checktype(L, 1, LUA_TTABLE);                  /* perms rootobj? ...? */
+    luaL_checkany(L, 2);                                /* perms rootobj ...? */
+    lua_settop(L, 2);                                        /* perms rootobj */
+  }
+  eris_checkstack(L, 1);
+  lua_pushnil(L);                                       /* perms rootobj buff */
+  lua_insert(L, 2);                                     /* perms buff rootobj */
+
+  eris_initbuffer(L, &buff);
+  eris_bufflen(&buff) = 0; /* Not initialized by initbuffer... */
+
+  unchecked_persist(L, writer, &buff);                  /* perms buff rootobj */
+
+  /* Copy the buffer as the result string before removing it, to avoid the data
+   * being garbage collected. */
+  lua_pushlstring(L, eris_buffer(&buff), eris_bufflen(&buff));
+                                                    /* perms buff rootobj str */
+
+  return 1;
+}
+
+static int
+l_unpersist(lua_State *L) {                               /* perms? str? ...? */
+  RBuffer buff;
+
+  /* See if we have anything at all. */
+  luaL_checkany(L, 1);
+
+  /* If we only have one object we assume it is the root object and that there
+   * is no perms table, so we create an empty one for internal use. */
+  if (lua_gettop(L) == 1) {                                           /* str? */
+    eris_checkstack(L, 1);
+    lua_newtable(L);                                            /* str? perms */
+    lua_insert(L, PERMIDX);                                     /* perms str? */
+  }
+  else {
+    luaL_checktype(L, 1, LUA_TTABLE);                      /* perms str? ...? */
+  }
+  eris_buffer(&buff) = luaL_checklstring(L, 2, &eris_bufflen(&buff));
+  eris_sizebuffer(&buff) = eris_bufflen(&buff);             /* perms str ...? */
+  lua_settop(L, 2);                                              /* perms str */
+
+  unchecked_unpersist(L, reader, &buff);                 /* perms str rootobj */
+
+  return 1;
+}
+
+#define IS(s) strncmp(s, name, length < sizeof(s) ? length : sizeof(s)) == 0
+
+static int
+l_settings(lua_State *L) {                                /* name value? ...? */
+  size_t length;
+  const char *name = luaL_checklstring(L, 1, &length);
+  if (lua_isnone(L, 2)) {                                        /* name ...? */
+    lua_settop(L, 1);                                                 /* name */
+    /* Get the current setting value and return it. */
+    if (IS(kSettingMetafield)) {
+      if (!get_setting(L, (void*)&kSettingMetafield)) {
+        lua_pushstring(L, kPersistKey);
+      }
+    }
+    else if (IS(kSettingPassIOToPersist)) {
+      if (!get_setting(L, (void*)&kSettingPassIOToPersist)) {
+        lua_pushboolean(L, kPassIOToPersist);
+      }
+    }
+    else if (IS(kSettingWriteDebugInfo)) {
+      if (!get_setting(L, (void*)&kSettingWriteDebugInfo)) {
+        lua_pushboolean(L, kWriteDebugInformation);
+      }
+    }
+    else if (IS(kSettingGeneratePath)) {
+      if (!get_setting(L, (void*)&kSettingGeneratePath)) {
+        lua_pushboolean(L, kGeneratePath);
+      }
+    }
+    else if (IS(kSettingMaxComplexity)) {
+      if (!get_setting(L, (void*)&kSettingMaxComplexity)) {
+        lua_pushunsigned(L, kMaxComplexity);
+      }
+    }
+    else {
+      return luaL_argerror(L, 1, "no such setting");
+    }                                                           /* name value */
+    return 1;
+  }
+  else {                                                   /* name value ...? */
+    lua_settop(L, 2);                                           /* name value */
+    /* Set a new value for the setting. */
+    if (IS(kSettingMetafield)) {
+      luaL_optstring(L, 2, NULL);
+      set_setting(L, (void*)&kSettingMetafield);
+    }
+    else if (IS(kSettingPassIOToPersist)) {
+      luaL_opt(L, checkboolean, 2, false);
+      set_setting(L, (void*)&kSettingPassIOToPersist);
+    }
+    else if (IS(kSettingWriteDebugInfo)) {
+      luaL_opt(L, checkboolean, 2, false);
+      set_setting(L, (void*)&kSettingWriteDebugInfo);
+    }
+    else if (IS(kSettingGeneratePath)) {
+      luaL_opt(L, checkboolean, 2, false);
+      set_setting(L, (void*)&kSettingGeneratePath);
+    }
+    else if (IS(kSettingMaxComplexity)) {
+      luaL_optunsigned(L, 2, 0);
+      set_setting(L, (void*)&kSettingMaxComplexity);
+    }
+    else {
+      return luaL_argerror(L, 1, "no such setting");
+    }                                                                 /* name */
+    return 0;
+  }
+}
+
+#undef IS
+
+/** ======================================================================== */
+
+static luaL_Reg erislib[] = {
+  { "persist", l_persist },
+  { "unpersist", l_unpersist },
+  { "settings", l_settings },
+  { NULL, NULL }
+};
+
+LUA_API int luaopen_eris(lua_State *L) {
+  luaL_newlib(L, erislib);
+  return 1;
+}
+
+/* }======================================================================== */
+
+/*
+** {===========================================================================
+** Public API functions.
+** ============================================================================
+*/
+
+LUA_API void
+eris_dump(lua_State *L, lua_Writer writer, void *ud) {     /* perms? rootobj? */
+  if (lua_gettop(L) > 2) {
+    luaL_error(L, "too many arguments");
+  }
+  luaL_checktype(L, 1, LUA_TTABLE);                         /* perms rootobj? */
+  luaL_checkany(L, 2);                                       /* perms rootobj */
+  lua_pushnil(L);                                        /* perms rootobj nil */
+  lua_insert(L, -2);                                     /* perms nil rootobj */
+  unchecked_persist(L, writer, ud);                      /* perms nil rootobj */
+  lua_remove(L, -2);                                         /* perms rootobj */
+}
+
+LUA_API void
+eris_undump(lua_State *L, lua_Reader reader, void *ud) {            /* perms? */
+  if (lua_gettop(L) > 1) {
+    luaL_error(L, "too many arguments");
+  }
+  luaL_checktype(L, 1, LUA_TTABLE);                                  /* perms */
+  unchecked_unpersist(L, reader, ud);                        /* perms rootobj */
+}
+
+/** ======================================================================== */
+
+LUA_API void
+eris_persist(lua_State *L, int perms, int value) {                    /* ...? */
+  eris_checkstack(L, 3);
+  lua_pushcfunction(L, l_persist);                           /* ... l_persist */
+  lua_pushvalue(L, perms);                             /* ... l_persist perms */
+  lua_pushvalue(L, value);                     /* ... l_persist perms rootobj */
+  lua_call(L, 2, 1);                                               /* ... str */
+}
+
+LUA_API void
+eris_unpersist(lua_State *L, int perms, int value) {                   /* ... */
+  eris_checkstack(L, 3);
+  lua_pushcfunction(L, l_unpersist);                       /* ... l_unpersist */
+  lua_pushvalue(L, perms);                           /* ... l_unpersist perms */
+  lua_pushvalue(L, value);                       /* ... l_unpersist perms str */
+  lua_call(L, 2, 1);                                           /* ... rootobj */
+}
+
+LUA_API void
+eris_get_setting(lua_State *L, const char *name) {                     /* ... */
+  eris_checkstack(L, 2);
+  lua_pushcfunction(L, l_settings);                         /* ... l_settings */
+  lua_pushstring(L, name);                             /* ... l_settings name */
+  lua_call(L, 1, 1);                                             /* ... value */
+}
+
+LUA_API void
+eris_set_setting(lua_State *L, const char *name, int value) {          /* ... */
+  eris_checkstack(L, 3);
+  lua_pushcfunction(L, l_settings);                         /* ... l_settings */
+  lua_pushstring(L, name);                             /* ... l_settings name */
+  lua_pushvalue(L, value);                       /* ... l_settings name value */
+  lua_call(L, 2, 0);                                                   /* ... */
+}
+
+/* }======================================================================== */
+

=== added file 'src/scripting/eris/eris.h'
--- src/scripting/eris/eris.h	1970-01-01 00:00:00 +0000
+++ src/scripting/eris/eris.h	2014-02-22 14:58:17 +0000
@@ -0,0 +1,148 @@
+/*
+Eris - Heavy-duty persistence for Lua 5.2.2 - Based on Pluto
+Copyright (c) 2013 by Florian Nuecke.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+/* lua.h must be included before this file */
+
+#ifndef ERIS_H
+#define ERIS_H
+
+/*
+** ==================================================================
+** API
+** ==================================================================
+*/
+
+/**
+ * This provides an interface to Eris' persist functionality for writing in
+ * an arbitrary way, using a writer.
+ *
+ * When called, the stack in 'L' must look like this:
+ * 1: perms:table
+ * 2: value:any
+ *
+ * 'writer' is the writer function used to store all data, 'ud' is passed to
+ * the writer function whenever it is called.
+ *
+ * [-0, +0, e]
+ */
+LUA_API void eris_dump(lua_State* L, lua_Writer writer, void* ud);
+
+/**
+ * This provides an interface to Eris' unpersist functionality for reading
+ * in an arbitrary way, using a reader.
+ *
+ * When called, the stack in 'L' must look like this:
+ * 1: perms:table
+ *
+ * 'reader' is the reader function used to read all data, 'ud' is passed to
+ * the reader function whenever it is called.
+ *
+ * The result of the operation will be pushed onto the stack.
+ *
+ * [-0, +1, e]
+ */
+LUA_API void eris_undump(lua_State* L, lua_Reader reader, void* ud);
+
+/**
+ * This is a stack-based alternative to eris_dump.
+ *
+ * It expects the perms table at the specified index 'perms' and the value to
+ * persist at the specified index 'value'. It will push the resulting string
+ * onto the stack on success.
+ *
+ * [-0, +1, e]
+ */
+LUA_API void eris_persist(lua_State* L, int perms, int value);
+
+/**
+ * This is a stack-based alternative to eris_undump.
+ *
+ * It expects the perms table at the specified index 'perms' and the string
+ * containing persisted data at the specified index 'value'. It will push the
+ * resulting value onto the stack on success.
+ *
+ * [-0, +1, e]
+ */
+LUA_API void eris_unpersist(lua_State* L, int perms, int value);
+
+/**
+ * Pushes the current value of a setting onto the stack.
+ *
+ * The name is the name of the setting to get the value for:
+ * - 'debug'  whether to write debug information when persisting function
+ *            prototypes (line numbers, local variable names, upvalue names).
+ * - 'maxrec' the maximum complexity of objects we support (the nesting level
+ *            of tables, for example). This can be useful to avoid segmentation
+ *            faults due to too deep recursion when working with user-provided
+ *            data.
+ * - 'path'   whether to generate a "path" used to indicate where in an object
+ *            an error occurred. This adds considerable overhead and should
+ *            only be used to debug errors as they appear.
+ * - 'spio'   whether to pass IO objects along as light userdata to special
+ *            persistence functions. When persisting this will pass along the
+ *            lua_Writer and its void* in addition to the original object, when
+ *            unpersisting it will pass along a ZIO*.
+ * - 'spkey'  the name of the field in the metatable of tables and userdata
+ *            used to control persistence (on/off or special persistence).
+ *
+ * If an unknown name is specified this will throw an error.
+ *
+ * [-0, +1, e]
+ */
+LUA_API void eris_get_setting(lua_State *L, const char *name);
+
+/**
+ * Changes the value of a setting to a value on the stack.
+ *
+ * For the available settings see eris_set_setting(). This will get the new
+ * value from the specified stack index 'value'. If the type does not match
+ * this will throw an error. Specify a nil value to reset the setting to its
+ * default value.
+ *
+ * [-0, +0, e]
+ */
+LUA_API void eris_set_setting(lua_State *L, const char *name, int value);
+
+/*
+** ==================================================================
+** Library installer
+** ==================================================================
+*/
+
+/**
+ * This pushes a table with the two functions 'persist' and 'unpersist':
+ *   persist([perms,] value)
+ *     Where 'perms' is a table with "permanent" objects and 'value' is the
+ *     value that should be persisted. Returns the string with persisted data.
+ *     If only one value is given, the perms table is assumed to be empty.
+ *
+ *   unpersist([perms,] value)
+ *     Where 'perms' is a table with the inverse mapping as used when
+ *     persisting the data via persist() and 'value' is the string with the
+ *     persisted data returned by persist(). Returns the unpersisted value.
+ *     If only one value is given, the perms table is assumed to be empty.
+ */
+LUA_API int luaopen_eris(lua_State* L);
+
+#endif
+

=== added file 'src/scripting/eris/lapi.c'
--- src/scripting/eris/lapi.c	1970-01-01 00:00:00 +0000
+++ src/scripting/eris/lapi.c	2014-02-22 14:58:17 +0000
@@ -0,0 +1,1284 @@
+/*
+** $Id: lapi.c,v 2.171.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lua API
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdarg.h>
+#include <string.h>
+
+#define lapi_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lapi.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lundump.h"
+#include "lvm.h"
+
+
+
+const char lua_ident[] =
+  "$LuaVersion: " LUA_COPYRIGHT " $"
+  "$LuaAuthors: " LUA_AUTHORS " $";
+
+
+/* value at a non-valid index */
+#define NONVALIDVALUE		cast(TValue *, luaO_nilobject)
+
+/* corresponding test */
+#define isvalid(o)	((o) != luaO_nilobject)
+
+/* test for pseudo index */
+#define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)
+
+/* test for valid but not pseudo index */
+#define isstackindex(i, o)	(isvalid(o) && !ispseudo(i))
+
+#define api_checkvalidindex(L, o)  api_check(L, isvalid(o), "invalid index")
+
+#define api_checkstackindex(L, i, o)  \
+	api_check(L, isstackindex(i, o), "index not in the stack")
+
+
+static TValue *index2addr (lua_State *L, int idx) {
+  CallInfo *ci = L->ci;
+  if (idx > 0) {
+    TValue *o = ci->func + idx;
+    api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
+    if (o >= L->top) return NONVALIDVALUE;
+    else return o;
+  }
+  else if (!ispseudo(idx)) {  /* negative index */
+    api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
+    return L->top + idx;
+  }
+  else if (idx == LUA_REGISTRYINDEX)
+    return &G(L)->l_registry;
+  else {  /* upvalues */
+    idx = LUA_REGISTRYINDEX - idx;
+    api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");
+    if (ttislcf(ci->func))  /* light C function? */
+      return NONVALIDVALUE;  /* it has no upvalues */
+    else {
+      CClosure *func = clCvalue(ci->func);
+      return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : NONVALIDVALUE;
+    }
+  }
+}
+
+
+/*
+** to be called by 'lua_checkstack' in protected mode, to grow stack
+** capturing memory errors
+*/
+static void growstack (lua_State *L, void *ud) {
+  int size = *(int *)ud;
+  luaD_growstack(L, size);
+}
+
+
+LUA_API int lua_checkstack (lua_State *L, int size) {
+  int res;
+  CallInfo *ci = L->ci;
+  lua_lock(L);
+  if (L->stack_last - L->top > size)  /* stack large enough? */
+    res = 1;  /* yes; check is OK */
+  else {  /* no; need to grow stack */
+    int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;
+    if (inuse > LUAI_MAXSTACK - size)  /* can grow without overflow? */
+      res = 0;  /* no */
+    else  /* try to grow stack */
+      res = (luaD_rawrunprotected(L, &growstack, &size) == LUA_OK);
+  }
+  if (res && ci->top < L->top + size)
+    ci->top = L->top + size;  /* adjust frame top */
+  lua_unlock(L);
+  return res;
+}
+
+
+LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
+  int i;
+  if (from == to) return;
+  lua_lock(to);
+  api_checknelems(from, n);
+  api_check(from, G(from) == G(to), "moving among independent states");
+  api_check(from, to->ci->top - to->top >= n, "not enough elements to move");
+  from->top -= n;
+  for (i = 0; i < n; i++) {
+    setobj2s(to, to->top++, from->top + i);
+  }
+  lua_unlock(to);
+}
+
+
+LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
+  lua_CFunction old;
+  lua_lock(L);
+  old = G(L)->panic;
+  G(L)->panic = panicf;
+  lua_unlock(L);
+  return old;
+}
+
+
+LUA_API const lua_Number *lua_version (lua_State *L) {
+  static const lua_Number version = LUA_VERSION_NUM;
+  if (L == NULL) return &version;
+  else return G(L)->version;
+}
+
+
+
+/*
+** basic stack manipulation
+*/
+
+
+/*
+** convert an acceptable stack index into an absolute index
+*/
+LUA_API int lua_absindex (lua_State *L, int idx) {
+  return (idx > 0 || ispseudo(idx))
+         ? idx
+         : cast_int(L->top - L->ci->func + idx);
+}
+
+
+LUA_API int lua_gettop (lua_State *L) {
+  return cast_int(L->top - (L->ci->func + 1));
+}
+
+
+LUA_API void lua_settop (lua_State *L, int idx) {
+  StkId func = L->ci->func;
+  lua_lock(L);
+  if (idx >= 0) {
+    api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
+    while (L->top < (func + 1) + idx)
+      setnilvalue(L->top++);
+    L->top = (func + 1) + idx;
+  }
+  else {
+    api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");
+    L->top += idx+1;  /* `subtract' index (index is negative) */
+  }
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_remove (lua_State *L, int idx) {
+  StkId p;
+  lua_lock(L);
+  p = index2addr(L, idx);
+  api_checkstackindex(L, idx, p);
+  while (++p < L->top) setobjs2s(L, p-1, p);
+  L->top--;
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_insert (lua_State *L, int idx) {
+  StkId p;
+  StkId q;
+  lua_lock(L);
+  p = index2addr(L, idx);
+  api_checkstackindex(L, idx, p);
+  for (q = L->top; q > p; q--)  /* use L->top as a temporary */
+    setobjs2s(L, q, q - 1);
+  setobjs2s(L, p, L->top);
+  lua_unlock(L);
+}
+
+
+static void moveto (lua_State *L, TValue *fr, int idx) {
+  TValue *to = index2addr(L, idx);
+  api_checkvalidindex(L, to);
+  setobj(L, to, fr);
+  if (idx < LUA_REGISTRYINDEX)  /* function upvalue? */
+    luaC_barrier(L, clCvalue(L->ci->func), fr);
+  /* LUA_REGISTRYINDEX does not need gc barrier
+     (collector revisits it before finishing collection) */
+}
+
+
+LUA_API void lua_replace (lua_State *L, int idx) {
+  lua_lock(L);
+  api_checknelems(L, 1);
+  moveto(L, L->top - 1, idx);
+  L->top--;
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
+  TValue *fr;
+  lua_lock(L);
+  fr = index2addr(L, fromidx);
+  moveto(L, fr, toidx);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushvalue (lua_State *L, int idx) {
+  lua_lock(L);
+  setobj2s(L, L->top, index2addr(L, idx));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+
+/*
+** access functions (stack -> C)
+*/
+
+
+LUA_API int lua_type (lua_State *L, int idx) {
+  StkId o = index2addr(L, idx);
+  return (isvalid(o) ? ttypenv(o) : LUA_TNONE);
+}
+
+
+LUA_API const char *lua_typename (lua_State *L, int t) {
+  UNUSED(L);
+  return ttypename(t);
+}
+
+
+LUA_API int lua_iscfunction (lua_State *L, int idx) {
+  StkId o = index2addr(L, idx);
+  return (ttislcf(o) || (ttisCclosure(o)));
+}
+
+
+LUA_API int lua_isnumber (lua_State *L, int idx) {
+  TValue n;
+  const TValue *o = index2addr(L, idx);
+  return tonumber(o, &n);
+}
+
+
+LUA_API int lua_isstring (lua_State *L, int idx) {
+  int t = lua_type(L, idx);
+  return (t == LUA_TSTRING || t == LUA_TNUMBER);
+}
+
+
+LUA_API int lua_isuserdata (lua_State *L, int idx) {
+  const TValue *o = index2addr(L, idx);
+  return (ttisuserdata(o) || ttislightuserdata(o));
+}
+
+
+LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
+  StkId o1 = index2addr(L, index1);
+  StkId o2 = index2addr(L, index2);
+  return (isvalid(o1) && isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0;
+}
+
+
+LUA_API void lua_arith (lua_State *L, int op) {
+  StkId o1;  /* 1st operand */
+  StkId o2;  /* 2nd operand */
+  lua_lock(L);
+  if (op != LUA_OPUNM) /* all other operations expect two operands */
+    api_checknelems(L, 2);
+  else {  /* for unary minus, add fake 2nd operand */
+    api_checknelems(L, 1);
+    setobjs2s(L, L->top, L->top - 1);
+    L->top++;
+  }
+  o1 = L->top - 2;
+  o2 = L->top - 1;
+  if (ttisnumber(o1) && ttisnumber(o2)) {
+    setnvalue(o1, luaO_arith(op, nvalue(o1), nvalue(o2)));
+  }
+  else
+    luaV_arith(L, o1, o1, o2, cast(TMS, op - LUA_OPADD + TM_ADD));
+  L->top--;
+  lua_unlock(L);
+}
+
+
+LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {
+  StkId o1, o2;
+  int i = 0;
+  lua_lock(L);  /* may call tag method */
+  o1 = index2addr(L, index1);
+  o2 = index2addr(L, index2);
+  if (isvalid(o1) && isvalid(o2)) {
+    switch (op) {
+      case LUA_OPEQ: i = equalobj(L, o1, o2); break;
+      case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
+      case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
+      default: api_check(L, 0, "invalid option");
+    }
+  }
+  lua_unlock(L);
+  return i;
+}
+
+
+LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *isnum) {
+  TValue n;
+  const TValue *o = index2addr(L, idx);
+  if (tonumber(o, &n)) {
+    if (isnum) *isnum = 1;
+    return nvalue(o);
+  }
+  else {
+    if (isnum) *isnum = 0;
+    return 0;
+  }
+}
+
+
+LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *isnum) {
+  TValue n;
+  const TValue *o = index2addr(L, idx);
+  if (tonumber(o, &n)) {
+    lua_Integer res;
+    lua_Number num = nvalue(o);
+    lua_number2integer(res, num);
+    if (isnum) *isnum = 1;
+    return res;
+  }
+  else {
+    if (isnum) *isnum = 0;
+    return 0;
+  }
+}
+
+
+LUA_API lua_Unsigned lua_tounsignedx (lua_State *L, int idx, int *isnum) {
+  TValue n;
+  const TValue *o = index2addr(L, idx);
+  if (tonumber(o, &n)) {
+    lua_Unsigned res;
+    lua_Number num = nvalue(o);
+    lua_number2unsigned(res, num);
+    if (isnum) *isnum = 1;
+    return res;
+  }
+  else {
+    if (isnum) *isnum = 0;
+    return 0;
+  }
+}
+
+
+LUA_API int lua_toboolean (lua_State *L, int idx) {
+  const TValue *o = index2addr(L, idx);
+  return !l_isfalse(o);
+}
+
+
+LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
+  StkId o = index2addr(L, idx);
+  if (!ttisstring(o)) {
+    lua_lock(L);  /* `luaV_tostring' may create a new string */
+    if (!luaV_tostring(L, o)) {  /* conversion failed? */
+      if (len != NULL) *len = 0;
+      lua_unlock(L);
+      return NULL;
+    }
+    luaC_checkGC(L);
+    o = index2addr(L, idx);  /* previous call may reallocate the stack */
+    lua_unlock(L);
+  }
+  if (len != NULL) *len = tsvalue(o)->len;
+  return svalue(o);
+}
+
+
+LUA_API size_t lua_rawlen (lua_State *L, int idx) {
+  StkId o = index2addr(L, idx);
+  switch (ttypenv(o)) {
+    case LUA_TSTRING: return tsvalue(o)->len;
+    case LUA_TUSERDATA: return uvalue(o)->len;
+    case LUA_TTABLE: return luaH_getn(hvalue(o));
+    default: return 0;
+  }
+}
+
+
+LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
+  StkId o = index2addr(L, idx);
+  if (ttislcf(o)) return fvalue(o);
+  else if (ttisCclosure(o))
+    return clCvalue(o)->f;
+  else return NULL;  /* not a C function */
+}
+
+
+LUA_API void *lua_touserdata (lua_State *L, int idx) {
+  StkId o = index2addr(L, idx);
+  switch (ttypenv(o)) {
+    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
+    case LUA_TLIGHTUSERDATA: return pvalue(o);
+    default: return NULL;
+  }
+}
+
+