Merge lp:~widelands-dev/widelands/bug-1543001-eris into lp:widelands

[GunChleoc]

Updated Eris to version 1.1.0.

I just dumped the files and updated the readme. As long as we don't change to a newer Lua version, savegames should be compatible. I did a quick test with my long Trident of Fire savegame, and it loaded with no issues.

[Miroslav Remák (miroslavr256)]

We're going to break savegame compatibility for this release anyway. What's holding us from updating to Lua 5.3 eris?

[GunChleoc (gunchleoc)]

The highest Lua version available on my system is 5.2. Ubuntu introduced Lua with version 15.04, but I usually only use long term releases, which means that I will have to wait until 16.04 comes out in order to switch to Lua 5.3.

[SirVer (sirver)]

I think Eris is lua 5.3 - Eris bundles all of lua with it since it needs the private headers for serialization. So by updating Eris, we switch to lua 5.3.

This is from my memory. I cannot check right now, but it should be documented on the GitHub project page or the commit history of Eris.

> Am 08.04.2016 um 07:54 schrieb GunChleoc <email address hidden>:
>
> The highest Lua version available on my system is 5.2. Ubuntu introduced Lua with version 15.04, but I usually only use long term releases, which means that I will have to wait until 16.04 comes out in order to switch to Lua 5.3.
> --
> https://code.launchpad.net/~widelands-dev/widelands/bug-1543001-eris/+merge/291294
> Your team Widelands Developers is requested to review the proposed merge of lp:~widelands-dev/widelands/bug-1543001-eris into lp:widelands.
>
> _______________________________________________
> Mailing list: https://launchpad.net/~widelands-dev
> Post to : <email address hidden>
> Unsubscribe : https://launchpad.net/~widelands-dev
> More help : https://help.launchpad.net/ListHelp

[Miroslav Remák (miroslavr256)]

SirVer is correct. Here's an explanation:
https://github.com/fnuecke/eris/tree/master-lua5.3#core-library

You don't need to have Lua installed on your system at all.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 984. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/121502471.
Appveyor build 817. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_bug_1543001_eris-817.

[Klaus Halfmann (klaus-halfmann)]

On OSX (with macports) I have 'lua @5.3.1_2 (lang)'. hope this helps

[GunChleoc (gunchleoc)]

OK, I'll try the Lua 5.3 version then to see if it will run on my system :)

[GunChleoc (gunchleoc)]

Seems to be working - I could even load some savegames, so I haven't upgraded any packet numbers.

[Miroslav Remák (miroslavr256)]

Tutorials and campaigns seem to be crashing:

Error in Lua Coroutine
[/home/miroslavr/Games/widelands/src/scripting/lua_errors.cc:22] [string "scripting/ui.lua"]:102: bad argument #-1 to '__newindex' (number has no integer representation)
Send message to all players and pause gameFatal exception: [/home/miroslavr/Games/widelands/src/graphic/image_io.h:35] Image not found: Coroutine
Game: Writing Preload Data ... The program has unexpectedly finished.
/home/miroslavr/Games/widelands/build/src/widelands crashed

[Miroslav Remák (miroslavr256)]

Besides the obvious error in Lua coroutine, there seems to be another issue with the message that is supposed to show up, which ultimately leads to a crash. This message (in CmdLuaCoroutine::execute) is constructed with icon and title parameters swapped.

[Miroslav Remák (miroslavr256)]

Regarding the "number has no integer representation" error: Since Lua 5.3 added integer support, luaL_checkinteger does not seem to accept floating-point numbers anymore. We need to make sure to pass integers from Lua where required.

These changes seem to do the trick:

=== modified file 'data/scripting/ui.lua'
--- data/scripting/ui.lua 2016-01-28 05:24:34 +0000
+++ data/scripting/ui.lua 2016-04-09 01:25:31 +0000
@@ -99,8 +99,8 @@
    wl.Game().desired_speed = 1000

    for idx,p in ipairs(points) do
- mv.viewpoint_x = p.x
- mv.viewpoint_y = p.y
+ mv.viewpoint_x = math.floor(p.x)
+ mv.viewpoint_y = math.floor(p.y)

       sleep(dt)
    end
@@ -196,8 +196,8 @@
    wl.Game().desired_speed = 1000

    for idx,p in ipairs(points) do
- mv.mouse_position_x = p.x
- mv.mouse_position_y = p.y
+ mv.mouse_position_x = math.floor(p.x)
+ mv.mouse_position_y = math.floor(p.y)

       sleep(dt)
    end

[GunChleoc (gunchleoc)]

I can't reproduce the crash. Where were you exactly when it happened? What is your screen resolution?

[Miroslav Remák (miroslavr256)]

My in-game resolution is 1024x768, 60 fps. It happens anytime the view or mouse pointer moves automatically (see diff). For example, the first tutorial mission errors just after activating build spaces.

Can you try running 'wl.ui.MapView().viewpoint_x = 2.5' via the script console to see if you can reproduce it at all?

[Miroslav Remák (miroslavr256)]

Also, what does 'print(_VERSION)' output on your end? It should be 'Lua+Eris 5.3'.

[kaputtnik (franku)]

I just get a crash in Economy tutorial. The crash happens after clicking the "OK" button of first text screen:

Error in Lua Coroutine
[/home/kaputtnik/Quellcode/widelands-repo/bug-1543001-eris/src/scripting/lua_errors.cc:22] [string "scripting/ui.lua"]:102: bad argument #-1 to '__newindex' (number has no integer representation)
Send message to all players and pause gameFatal exception: [/home/kaputtnik/Quellcode/widelands-repo/bug-1543001-eris/src/graphic/image_io.h:35] Image not found: Coroutine
Game: Writing Preload Data ... Speicherzugriffsfehler (Speicherabzug geschrieben

The same crash happens when playing the warefare tutorial after the Citadel has been build.

[kaputtnik (franku)]

Another crash with a savegame saved with current trunk:

Reading Scripting Data ... PANIC: unprotected error in call to Lua API (incompatible integer type)

I attach the savegame to the bug.

[Miroslav Remák (miroslavr256)]

@kaputtnik: You won't be able to load older savegames because the save format of Eris is not compatible. I'm not sure if we can catch the error and display a message box instead of aborting, though.

[kaputtnik (franku)]

I just mentioned this because GunChleoc says:

> I could even load some savegames, so I haven't upgraded any packet numbers.

If the packet numbers are upgraded a message box is displayed automatically when trying to load an incompatible save game :-)

review: Needs Fixing

[Miroslav Remák (miroslavr256)]

Right, I see. We should definitely up the MapScriptingPacket version.

[SirVer (sirver)]

Theoretically, this should invalidate all savegames. Also non scenario ones. Since every game as a win condition (be it an empty one), all savegames contain Lua serialized coroutines. If they load it is by luck, there is no guarantee in Eris for compatibility. We should up the version for all savegames imho.

[GunChleoc (gunchleoc)]

> Also, what does 'print(_VERSION)' output on your end? It should be 'Lua+Eris
> 5.3'.

That was it. I had to delete the build directory to get the correct version. I can reproduce the crashes now.

I'll put this merge request on hold now, since there is obviously work to be done.

[GunChleoc (gunchleoc)]

This should be ready now :)

review: Needs Resubmitting

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 989. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/121769847.
Appveyor build 822. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_bug_1543001_eris-822.

[Miroslav Remák (miroslavr256)]

Can you also fix the issue I mentioned here: https://code.launchpad.net/~widelands-dev/widelands/bug-1543001-eris/+merge/291294/comments/746462

This is what lead to the crash in the first place...

[GunChleoc (gunchleoc)]

Sorry, I overlooked this one. Which message do you mean by "this message"? I played the first tutorial through without any crashes.

> Besides the obvious error in Lua coroutine, there seems to be another issue
> with the message that is supposed to show up, which ultimately leads to a
> crash. This message (in CmdLuaCoroutine::execute) is constructed with icon and
> title parameters swapped.

[Miroslav Remák (miroslavr256)]

When a coroutine errors, an in-game message is supposed to be sent to all of the players:
http://bazaar.launchpad.net/~widelands-dev/widelands/bug-1543001-eris/view/head:/src/logic/cmd_luacoroutine.cc#L51

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'bzr pull --overwrite' failed. Output:

ssh: Could not resolve hostname bazaar.launchpad.net: No address associated with hostname
ConnectionReset reading response for 'BzrDir.open_2.1', retrying
ssh: Could not resolve hostname bazaar.launchpad.net: No address associated with hostname
bzr: ERROR: Connection closed: Unexpected end of message. Please check connectivity and permissions, and report a bug if problems persist.
Using saved parent location: bzr+ssh://bazaar.launchpad.net/~widelands-dev/widelands/bug-1543001-eris/

[kaputtnik (franku)]

I have played some Tutorials and Campaigns, played a new game and also played with the editor.

Works fine i think :-)

review: Approve (testing)

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 993. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/122023836.
Appveyor build 826. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_bug_1543001_eris-826.

[GunChleoc (gunchleoc)]

This should now be fixed as well. It has been broken for ages.

> When a coroutine errors, an in-game message is supposed to be sent to all of
> the players:
> http://bazaar.launchpad.net/~widelands-
> dev/widelands/bug-1543001-eris/view/head:/src/logic/cmd_luacoroutine.cc#L51

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 994. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/122074637.
Appveyor build 827. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_bug_1543001_eris-827.

[Miroslav Remák (miroslavr256)]

LGTM.

review: Approve (code)

[GunChleoc (gunchleoc)]

Thanks!

@bunnybot merge

=== modified file 'src/logic/cmd_luacoroutine.cc'
--- src/logic/cmd_luacoroutine.cc	2016-02-15 23:26:42 +0000
+++ src/logic/cmd_luacoroutine.cc	2016-04-10 16:54:20 +0000
@@ -19,6 +19,8 @@
 
 #include "logic/cmd_luacoroutine.h"
 
+#include <boost/format.hpp>
+
 #include "base/log.h"
 #include "base/macros.h"
 #include "io/fileread.h"
@@ -52,10 +54,10 @@
 				*new Widelands::Message
 				(Message::Type::kGameLogic,
 				 game.get_gametime(),
+				 "Coroutine",
 				 "images/ui_basic/menu_help.png",
-				 "Coroutine",
 				 "Lua Coroutine Failed",
-				 e.what());
+				 (boost::format("<rt><p font-size=12>%s</p></rt>") % e.what()).str());
 			game.player(i).add_message(game, msg, true);
 		}
 		game.game_controller()->set_desired_speed(0);

=== modified file 'src/logic/map_objects/tribes/soldier.cc'
--- src/logic/map_objects/tribes/soldier.cc	2016-04-03 16:18:24 +0000
+++ src/logic/map_objects/tribes/soldier.cc	2016-04-10 16:54:20 +0000
@@ -1483,7 +1483,7 @@
 							 descr().descname(),
 							 "images/ui_basic/menu_help.png",
 							 _("Logic error"),
-							 messagetext,
+							 (boost::format("<rt><p font-size=12>%s</p></rt>") % messagetext).str(),
 						 	 get_position(),
 							 serial_));
 					opponent.owner().add_message
@@ -1494,7 +1494,7 @@
 							 descr().descname(),
 							 "images/ui_basic/menu_help.png",
 							 _("Logic error"),
-							 messagetext,
+							 (boost::format("<rt><p font-size=12>%s</p></rt>") % messagetext).str(),
 						 	 opponent.get_position(),
 							 serial_));
 					game.game_controller()->set_desired_speed(0);

=== modified file 'src/logic/map_objects/tribes/worker.cc'
--- src/logic/map_objects/tribes/worker.cc	2016-03-08 15:21:41 +0000
+++ src/logic/map_objects/tribes/worker.cc	2016-04-10 16:54:20 +0000
@@ -1844,7 +1844,7 @@
 				 _("Worker"),
 				 "images/ui_basic/menu_help.png",
 				 _("Worker got lost!"),
-				 message,
+				 (boost::format("<rt><p font-size=12>%s</p></rt>") % message).str(),
 				 get_position()),
 				 serial_);
 		set_location(nullptr);

=== modified file 'src/map_io/map_scripting_packet.cc'
--- src/map_io/map_scripting_packet.cc	2015-11-28 22:29:26 +0000
+++ src/map_io/map_scripting_packet.cc	2016-04-10 16:54:20 +0000
@@ -37,7 +37,7 @@
 namespace Widelands {
 
 namespace {
-constexpr uint32_t kCurrentPacketVersion = 2;
+constexpr uint32_t kCurrentPacketVersion = 3;
 }  // namespace
 /*
  * ========================================================================

=== modified file 'src/scripting/logic.cc'
--- src/scripting/logic.cc	2016-02-12 16:58:41 +0000
+++ src/scripting/logic.cc	2016-04-10 16:54:20 +0000
@@ -99,14 +99,14 @@
 	switch (lua_gettop(L)) { /* check number of arguments */
 		case 0:
 		{  /* no arguments */
-			lua_pushnumber(L, r);  /* Number between 0 and 1 */
+			lua_pushdouble(L, r);  /* Number between 0 and 1 */
 			break;
 		}
 		case 1:
 		{  /* only upper limit */
 			int32_t u = luaL_checkint32(L, 1);
 			luaL_argcheck(L, 1 <= u, 1, "interval is empty");
-			lua_pushnumber(L, floor(r * u) + 1);  /* int between 1 and `u' */
+			lua_pushuint32(L, floor(r * u) + 1);  /* int between 1 and `u' */
 			break;
 		}
 		case 2:
@@ -115,7 +115,7 @@
 			int32_t u = luaL_checkint32(L, 2);
 			luaL_argcheck(L, l <= u, 2, "interval is empty");
 			/* int between `l' and `u' */
-			lua_pushnumber(L, floor(r * (u - l + 1)) + l);
+			lua_pushint32(L, floor(r * (u - l + 1)) + l);
 			break;
 		}
 		default: return luaL_error(L, "wrong number of arguments");

=== modified file 'src/scripting/lua.h'
--- src/scripting/lua.h	2016-02-12 16:58:41 +0000
+++ src/scripting/lua.h	2016-04-10 16:54:20 +0000
@@ -26,9 +26,11 @@
 
 #define luaL_checkint32(L, n)  static_cast<int32_t>(luaL_checkinteger(L, (n)))
 #define luaL_checkuint32(L, n)  static_cast<uint32_t>(luaL_checkinteger(L, (n)))
+#define luaL_checkdouble(L, n)  static_cast<double>(luaL_checknumber(L, (n)))
 
 #define lua_pushint32(L, n) (lua_pushinteger(L, static_cast<int32_t>(n)))
 #define lua_pushuint32(L, n) (lua_pushinteger(L, static_cast<uint32_t>(n)))
+#define lua_pushdouble(L, n) (lua_pushnumber(L, static_cast<double>(n)))
 
 void lua_pushstring (lua_State * L, const std::string & s);
 

=== modified file 'src/scripting/lua_coroutine.cc'
--- src/scripting/lua_coroutine.cc	2016-03-21 08:06:33 +0000
+++ src/scripting/lua_coroutine.cc	2016-04-10 16:54:20 +0000
@@ -124,7 +124,7 @@
 	if (!nreturn_values_) {
 		return 0;
 	}
-	if (!lua_isnumber(lua_state_, -1)) {
+	if (!lua_isinteger(lua_state_, -1)) {
 		throw LuaError("pop_uint32(), but no integer on the stack.");
 	}
 	const uint32_t return_value = luaL_checkuint32(lua_state_, -1);
@@ -144,7 +144,7 @@
 	return result;
 }
 
-constexpr uint8_t kCoroutineDataPacketVersion = 3;
+constexpr uint8_t kCoroutineDataPacketVersion = 4;
 void LuaCoroutine::write(FileWrite& fw) {
 	fw.unsigned_8(kCoroutineDataPacketVersion);
 

=== modified file 'src/scripting/lua_globals.cc'
--- src/scripting/lua_globals.cc	2016-04-03 12:35:43 +0000
+++ src/scripting/lua_globals.cc	2016-04-10 16:54:20 +0000
@@ -80,13 +80,10 @@
 					break;
 
 				case LUA_TNUMBER:
-					{
-						const int d = lua_tointeger(L, i);
-						if (d == 0 && !lua_isnumber(L, 1)) {
-							fmt % d;
-						} else {
-							fmt % luaL_checknumber(L, i);
-						}
+					if (lua_isinteger(L, i)) {
+						fmt % luaL_checkint32(L, i);
+					} else {
+						fmt % luaL_checknumber(L, i);
 					}
 					break;
 

=== modified file 'src/scripting/lua_map.cc'
--- src/scripting/lua_map.cc	2016-04-05 07:51:48 +0000
+++ src/scripting/lua_map.cc	2016-04-10 16:54:20 +0000
@@ -98,11 +98,11 @@
 	lua_newtable(L);
 	int counter = 0;
 	for (const std::vector<std::string>& foodlist : table) {
-		lua_pushnumber(L, ++counter);
+		lua_pushuint32(L, ++counter);
 		lua_newtable(L);
 		int counter2 = 0;
 		for (const std::string& foodname : foodlist) {
-			lua_pushnumber(L, ++counter2);
+			lua_pushuint32(L, ++counter2);
 			lua_pushstring(L, foodname);
 			lua_settable(L, -3);
 		}
@@ -1506,8 +1506,8 @@
 /* RST
 	.. attribute:: returns the terrain affinity values for this immovable
 
-			(RO) a table containing numbers labeled as pickiness, preferred_fertility,
-				  preferred_humidity, and preferred_temperature,
+			(RO) a table containing numbers labeled as pickiness (double), preferred_fertility (double),
+				  preferred_humidity (double), and preferred_temperature (uint),
 				  or nil if the immovable has no terrain affinity.
 */
 int LuaImmovableDescription::get_terrain_affinity(lua_State * L) {
@@ -1515,16 +1515,16 @@
 		const TerrainAffinity& affinity = get()->terrain_affinity();
 		lua_newtable(L);
 		lua_pushstring(L, "pickiness");
-		lua_pushnumber(L, affinity.pickiness());
+		lua_pushdouble(L, affinity.pickiness());
 		lua_settable(L, -3);
 		lua_pushstring(L, "preferred_fertility");
-		lua_pushnumber(L, affinity.preferred_fertility());
+		lua_pushdouble(L, affinity.preferred_fertility());
 		lua_settable(L, -3);
 		lua_pushstring(L, "preferred_humidity");
-		lua_pushnumber(L, affinity.preferred_humidity());
+		lua_pushdouble(L, affinity.preferred_humidity());
 		lua_settable(L, -3);
 		lua_pushstring(L, "preferred_temperature");
-		lua_pushnumber(L, affinity.preferred_temperature());
+		lua_pushuint32(L, affinity.preferred_temperature());
 		lua_settable(L, -3);
 	} else {
 		lua_pushnil(L);
@@ -1620,7 +1620,7 @@
 	}
 	if (get()->has_terrain_affinity()) {
 		const TerrainDescription* terrain = (*get_user_class<LuaMaps::LuaTerrainDescription>(L, 2))->get();
-		lua_pushnumber(L, Widelands::probability_to_grow(get()->terrain_affinity(), *terrain));
+		lua_pushdouble(L, Widelands::probability_to_grow(get()->terrain_affinity(), *terrain));
 	} else {
 		lua_pushnil(L);
 	}
@@ -2062,11 +2062,11 @@
 		lua_newtable(L);
 		int counter = 0;
 		for (const auto& group: program.consumed_wares()) {
-			lua_pushnumber(L, ++counter);
+			lua_pushuint32(L, ++counter);
 			lua_newtable(L);
 			for (const DescriptionIndex& ware_index : group.first) {
 				lua_pushstring(L, get_egbase(L).tribes().get_ware_descr(ware_index)->name());
-				lua_pushnumber(L, group.second);
+				lua_pushuint32(L, group.second);
 				lua_settable(L, -3);
 			}
 			lua_settable(L, -3);
@@ -2380,7 +2380,7 @@
 	lua_newtable(L);
 	int counter = 0;
 	for (const std::string& weaponname : get()->get_weapons_attack()) {
-		lua_pushnumber(L, ++counter);
+		lua_pushuint32(L, ++counter);
 		lua_pushstring(L, weaponname);
 		lua_settable(L, -3);
 	}
@@ -2396,7 +2396,7 @@
 	lua_newtable(L);
 	int counter = 0;
 	for (const std::string& weaponname : get()->get_weapons_defense()) {
-		lua_pushnumber(L, ++counter);
+		lua_pushuint32(L, ++counter);
 		lua_pushstring(L, weaponname);
 		lua_settable(L, -3);
 	}
@@ -2412,7 +2412,7 @@
 	lua_newtable(L);
 	int counter = 0;
 	for (const std::string& weaponname : get()->get_weapons_evade()) {
-		lua_pushnumber(L, ++counter);
+		lua_pushuint32(L, ++counter);
 		lua_pushstring(L, weaponname);
 		lua_settable(L, -3);
 	}
@@ -2428,7 +2428,7 @@
 	lua_newtable(L);
 	int counter = 0;
 	for (const std::string& weaponname : get()->get_weapons_health()) {
-		lua_pushnumber(L, ++counter);
+		lua_pushuint32(L, ++counter);
 		lua_pushstring(L, weaponname);
 		lua_settable(L, -3);
 	}
@@ -3128,7 +3128,7 @@
 */
 
 int LuaTerrainDescription::get_fertility(lua_State * L) {
-	lua_pushnumber(L, get()->fertility());
+	lua_pushdouble(L, get()->fertility());
 	return 1;
 }
 
@@ -3139,7 +3139,7 @@
 */
 
 int LuaTerrainDescription::get_humidity(lua_State * L) {
-	lua_pushnumber(L, get()->humidity());
+	lua_pushdouble(L, get()->humidity());
 	return 1;
 }
 
@@ -3157,11 +3157,11 @@
 /* RST
 	.. attribute:: temperature
 
-			(RO) the :class:`double` temperature value for this terrain
+			(RO) the :class:`uint` temperature value for this terrain
 */
 
 int LuaTerrainDescription::get_temperature(lua_State * L) {
-	lua_pushnumber(L, get()->temperature());
+	lua_pushuint32(L, get()->temperature());
 	return 1;
 }
 

=== modified file 'src/scripting/lua_ui.cc'
--- src/scripting/lua_ui.cc	2016-02-14 14:09:29 +0000
+++ src/scripting/lua_ui.cc	2016-04-10 16:54:20 +0000
@@ -206,7 +206,7 @@
 int LuaPanel::set_mouse_position_x(lua_State * L) {
 	assert(panel_);
 	Point p = panel_->get_mouse_position();
-	p.x = luaL_checkint32(L, -1);
+	p.x = floor(luaL_checkdouble(L, -1));
 	panel_->set_mouse_pos(p);
 	return 1;
 }
@@ -218,7 +218,7 @@
 int LuaPanel::set_mouse_position_y(lua_State * L) {
 	assert(panel_);
 	Point p = panel_->get_mouse_position();
-	p.y = luaL_checkint32(L, -1);
+	p.y = floor(luaL_checkdouble(L, -1));
 	panel_->set_mouse_pos(p);
 	return 1;
 }
@@ -554,7 +554,7 @@
 
 	MapView * mv = get();
 	Point p = mv->get_viewpoint();
-	p.x = luaL_checkuint32(L, -1);
+	p.x = floor(luaL_checkdouble(L, -1));
 	mv->set_viewpoint(p, true);
 	return 0;
 }
@@ -571,7 +571,7 @@
 
 	MapView * mv = get();
 	Point p = mv->get_viewpoint();
-	p.y = luaL_checkuint32(L, -1);
+	p.y = floor(luaL_checkdouble(L, -1));
 	mv->set_viewpoint(p, true);
 	return 0;
 }

=== modified file 'src/third_party/CMakeLists.txt'
--- src/third_party/CMakeLists.txt	2015-07-05 11:05:23 +0000
+++ src/third_party/CMakeLists.txt	2016-04-10 16:54:20 +0000
@@ -51,6 +51,7 @@
     eris/loslib.c
     eris/lparser.c
     eris/lparser.h
+    eris/lprefix.h
     eris/lstate.c
     eris/lstate.h
     eris/lstring.c
@@ -63,10 +64,13 @@
     eris/ltm.h
     eris/lua.h
     eris/lua.hpp
+    eris/lua.c
+    eris/luac.c
     eris/luaconf.h
     eris/lualib.h
     eris/lundump.c
     eris/lundump.h
+    eris/lutf8lib.c
     eris/lvm.c
     eris/lvm.h
     eris/lzio.c

=== modified file 'src/third_party/eris/README.eris'
--- src/third_party/eris/README.eris	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/README.eris	2016-04-10 16:54:20 +0000
@@ -1,11 +1,11 @@
 This directory contains a verbatim copy of Eris by Florian Nücke.
 
 URL: https://github.com/fnuecke/eris
-VERSION: 2e39ecc7dcb73120dde775929227fa661fbc6bc0
+VERSION: 1.1.0 for Lua 5.3
 
 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. 
+License.
 
    -- SirVer, in behalf of the Widelands Team

=== modified file 'src/third_party/eris/eris.c'
--- src/third_party/eris/eris.c	2014-07-25 11:14:03 +0000
+++ src/third_party/eris/eris.c	2016-04-10 16:54:20 +0000
@@ -1,6 +1,6 @@
 /*
-Eris - Heavy-duty persistence for Lua 5.2.2 - Based on Pluto
-Copyright (c) 2013 by Florian Nuecke.
+Eris - Heavy-duty persistence for Lua 5.3.0 - Based on Pluto
+Copyright (c) 2013-2015 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
@@ -113,14 +113,13 @@
 /* lfunc.h */
 #define eris_newproto luaF_newproto
 #define eris_newLclosure luaF_newLclosure
-#define eris_newupval luaF_newupval
+#define eris_initupvals luaF_initupvals
 #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_ttnov ttnov
+#define eris_clLvalue clLvalue
 #define eris_setnilvalue setnilvalue
 #define eris_setclLvalue setclLvalue
 #define eris_setobj setobj
@@ -176,15 +175,60 @@
 
 /*
 ** ============================================================================
+** Language strings for errors.
+** ============================================================================
+*/
+
+#define ERIS_ERR_CFUNC "attempt to persist a light C function (%p)"
+#define ERIS_ERR_COMPLEXITY "object too complex"
+#define ERIS_ERR_HOOK "cannot persist yielded hooks"
+#define ERIS_ERR_METATABLE "bad metatable, not nil or table"
+#define ERIS_ERR_NOFUNC "attempt to persist unknown function type"
+#define ERIS_ERR_READ "could not read data"
+#define ERIS_ERR_SPER_FUNC "%s did not return a function"
+#define ERIS_ERR_SPER_LOAD "bad unpersist function (%s expected, returned %s)"
+#define ERIS_ERR_SPER_PROT "attempt to persist forbidden table"
+#define ERIS_ERR_SPER_TYPE "%d not nil, boolean, or function"
+#define ERIS_ERR_SPER_UFUNC "invalid restore function"
+#define ERIS_ERR_SPER_UPERM "bad permanent value (%s expected, got %s)"
+#define ERIS_ERR_SPER_UPERMNIL "bad permanent value (no value)"
+#define ERIS_ERR_STACKBOUNDS "stack index out of bounds"
+#define ERIS_ERR_TABLE "bad table value, got a nil value"
+#define ERIS_ERR_THREAD "cannot persist currently running thread"
+#define ERIS_ERR_THREADCI "invalid callinfo"
+#define ERIS_ERR_THREADCTX "bad C continuation function"
+#define ERIS_ERR_THREADERRF "invalid errfunc"
+#define ERIS_ERR_THREADPC "saved program counter out of bounds"
+#define ERIS_ERR_TRUNC_INT "int value would get truncated"
+#define ERIS_ERR_TRUNC_SIZE "size_t value would get truncated"
+#define ERIS_ERR_TYPE_FLOAT "unsupported lua_Number type"
+#define ERIS_ERR_TYPE_INT "unsupported int type"
+#define ERIS_ERR_TYPE_SIZE "unsupported size_t type"
+#define ERIS_ERR_TYPEP "trying to persist unknown type %d"
+#define ERIS_ERR_TYPEU "trying to unpersist unknown type %d"
+#define ERIS_ERR_UCFUNC "bad C closure (C function expected, got %s)"
+#define ERIS_ERR_UCFUNCNULL "bad C closure (C function expected, got null)"
+#define ERIS_ERR_USERDATA "attempt to literally persist userdata"
+#define ERIS_ERR_WRITE "could not write data"
+#define ERIS_ERR_REF "invalid reference #%d. this usually means a special "\
+                      "persistence callback of a table referenced said table "\
+                      "(directly or indirectly via an upvalue)."
+
+/*
+** ============================================================================
 ** Constants, settings, types and forward declarations.
 ** ============================================================================
 */
 
+/* The upvalue tag type was removed in Lua 5.3, but we still need it for
+ * special handling of upvalues, so we redeclare it for internal use. */
+#define LUA_TUPVAL (LUA_TOTALTAGS + 1)
+
 /* 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)
+#define ERIS_PERMANENT (LUA_TOTALTAGS + 2)
 
 /* 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
@@ -266,6 +310,12 @@
 #define BUFFIDX 3
 #define PATHIDX 4
 
+/* Table indices for upvalue tables, keeping track of upvals to open. */
+#define UVTOCL 1
+#define UVTONU 2
+#define UVTVAL 3
+#define UVTREF 4
+
 /* }======================================================================== */
 
 /*
@@ -405,12 +455,13 @@
 }
 
 /* Used as a callback for luaL_opt to check boolean setting values. */
-static void
+static bool
 checkboolean(lua_State *L, int narg) {                       /* ... bool? ... */
   if (!lua_isboolean(L, narg)) {                                /* ... :( ... */
-    luaL_argerror(L, narg, lua_pushfstring(L,
+    return luaL_argerror(L, narg, lua_pushfstring(L,
       "boolean expected, got %s", lua_typename(L, lua_type(L, narg))));
   }                                                           /* ... bool ... */
+  return lua_toboolean(L, narg);
 }
 
 /* }======================================================================== */
@@ -427,7 +478,7 @@
 /* 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"); }
+    eris_error(info, ERIS_ERR_WRITE); }
 
 /* Writes a single value with the specified type. */
 #define WRITE_VALUE(value, type) write_##type(info, value)
@@ -441,7 +492,7 @@
 /* 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"); }
+    eris_error(info, ERIS_ERR_READ); }
 
 /* Reads a single value with the specified type. */
 #define READ_VALUE(type) read_##type(info)
@@ -527,7 +578,7 @@
     write_int64_t(info, value);
   }
   else {
-    eris_error(info, "unsupported int type");
+    eris_error(info, ERIS_ERR_TYPE_INT);
   }
 }
 
@@ -543,7 +594,7 @@
     write_uint64_t(info, value);
   }
   else {
-    eris_error(info, "unsupported size_t type");
+    eris_error(info, ERIS_ERR_TYPE_SIZE);
   }
 }
 
@@ -556,7 +607,20 @@
     write_float64(info, value);
   }
   else {
-    eris_error(info, "unsupported lua_Number type");
+    eris_error(info, ERIS_ERR_TYPE_FLOAT);
+  }
+}
+
+static void
+write_lua_Integer(Info *info, lua_Integer value) {
+  if (sizeof(lua_Integer) == sizeof(uint32_t)) {
+    write_uint32_t(info, value);
+  }
+  else if (sizeof(lua_Integer) == sizeof(uint64_t)) {
+    write_uint64_t(info, value);
+  }
+  else {
+    eris_error(info, ERIS_ERR_TYPE_INT);
   }
 }
 
@@ -657,25 +721,25 @@
     int16_t pvalue = read_int16_t(info);
     value = (int)pvalue;
     if ((int32_t)value != pvalue) {
-      eris_error(info, "int value would get truncated");
+      eris_error(info, ERIS_ERR_TRUNC_INT);
     }
   }
   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");
+      eris_error(info, ERIS_ERR_TRUNC_INT);
     }
   }
   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");
+      eris_error(info, ERIS_ERR_TRUNC_INT);
     }
   }
   else {
-    eris_error(info, "unsupported int type");
+    eris_error(info, ERIS_ERR_TYPE_INT);
     value = 0; /* not reached */
   }
   return value;
@@ -688,25 +752,25 @@
     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");
+      eris_error(info, ERIS_ERR_TRUNC_SIZE);
     }
   }
   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");
+      eris_error(info, ERIS_ERR_TRUNC_SIZE);
     }
   }
   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");
+      eris_error(info, ERIS_ERR_TRUNC_SIZE);
     }
   }
   else {
-    eris_error(info, "unsupported size_t type");
+    eris_error(info, ERIS_ERR_TYPE_SIZE);
     value = 0; /* not reached */
   }
   return value;
@@ -721,7 +785,21 @@
     return read_float64(info);
   }
   else {
-    eris_error(info, "unsupported lua_Number type");
+    eris_error(info, ERIS_ERR_TYPE_FLOAT);
+    return 0; /* not reached */
+  }
+}
+
+static lua_Integer
+read_lua_Integer(Info *info) {
+  if (sizeof(lua_Integer) == sizeof(uint32_t)) {
+    return (lua_Integer) read_uint32_t(info);
+  }
+  else if (sizeof(lua_Integer) == sizeof(uint64_t)) {
+    return (lua_Integer) read_uint64_t(info);
+  }
+  else {
+    eris_error(info, ERIS_ERR_TYPE_INT);
     return 0; /* not reached */
   }
 }
@@ -776,13 +854,25 @@
 
 static void
 p_number(Info *info) {                                             /* ... num */
-  WRITE_VALUE(lua_tonumber(info->L, -1), lua_Number);
+  if (lua_isinteger(info->L, -1)) {
+    WRITE_VALUE(true, uint8_t);
+    WRITE_VALUE(lua_tointeger(info->L, -1), lua_Integer);
+  }
+  else {
+    WRITE_VALUE(false, uint8_t);
+    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 */
+  if (READ_VALUE(uint8_t)) {
+    lua_pushinteger(info->L, READ_VALUE(lua_Integer));
+  }
+  else {
+    lua_pushnumber(info->L, READ_VALUE(lua_Number));               /* ... num */
+  }
 
   eris_assert(lua_type(info->L, -1) == LUA_TNUMBER);
 }
@@ -801,7 +891,7 @@
 u_string(Info *info) {                                                 /* ... */
   eris_checkstack(info->L, 2);
   {
-	 // TODO(unknown): Can we avoid this copy somehow? (Without it getting too nasty)
+    /* 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);
@@ -843,7 +933,7 @@
     lua_pop(info->L, 1);                                           /* ... tbl */
   }
   else {                                                            /* tbl :( */
-    eris_error(info, "bad metatable, not nil or table");
+    eris_error(info, ERIS_ERR_METATABLE);
   }
   poppath(info);
 }
@@ -923,7 +1013,7 @@
       lua_rawset(info->L, -3);                                     /* ... tbl */
     }
     else {
-      eris_error(info, "bad table value, got a nil value");
+      eris_error(info, ERIS_ERR_TABLE);
     }
 
     poppath(info);
@@ -996,8 +1086,7 @@
           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);
+          eris_error(info, ERIS_ERR_SPER_FUNC, info->u.pi.metafield);
         }                                                     /* ... obj func */
 
         /* Special persistence, call this function when unpersisting. */
@@ -1006,8 +1095,7 @@
         lua_pop(info->L, 1);                                       /* ... obj */
         return;
       default:                                               /* ... obj mt :( */
-        eris_error(info, "%d not nil, boolean, or function",
-                   info->u.pi.metafield);
+        eris_error(info, ERIS_ERR_SPER_TYPE, info->u.pi.metafield);
         return; /* not reached */
     }
   }
@@ -1018,10 +1106,10 @@
     literal(info);                                                 /* ... obj */
   }
   else if (lua_type(info->L, -1) == LUA_TTABLE) {
-    eris_error(info, "attempt to persist forbidden table");
+    eris_error(info, ERIS_ERR_SPER_PROT);
   }
   else {
-    eris_error(info, "attempt to literally persist userdata");
+    eris_error(info, ERIS_ERR_USERDATA);
   }
 }
 
@@ -1040,7 +1128,7 @@
      * persisting a special object. */
     unpersist(info);                                           /* ... spfunc? */
     if (!lua_isfunction(info->L, -1)) {                             /* ... :( */
-      eris_error(info, "invalid restore function");
+      eris_error(info, ERIS_ERR_SPER_UFUNC);
     }                                                           /* ... spfunc */
 
     if (info->passIOToPersist) {
@@ -1051,8 +1139,9 @@
     }
 
     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)]);
+      const char *want = kTypenames[type];
+      const char *have = kTypenames[lua_type(info->L, -1)];
+      eris_error(info, ERIS_ERR_SPER_LOAD, want, have);
     }                                                              /* ... obj */
 
     /* Update the reftable entry. */
@@ -1326,12 +1415,14 @@
 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 */
+  /* Create the table we use to store the stack location to the upval (1+2),
+   * the value of the upval (3) and any references to the upvalue's value (4+).
+   * References are stored as two entries each, the actual closure holding the
+   * upvalue, and the index of the upvalue in that closure. */
+  lua_createtable(info->L, 5, 0);                                  /* ... tbl */
   registerobject(info);
   unpersist(info);                                             /* ... tbl obj */
-  lua_rawseti(info->L, -2, 1);                                     /* ... tbl */
+  lua_rawseti(info->L, -2, UVTVAL);                                /* ... tbl */
 
   eris_assert(lua_type(info->L, -1) == LUA_TTABLE);
 }
@@ -1354,8 +1445,7 @@
   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));
+      eris_error(info, ERIS_ERR_CFUNC, lua_tocfunction(info->L, -1));
       return; /* not reached */
     case LUA_TCCL: /* C closure */ {                  /* perms reftbl ... ccl */
       CClosure *cl = clCvalue(info->L->top - 1);
@@ -1387,7 +1477,7 @@
       break;
     }
     case LUA_TLCL: /* Lua function */ {               /* perms reftbl ... lcl */
-      LClosure *cl = clLvalue(info->L->top - 1);
+      LClosure *cl = eris_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
@@ -1421,7 +1511,7 @@
       break;
     }
     default:
-      eris_error(info, "attempt to persist unknown function type");
+      eris_error(info, ERIS_ERR_NOFUNC);
       return; /* not reached */
   }
 }
@@ -1444,12 +1534,11 @@
     /* 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)]);
+      eris_error(info, ERIS_ERR_UCFUNC, 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)");
+      eris_error(info, ERIS_ERR_UCFUNCNULL);
     }
     lua_pop(info->L, 1);                                               /* ... */
 
@@ -1476,7 +1565,7 @@
     poppath(info);
   }
   else {
-    Closure *cl;
+    LClosure *cl;
     Proto *p;
 
     eris_checkstack(info->L, 4);
@@ -1494,27 +1583,28 @@
      * 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);
+    cl->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 */
+    lua_pushlightuserdata(info->L, cl->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 */
+    if (p != cl->p) {                              /* ... lcl nproto oproto */
       /* Just overwrite the old one, GC will clean this up. */
-      cl->l.p = p;
+      cl->p = p;
     }
     lua_pop(info->L, 2);                                           /* ... lcl */
-    eris_assert(cl->l.p->sizeupvalues == nups);
+    eris_assert(cl->nupvalues == cl->p->sizeupvalues);
+    eris_initupvals(info->L, cl); /* Init to all closed, fill in later. */
     poppath(info);
 
     /* Unpersist all upvalues. */
     pushpath(info, ".upvalues");
     for (nup = 1; nup <= nups; ++nup) {
-      UpVal **uv = &cl->l.upvals[nup - 1];
+      UpVal **uv = &cl->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));
@@ -1524,50 +1614,60 @@
       }
       unpersist(info);                                         /* ... lcl tbl */
       eris_assert(lua_type(info->L, -1) == LUA_TTABLE);
-      lua_rawgeti(info->L, -1, 2);                   /* ... lcl tbl upval/nil */
+      lua_rawgeti(info->L, -1, UVTOCL);               /* ... lcl tbl olcl/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 */
+        lua_pushvalue(info->L, -2);                        /* ... lcl tbl lcl */
+        lua_rawseti(info->L, -2, UVTOCL);                      /* ... lcl tbl */
+        lua_pushinteger(info->L, nup);                     /* ... lcl tbl nup */
+        lua_rawseti(info->L, -2, UVTONU);                      /* ... lcl tbl */
       }
-      else {                                             /* ... lcl tbl upval */
-        eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
-        *uv = (UpVal*)lua_touserdata(info->L, -1);
+      else {                                              /* ... lcl tbl olcl */
+        int onup;
+        eris_assert(lua_type(info->L, -1) == LUA_TFUNCTION);
+        lua_rawgeti(info->L, -2, UVTONU);            /* ... lcl tbl olcl onup */
+        eris_assert(lua_type(info->L, -1) == LUA_TNUMBER);
+        onup = lua_tointeger(info->L, -1);
+        lua_pop(info->L, 1);                              /* ... lcl tbl olcl */
+        lua_upvaluejoin(info->L, -3, nup, -1, onup);
         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
+       * the list, for reference 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) {
+      if (!upisopen(*uv)) {
+        int i;
         /* 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 */
+         * incorrectly initialized to nil before (or rather, not yet set). */
+        lua_rawgeti(info->L, -1, UVTVAL);                  /* ... 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 */
+        lua_pushinteger(info->L, nup);                     /* ... lcl tbl nup */
+        lua_pushvalue(info->L, -3);                    /* ... lcl tbl nup lcl */
+        if (luaL_len(info->L, -3) >= UVTVAL) {
+          /* Got a valid sequence (value already set), insert at the end. */
+          i = luaL_len(info->L, -3);
+          lua_rawseti(info->L, -3, i + 1);                 /* ... lcl tbl nup */
+          lua_rawseti(info->L, -2, i + 2);                     /* ... lcl tbl */
         }
-        else {                                          /* ... lcl tbl upvalp */
-          int i;
+        else {                                         /* ... lcl tbl nup lcl */
           /* 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 */
+          for (i = UVTREF;; i += 2) {
+            lua_rawgeti(info->L, -3, i);       /* ... lcl tbl nup lcl lcl/nil */
+            if (lua_isnil(info->L, -1)) {          /* ... lcl tbl nup lcl nil */
+              lua_pop(info->L, 1);                     /* ... lcl tbl nup lcl */
+              lua_rawseti(info->L, -3, i);                 /* ... lcl tbl nup */
+              lua_rawseti(info->L, -2, i + 1);                 /* ... lcl tbl */
               break;
             }
             else {
-              lua_pop(info->L, 1);                      /* ... lcl tbl upvalp */
+              lua_pop(info->L, 1);                     /* ... lcl tbl nup lcl */
             }
           }                                                    /* ... lcl tbl */
         }
@@ -1578,8 +1678,9 @@
     }
     poppath(info);
 
-    eris_barrierproto(info->L, p, cl);
-    p->cache = cl; /* save it in cache for reuse, see lvm.c:416 */
+    /* save it in cache for reuse, see lvm.c:416 */
+    if (!isblack(p))
+      p->cache = cl;
   }
 
   eris_assert(lua_type(info->L, -1) == LUA_TFUNCTION);
@@ -1590,8 +1691,7 @@
 static void
 p_thread(Info *info) {                                          /* ... thread */
   lua_State* thread = lua_tothread(info->L, -1);
-  size_t level;
-  StkId o;
+  size_t level = 0, total = thread->top - thread->stack;
   CallInfo *ci;
   UpVal *uv;
 
@@ -1600,13 +1700,13 @@
   /* 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");
+    eris_error(info, ERIS_ERR_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);
+  WRITE_VALUE(total, size_t);
 
   /* The Lua stack looks like this:
    * stack ... top ... stack_last
@@ -1614,10 +1714,15 @@
    * 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 */
+  /* Since the thread's stack may be re-allocated in the meantime, we cannot
+   * use pointer arithmetic here (i.e. o = thread->stack; ...; ++o). Instead we
+   * have to keep track of our position in the stack directly (which we do for
+   * the path info anyway) and compute the actual address each time.
+   */
+  for (; level < total; ++level) {
+    pushpath(info, "[%d]", level);
+    eris_setobj(info->L, info->L->top - 1, thread->stack + level);
+                                                            /* ... thread obj */
     persist(info);                                          /* ... thread obj */
     poppath(info);
   }
@@ -1647,7 +1752,7 @@
   WRITE_VALUE(thread->hookcount, int); */
 
   if (thread->hook) {
-	 // TODO(unknown): Warn that hooks are not persisted?
+    /* TODO Warn that hooks are not persisted? */
   }
 
   /* Write call information (stack frames). In 5.2 CallInfo is stored in a
@@ -1665,42 +1770,46 @@
     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(unknown): 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 */
+    if (ci->callstatus) {
+      /* 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, ERIS_ERR_HOOK);
+      }
+
+      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 {
+        /* These are only used while a thread is being executed:
+        WRITE_VALUE(ci->u.c.old_errfunc, ptrdiff_t); */
+        if (thread->status == LUA_YIELD && ci->u.c.k) {
+          WRITE_VALUE(true, uint8_t);
+          WRITE_VALUE(ci->u.c.ctx, int);
+          /* NOTE Ugly hack. We have to push the continuation function as a C
+           * function to properly track it in our ref table. It's never called,
+           * so we can get away with this. */
+          lua_pushcfunction(info->L, (lua_CFunction) ci->u.c.k);
+                                                             /* ... thread func */
+          persist(info);                                 /* ... thread func/nil */
+          lua_pop(info->L, 1);                                    /* ... thread */
+        }
+        else {
+          WRITE_VALUE(false, uint8_t);
+        }
       }
     }
 
@@ -1719,11 +1828,11 @@
   pushpath(info, ".openupval");
   lua_pushnil(info->L);                                     /* ... thread nil */
   level = 0;
-  for (uv = eris_gco2uv(thread->openupval);
+  for (uv = thread->openupval;
        uv != NULL;
-       uv = eris_gco2uv(eris_gch(eris_obj2gco(uv))->next))
+       uv = uv->u.open.next)
   {
-    pushpath(info, "[%d]", level);
+    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 */
@@ -1739,7 +1848,7 @@
 #define validate(stackpos, inclmax) \
   if ((stackpos) < thread->stack || stackpos > (inclmax)) { \
     (stackpos) = thread->stack; \
-    eris_error(info, "stack index out of bounds"); }
+    eris_error(info, ERIS_ERR_STACKBOUNDS); }
 
 /* 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
@@ -1805,8 +1914,8 @@
   if (thread->errfunc) {
     o = eris_restorestack(thread, thread->errfunc);
     validate(o, thread->top);
-    if (eris_ttypenv(o) != LUA_TFUNCTION) {
-      eris_error(info, "invalid errfunc");
+    if (eris_ttnov(o) != LUA_TFUNCTION) {
+      eris_error(info, ERIS_ERR_THREADERRF);
     }
   }
   /* These are only used while a thread is being executed or can be deduced:
@@ -1835,61 +1944,64 @@
     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");
-      }
+    if (thread->ci->callstatus) {
+      /** 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_ttnov(o) != LUA_TFUNCTION) {
+          eris_error(info, ERIS_ERR_THREADCI);
+        }
+      }
+
+      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, ERIS_ERR_THREADPC);
+        }
+      }
+      else {
+        /* 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_errfunc = 0;
+
+        if (thread->status == LUA_YIELD && READ_VALUE(uint8_t)) {
+          thread->ci->u.c.ctx = READ_VALUE(int);
+          LOCK(thread);
+          unpersist(info);                                  /* ... thread func? */
+          UNLOCK(thread);
+          if (lua_iscfunction(info->L, -1)) {                /* ... thread func */
+            /* NOTE Ugly hack. See p_thread. */
+            thread->ci->u.c.k = (lua_KFunction) lua_tocfunction(info->L, -1);
+          }
+          else {
+            eris_error(info, ERIS_ERR_THREADCTX);
+            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);
     }
     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.k = NULL;
       thread->ci->u.c.old_errfunc = 0;
-      thread->ci->u.c.old_allowhook = 0;
-
-		// TODO(unknown): 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;
-      }
+      thread->ci->u.c.ctx = 0;
     }
-    LOCK(thread);
-    poppath(info);
-    UNLOCK(thread);
 
     /* Read in value for check for next iteration. */
     if (READ_VALUE(uint8_t)) {
@@ -1904,8 +2016,8 @@
       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_ttnov(o) != LUA_TFUNCTION) {
+      eris_error(info, ERIS_ERR_THREADCI);
     }
   }
   LOCK(thread);
@@ -1919,7 +2031,7 @@
    * 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. */
+   * upvalue, so that we can adjust these references in here. */
   LOCK(thread);
   pushpath(info, ".openupval");
   UNLOCK(thread);
@@ -1948,19 +2060,27 @@
     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 */
+    /* Then check if we need to patch some references. */
+    lua_rawgeti(info->L, -1, UVTREF);               /* ... thread tbl lcl/nil */
+    if (!lua_isnil(info->L, -1)) {                      /* ... thread tbl lcl */
       int i, n;
-      eris_assert(lua_type(info->L, -1) == LUA_TLIGHTUSERDATA);
+      eris_assert(lua_type(info->L, -1) == LUA_TFUNCTION);
       /* 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. */
+       * references to the already existing one, which we added to the table in
+       * u_closure. */
       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 */
+      for (i = UVTREF, n = luaL_len(info->L, -1); i <= n; i += 2) {
+        LClosure *cl;
+        int nup;
+        lua_rawgeti(info->L, -1, i);                    /* ... thread tbl lcl */
+        cl = eris_clLvalue(info->L->top - 1);
+        lua_pop(info->L, 1);                                /* ... thread tbl */
+        lua_rawgeti(info->L, -1, i + 1);                /* ... thread tbl nup */
+        nup = lua_tointeger(info->L, -1);
+        lua_pop(info->L, 1);                                /* ... thread tbl */
+        /* Open the upvalue by pointing to the stack and register in GC. */
+        cl->upvals[nup - 1] = nuv;
+        cl->upvals[nup - 1]->refcount++;
       }
     }
     else {                                              /* ... thread tbl nil */
@@ -1970,8 +2090,6 @@
 
     /* 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);
@@ -1996,7 +2114,7 @@
 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");
+    eris_error(info, ERIS_ERR_COMPLEXITY);
   }
   ++info->level;
 
@@ -2033,7 +2151,7 @@
       p_upval(info);
       break;
     default:
-      eris_error(info, "trying to persist unknown type");
+      eris_error(info, ERIS_ERR_TYPEP, type);
   }                                                   /* perms reftbl ... obj */
 
   --info->level;
@@ -2130,13 +2248,14 @@
   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)");
+    eris_error(info, ERIS_ERR_SPER_UPERMNIL);
   }
   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)]);
+    const char *want = kTypenames[type];
+    const char *have = kTypenames[lua_type(info->L, -1)];
+    eris_error(info, ERIS_ERR_SPER_UPERM, want, have);
   }                                                   /* perms reftbl ... obj */
   /* Create the entry in the reftable. */
   lua_pushvalue(info->L, -1);                     /* perms reftbl ... obj obj */
@@ -2147,7 +2266,7 @@
 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");
+    eris_error(info, ERIS_ERR_COMPLEXITY);
   }
   ++info->level;
 
@@ -2158,7 +2277,7 @@
       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);
+        eris_error(info, ERIS_ERR_REF, reference);
       }                                            /* perms reftbl ud ... obj */
     }
     else {
@@ -2201,7 +2320,7 @@
           u_permanent(info);
           break;
         default:
-          eris_error(info, "trying to unpersist unknown type %d", type);
+          eris_error(info, ERIS_ERR_TYPEU, type);
       }                                              /* perms reftbl ... obj? */
     }
   }
@@ -2289,6 +2408,7 @@
   WRITE_RAW(kHeader, HEADER_LENGTH);
   WRITE_VALUE(sizeof(lua_Number), uint8_t);
   WRITE_VALUE(kHeaderNumber, lua_Number);
+  WRITE_VALUE(sizeof(lua_Integer), uint8_t);
   WRITE_VALUE(sizeof(int), uint8_t);
   WRITE_VALUE(sizeof(size_t), uint8_t);
 }
@@ -2317,6 +2437,9 @@
   if (READ_VALUE(lua_Number) != kHeaderNumber) {
     luaL_error(info->L, "incompatible floating point representation");
   }
+  if (READ_VALUE(uint8_t) != sizeof(lua_Integer)) {
+    luaL_error(info->L, "incompatible integer type");
+  }
   info->u.upi.sizeof_int = READ_VALUE(uint8_t);
   info->u.upi.sizeof_size_t = READ_VALUE(uint8_t);
 }
@@ -2339,7 +2462,7 @@
 
   if (get_setting(L, (void*)&kSettingMaxComplexity)) {
                                                   /* perms buff rootobj value */
-    info.maxComplexity = lua_tounsigned(L, -1);
+    info.maxComplexity = lua_tointeger(L, -1);
     lua_pop(L, 1);                                      /* perms buff rootobj */
   }
   if (get_setting(L, (void*)&kSettingGeneratePath)) {
@@ -2399,7 +2522,7 @@
 
   if (get_setting(L, (void*)&kSettingMaxComplexity)) {
                                                   /* perms buff rootobj value */
-    info.maxComplexity = lua_tounsigned(L, -1);
+    info.maxComplexity = lua_tointeger(L, -1);
     lua_pop(L, 1);                                      /* perms buff rootobj */
   }
   if (get_setting(L, (void*)&kSettingGeneratePath)) {
@@ -2533,7 +2656,7 @@
     }
     else if (IS(kSettingMaxComplexity)) {
       if (!get_setting(L, (void*)&kSettingMaxComplexity)) {
-        lua_pushunsigned(L, kMaxComplexity);
+        lua_pushinteger(L, kMaxComplexity);
       }
     }
     else {
@@ -2561,7 +2684,7 @@
       set_setting(L, (void*)&kSettingGeneratePath);
     }
     else if (IS(kSettingMaxComplexity)) {
-      luaL_optunsigned(L, 2, 0);
+      luaL_optinteger(L, 2, 0);
       set_setting(L, (void*)&kSettingMaxComplexity);
     }
     else {
@@ -2621,6 +2744,8 @@
 
 LUA_API void
 eris_persist(lua_State *L, int perms, int value) {                    /* ...? */
+  perms = lua_absindex(L, perms);
+  value = lua_absindex(L, value);
   eris_checkstack(L, 3);
   lua_pushcfunction(L, l_persist);                           /* ... l_persist */
   lua_pushvalue(L, perms);                             /* ... l_persist perms */
@@ -2630,6 +2755,8 @@
 
 LUA_API void
 eris_unpersist(lua_State *L, int perms, int value) {                   /* ... */
+  perms = lua_absindex(L, perms);
+  value = lua_absindex(L, value);
   eris_checkstack(L, 3);
   lua_pushcfunction(L, l_unpersist);                       /* ... l_unpersist */
   lua_pushvalue(L, perms);                           /* ... l_unpersist perms */
@@ -2647,6 +2774,7 @@
 
 LUA_API void
 eris_set_setting(lua_State *L, const char *name, int value) {          /* ... */
+  value = lua_absindex(L, value);
   eris_checkstack(L, 3);
   lua_pushcfunction(L, l_settings);                         /* ... l_settings */
   lua_pushstring(L, name);                             /* ... l_settings name */

=== modified file 'src/third_party/eris/eris.h'
--- src/third_party/eris/eris.h	2013-10-17 07:22:46 +0000
+++ src/third_party/eris/eris.h	2016-04-10 16:54:20 +0000
@@ -1,6 +1,6 @@
 /*
-Eris - Heavy-duty persistence for Lua 5.2.2 - Based on Pluto
-Copyright (c) 2013 by Florian Nuecke.
+Eris - Heavy-duty persistence for Lua 5.3.0 - Based on Pluto
+Copyright (c) 2013-2015 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
@@ -26,6 +26,11 @@
 #ifndef ERIS_H
 #define ERIS_H
 
+#define ERIS_VERSION_MAJOR  "1"
+#define ERIS_VERSION_MINOR  "1"
+#define ERIS_VERSION_NUM    101
+#define ERIS_VERSION_RELEASE  "0"
+
 /*
 ** ==================================================================
 ** API

=== modified file 'src/third_party/eris/lapi.c'
--- src/third_party/eris/lapi.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lapi.c	2016-04-10 16:54:20 +0000
@@ -1,16 +1,18 @@
 /*
-** $Id: lapi.c,v 2.171.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lapi.c,v 2.244 2014/12/26 14:43:45 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
 
+#define lapi_c
+#define LUA_CORE
+
+#include "lprefix.h"
+
 
 #include <stdarg.h>
 #include <string.h>
 
-#define lapi_c
-#define LUA_CORE
-
 #include "lua.h"
 
 #include "lapi.h"
@@ -43,32 +45,35 @@
 /* test for pseudo index */
 #define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)
 
+/* test for upvalue */
+#define isupvalue(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_checkvalidindex(o)  api_check(isvalid(o), "invalid index")
 
-#define api_checkstackindex(L, i, o)  \
-	api_check(L, isstackindex(i, o), "index not in the stack")
+#define api_checkstackindex(i, o)  \
+	api_check(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");
+    api_check(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");
+    api_check(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");
+    api_check(idx <= MAXUPVAL + 1, "upvalue index too large");
     if (ttislcf(ci->func))  /* light C function? */
       return NONVALIDVALUE;  /* it has no upvalues */
     else {
@@ -89,21 +94,22 @@
 }
 
 
-LUA_API int lua_checkstack (lua_State *L, int size) {
+LUA_API int lua_checkstack (lua_State *L, int n) {
   int res;
   CallInfo *ci = L->ci;
   lua_lock(L);
-  if (L->stack_last - L->top > size)  /* stack large enough? */
+  api_check(n >= 0, "negative 'n'");
+  if (L->stack_last - L->top > n)  /* 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? */
+    if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */
       res = 0;  /* no */
     else  /* try to grow stack */
-      res = (luaD_rawrunprotected(L, &growstack, &size) == LUA_OK);
+      res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK);
   }
-  if (res && ci->top < L->top + size)
-    ci->top = L->top + size;  /* adjust frame top */
+  if (res && ci->top < L->top + n)
+    ci->top = L->top + n;  /* adjust frame top */
   lua_unlock(L);
   return res;
 }
@@ -114,8 +120,8 @@
   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");
+  api_check(G(from) == G(to), "moving among independent states");
+  api_check(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);
@@ -166,68 +172,63 @@
   StkId func = L->ci->func;
   lua_lock(L);
   if (idx >= 0) {
-    api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
+    api_check(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);
+    api_check(-(idx+1) <= (L->top - (func + 1)), "invalid new top");
+    L->top += idx+1;  /* 'subtract' index (index is negative) */
+  }
+  lua_unlock(L);
+}
+
+
+/*
+** Reverse the stack segment from 'from' to 'to'
+** (auxiliary to 'lua_rotate')
+*/
+static void reverse (lua_State *L, StkId from, StkId to) {
+  for (; from < to; from++, to--) {
+    TValue temp;
+    setobj(L, &temp, from);
+    setobjs2s(L, from, to);
+    setobj2s(L, to, &temp);
+  }
+}
+
+
+/*
+** Let x = AB, where A is a prefix of length 'n'. Then,
+** rotate x n == BA. But BA == (A^r . B^r)^r.
+*/
+LUA_API void lua_rotate (lua_State *L, int idx, int n) {
+  StkId p, t, m;
+  lua_lock(L);
+  t = L->top - 1;  /* end of stack segment being rotated */
+  p = index2addr(L, idx);  /* start of segment */
+  api_checkstackindex(idx, p);
+  api_check((n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
+  m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */
+  reverse(L, p, m);  /* reverse the prefix with length 'n' */
+  reverse(L, m + 1, t);  /* reverse the suffix */
+  reverse(L, p, t);  /* reverse the entire segment */
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
+  TValue *fr, *to;
+  lua_lock(L);
+  fr = index2addr(L, fromidx);
+  to = index2addr(L, toidx);
+  api_checkvalidindex(to);
   setobj(L, to, fr);
-  if (idx < LUA_REGISTRYINDEX)  /* function upvalue? */
+  if (isupvalue(toidx))  /* 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);
 }
 
@@ -248,12 +249,13 @@
 
 LUA_API int lua_type (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
-  return (isvalid(o) ? ttypenv(o) : LUA_TNONE);
+  return (isvalid(o) ? ttnov(o) : LUA_TNONE);
 }
 
 
 LUA_API const char *lua_typename (lua_State *L, int t) {
   UNUSED(L);
+  api_check(LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag");
   return ttypename(t);
 }
 
@@ -264,22 +266,28 @@
 }
 
 
+LUA_API int lua_isinteger (lua_State *L, int idx) {
+  StkId o = index2addr(L, idx);
+  return ttisinteger(o);
+}
+
+
 LUA_API int lua_isnumber (lua_State *L, int idx) {
-  TValue n;
+  lua_Number 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);
+  const TValue *o = index2addr(L, idx);
+  return (ttisstring(o) || cvt2str(o));
 }
 
 
 LUA_API int lua_isuserdata (lua_State *L, int idx) {
   const TValue *o = index2addr(L, idx);
-  return (ttisuserdata(o) || ttislightuserdata(o));
+  return (ttisfulluserdata(o) || ttislightuserdata(o));
 }
 
 
@@ -291,24 +299,17 @@
 
 
 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 */
+  if (op != LUA_OPUNM && op != LUA_OPBNOT)
+    api_checknelems(L, 2);  /* all other operations expect two operands */
+  else {  /* for unary operations, 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--;
+  /* first operand at top - 2, second at top - 1; result go to top - 2 */
+  luaO_arith(L, op, L->top - 2, L->top - 1, L->top - 2);
+  L->top--;  /* remove second operand */
   lua_unlock(L);
 }
 
@@ -321,10 +322,10 @@
   o2 = index2addr(L, index2);
   if (isvalid(o1) && isvalid(o2)) {
     switch (op) {
-      case LUA_OPEQ: i = equalobj(L, o1, o2); break;
+      case LUA_OPEQ: i = luaV_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");
+      default: api_check(0, "invalid option");
     }
   }
   lua_unlock(L);
@@ -332,51 +333,33 @@
 }
 
 
-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 size_t lua_stringtonumber (lua_State *L, const char *s) {
+  size_t sz = luaO_str2num(s, L->top);
+  if (sz != 0)
+    api_incr_top(L);
+  return sz;
+}
+
+
+LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {
+  lua_Number n;
+  const TValue *o = index2addr(L, idx);
+  int isnum = tonumber(o, &n);
+  if (!isnum)
+    n = 0;  /* call to 'tonumber' may change 'n' even if it fails */
+  if (pisnum) *pisnum = isnum;
+  return n;
+}
+
+
+LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
+  lua_Integer res;
+  const TValue *o = index2addr(L, idx);
+  int isnum = tointeger(o, &res);
+  if (!isnum)
+    res = 0;  /* call to 'tointeger' may change 'n' even if it fails */
+  if (pisnum) *pisnum = isnum;
+  return res;
 }
 
 
@@ -389,14 +372,14 @@
 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 (!cvt2str(o)) {  /* not convertible? */
       if (len != NULL) *len = 0;
-      lua_unlock(L);
       return NULL;
     }
+    lua_lock(L);  /* 'luaO_tostring' may create a new string */
     luaC_checkGC(L);
     o = index2addr(L, idx);  /* previous call may reallocate the stack */
+    luaO_tostring(L, o);
     lua_unlock(L);
   }
   if (len != NULL) *len = tsvalue(o)->len;
@@ -406,7 +389,7 @@
 
 LUA_API size_t lua_rawlen (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
-  switch (ttypenv(o)) {
+  switch (ttnov(o)) {
     case LUA_TSTRING: return tsvalue(o)->len;
     case LUA_TUSERDATA: return uvalue(o)->len;
     case LUA_TTABLE: return luaH_getn(hvalue(o));
@@ -426,8 +409,8 @@
 
 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);
+  switch (ttnov(o)) {
+    case LUA_TUSERDATA: return getudatamem(uvalue(o));
     case LUA_TLIGHTUSERDATA: return pvalue(o);
     default: return NULL;
   }
@@ -472,9 +455,7 @@
 
 LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
   lua_lock(L);
-  setnvalue(L->top, n);
-  luai_checknum(L, L->top,
-    luaG_runerror(L, "C API - attempt to push a signaling NaN"));
+  setfltvalue(L->top, n);
   api_incr_top(L);
   lua_unlock(L);
 }
@@ -482,17 +463,7 @@
 
 LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
   lua_lock(L);
-  setnvalue(L->top, cast_num(n));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) {
-  lua_Number n;
-  lua_lock(L);
-  n = lua_unsigned2number(u);
-  setnvalue(L->top, n);
+  setivalue(L->top, n);
   api_incr_top(L);
   lua_unlock(L);
 }
@@ -558,15 +529,17 @@
     setfvalue(L->top, fn);
   }
   else {
-    Closure *cl;
+    CClosure *cl;
     api_checknelems(L, n);
-    api_check(L, n <= MAXUPVAL, "upvalue index too large");
+    api_check(n <= MAXUPVAL, "upvalue index too large");
     luaC_checkGC(L);
     cl = luaF_newCclosure(L, n);
-    cl->c.f = fn;
+    cl->f = fn;
     L->top -= n;
-    while (n--)
-      setobj2n(L, &cl->c.upvalue[n], L->top + n);
+    while (n--) {
+      setobj2n(L, &cl->upvalue[n], L->top + n);
+      /* does not need barrier because closure is white */
+    }
     setclCvalue(L, L->top, cl);
   }
   api_incr_top(L);
@@ -605,27 +578,29 @@
 */
 
 
-LUA_API void lua_getglobal (lua_State *L, const char *var) {
+LUA_API int lua_getglobal (lua_State *L, const char *name) {
   Table *reg = hvalue(&G(L)->l_registry);
   const TValue *gt;  /* global table */
   lua_lock(L);
   gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
-  setsvalue2s(L, L->top++, luaS_new(L, var));
+  setsvalue2s(L, L->top++, luaS_new(L, name));
   luaV_gettable(L, gt, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 
 
-LUA_API void lua_gettable (lua_State *L, int idx) {
+LUA_API int lua_gettable (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   luaV_gettable(L, t, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 
 
-LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
+LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
@@ -633,40 +608,56 @@
   api_incr_top(L);
   luaV_gettable(L, t, L->top - 1, L->top - 1);
   lua_unlock(L);
-}
-
-
-LUA_API void lua_rawget (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  return ttnov(L->top - 1);
+}
+
+
+LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
+  StkId t;
+  lua_lock(L);
+  t = index2addr(L, idx);
+  setivalue(L->top, n);
+  api_incr_top(L);
+  luaV_gettable(L, t, L->top - 1, L->top - 1);
+  lua_unlock(L);
+  return ttnov(L->top - 1);
+}
+
+
+LUA_API int lua_rawget (lua_State *L, int idx) {
+  StkId t;
+  lua_lock(L);
+  t = index2addr(L, idx);
+  api_check(ttistable(t), "table expected");
   setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 
 
-LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
+LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   setobj2s(L, L->top, luaH_getint(hvalue(t), n));
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 
 
-LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) {
+LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
   StkId t;
   TValue k;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   setpvalue(&k, cast(void *, p));
   setobj2s(L, L->top, luaH_get(hvalue(t), &k));
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 
 
@@ -685,11 +676,11 @@
 
 LUA_API int lua_getmetatable (lua_State *L, int objindex) {
   const TValue *obj;
-  Table *mt = NULL;
-  int res;
+  Table *mt;
+  int res = 0;
   lua_lock(L);
   obj = index2addr(L, objindex);
-  switch (ttypenv(obj)) {
+  switch (ttnov(obj)) {
     case LUA_TTABLE:
       mt = hvalue(obj)->metatable;
       break;
@@ -697,12 +688,10 @@
       mt = uvalue(obj)->metatable;
       break;
     default:
-      mt = G(L)->mt[ttypenv(obj)];
+      mt = G(L)->mt[ttnov(obj)];
       break;
   }
-  if (mt == NULL)
-    res = 0;
-  else {
+  if (mt != NULL) {
     sethvalue(L, L->top, mt);
     api_incr_top(L);
     res = 1;
@@ -712,17 +701,15 @@
 }
 
 
-LUA_API void lua_getuservalue (lua_State *L, int idx) {
+LUA_API int lua_getuservalue (lua_State *L, int idx) {
   StkId o;
   lua_lock(L);
   o = index2addr(L, idx);
-  api_check(L, ttisuserdata(o), "userdata expected");
-  if (uvalue(o)->env) {
-    sethvalue(L, L->top, uvalue(o)->env);
-  } else
-    setnilvalue(L->top);
+  api_check(ttisfulluserdata(o), "full userdata expected");
+  getuservalue(L, uvalue(o), L->top);
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 
 
@@ -731,13 +718,13 @@
 */
 
 
-LUA_API void lua_setglobal (lua_State *L, const char *var) {
+LUA_API void lua_setglobal (lua_State *L, const char *name) {
   Table *reg = hvalue(&G(L)->l_registry);
   const TValue *gt;  /* global table */
   lua_lock(L);
   api_checknelems(L, 1);
   gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
-  setsvalue2s(L, L->top++, luaS_new(L, var));
+  setsvalue2s(L, L->top++, luaS_new(L, name));
   luaV_settable(L, gt, L->top - 1, L->top - 2);
   L->top -= 2;  /* pop value and key */
   lua_unlock(L);
@@ -767,43 +754,61 @@
 }
 
 
+LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
+  StkId t;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  t = index2addr(L, idx);
+  setivalue(L->top++, n);
+  luaV_settable(L, t, L->top - 1, L->top - 2);
+  L->top -= 2;  /* pop value and key */
+  lua_unlock(L);
+}
+
+
 LUA_API void lua_rawset (lua_State *L, int idx) {
-  StkId t;
+  StkId o;
+  Table *t;
   lua_lock(L);
   api_checknelems(L, 2);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
-  invalidateTMcache(hvalue(t));
-  luaC_barrierback(L, gcvalue(t), L->top-1);
+  o = index2addr(L, idx);
+  api_check(ttistable(o), "table expected");
+  t = hvalue(o);
+  setobj2t(L, luaH_set(L, t, L->top-2), L->top-1);
+  invalidateTMcache(t);
+  luaC_barrierback(L, t, L->top-1);
   L->top -= 2;
   lua_unlock(L);
 }
 
 
-LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
-  StkId t;
+LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
+  StkId o;
+  Table *t;
   lua_lock(L);
   api_checknelems(L, 1);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  luaH_setint(L, hvalue(t), n, L->top - 1);
-  luaC_barrierback(L, gcvalue(t), L->top-1);
+  o = index2addr(L, idx);
+  api_check(ttistable(o), "table expected");
+  t = hvalue(o);
+  luaH_setint(L, t, n, L->top - 1);
+  luaC_barrierback(L, t, L->top-1);
   L->top--;
   lua_unlock(L);
 }
 
 
 LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
-  StkId t;
+  StkId o;
+  Table *t;
   TValue k;
   lua_lock(L);
   api_checknelems(L, 1);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  o = index2addr(L, idx);
+  api_check(ttistable(o), "table expected");
+  t = hvalue(o);
   setpvalue(&k, cast(void *, p));
-  setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1);
-  luaC_barrierback(L, gcvalue(t), L->top - 1);
+  setobj2t(L, luaH_set(L, t, &k), L->top - 1);
+  luaC_barrierback(L, t, L->top - 1);
   L->top--;
   lua_unlock(L);
 }
@@ -818,14 +823,14 @@
   if (ttisnil(L->top - 1))
     mt = NULL;
   else {
-    api_check(L, ttistable(L->top - 1), "table expected");
+    api_check(ttistable(L->top - 1), "table expected");
     mt = hvalue(L->top - 1);
   }
-  switch (ttypenv(obj)) {
+  switch (ttnov(obj)) {
     case LUA_TTABLE: {
       hvalue(obj)->metatable = mt;
       if (mt) {
-        luaC_objbarrierback(L, gcvalue(obj), mt);
+        luaC_objbarrier(L, gcvalue(obj), mt);
         luaC_checkfinalizer(L, gcvalue(obj), mt);
       }
       break;
@@ -833,13 +838,13 @@
     case LUA_TUSERDATA: {
       uvalue(obj)->metatable = mt;
       if (mt) {
-        luaC_objbarrier(L, rawuvalue(obj), mt);
+        luaC_objbarrier(L, uvalue(obj), mt);
         luaC_checkfinalizer(L, gcvalue(obj), mt);
       }
       break;
     }
     default: {
-      G(L)->mt[ttypenv(obj)] = mt;
+      G(L)->mt[ttnov(obj)] = mt;
       break;
     }
   }
@@ -854,46 +859,32 @@
   lua_lock(L);
   api_checknelems(L, 1);
   o = index2addr(L, idx);
-  api_check(L, ttisuserdata(o), "userdata expected");
-  if (ttisnil(L->top - 1))
-    uvalue(o)->env = NULL;
-  else {
-    api_check(L, ttistable(L->top - 1), "table expected");
-    uvalue(o)->env = hvalue(L->top - 1);
-    luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
-  }
+  api_check(ttisfulluserdata(o), "full userdata expected");
+  setuservalue(L, uvalue(o), L->top - 1);
+  luaC_barrier(L, gcvalue(o), L->top - 1);
   L->top--;
   lua_unlock(L);
 }
 
 
 /*
-** `load' and `call' functions (run Lua code)
+** 'load' and 'call' functions (run Lua code)
 */
 
 
 #define checkresults(L,na,nr) \
-     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
+     api_check((nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
 	"results from function overflow current stack size")
 
 
-LUA_API int lua_getctx (lua_State *L, int *ctx) {
-  if (L->ci->callstatus & CIST_YIELDED) {
-    if (ctx) *ctx = L->ci->u.c.ctx;
-    return L->ci->u.c.status;
-  }
-  else return LUA_OK;
-}
-
-
-LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
-                        lua_CFunction k) {
+LUA_API void lua_callk (lua_State *L, int nargs, int nresults,
+                        lua_KContext ctx, lua_KFunction k) {
   StkId func;
   lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
+  api_check(k == NULL || !isLua(L->ci),
     "cannot use continuations inside hooks");
   api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
+  api_check(L->status == LUA_OK, "cannot do calls on non-normal thread");
   checkresults(L, nargs, nresults);
   func = L->top - (nargs+1);
   if (k != NULL && L->nny == 0) {  /* need to prepare continuation? */
@@ -912,7 +903,7 @@
 /*
 ** Execute a protected call.
 */
-struct CallS {  /* data to `f_call' */
+struct CallS {  /* data to 'f_call' */
   StkId func;
   int nresults;
 };
@@ -926,21 +917,21 @@
 
 
 LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
-                        int ctx, lua_CFunction k) {
+                        lua_KContext ctx, lua_KFunction k) {
   struct CallS c;
   int status;
   ptrdiff_t func;
   lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
+  api_check(k == NULL || !isLua(L->ci),
     "cannot use continuations inside hooks");
   api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
+  api_check(L->status == LUA_OK, "cannot do calls on non-normal thread");
   checkresults(L, nargs, nresults);
   if (errfunc == 0)
     func = 0;
   else {
     StkId o = index2addr(L, errfunc);
-    api_checkstackindex(L, errfunc, o);
+    api_checkstackindex(errfunc, o);
     func = savestack(L, o);
   }
   c.func = L->top - (nargs+1);  /* function to be called */
@@ -954,11 +945,10 @@
     ci->u.c.ctx = ctx;  /* save context */
     /* save information for error recovery */
     ci->extra = savestack(L, c.func);
-    ci->u.c.old_allowhook = L->allowhook;
     ci->u.c.old_errfunc = L->errfunc;
     L->errfunc = func;
-    /* mark that function may do error recovery */
-    ci->callstatus |= CIST_YPCALL;
+    setoah(ci->callstatus, L->allowhook);  /* save value of 'allowhook' */
+    ci->callstatus |= CIST_YPCALL;  /* function can do error recovery */
     luaD_call(L, c.func, nresults, 1);  /* do the call */
     ci->callstatus &= ~CIST_YPCALL;
     L->errfunc = ci->u.c.old_errfunc;
@@ -980,13 +970,13 @@
   status = luaD_protectedparser(L, &z, chunkname, mode);
   if (status == LUA_OK) {  /* no errors? */
     LClosure *f = clLvalue(L->top - 1);  /* get newly created function */
-    if (f->nupvalues == 1) {  /* does it have one upvalue? */
+    if (f->nupvalues >= 1) {  /* does it have an upvalue? */
       /* get global table from registry */
       Table *reg = hvalue(&G(L)->l_registry);
       const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
       /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
       setobj(L, f->upvals[0]->v, gt);
-      luaC_barrier(L, f->upvals[0], gt);
+      luaC_upvalbarrier(L, f->upvals[0]);
     }
   }
   lua_unlock(L);
@@ -994,14 +984,14 @@
 }
 
 
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
+LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {
   int status;
   TValue *o;
   lua_lock(L);
   api_checknelems(L, 1);
   o = L->top - 1;
   if (isLfunction(o))
-    status = luaU_dump(L, getproto(o), writer, data, 0);
+    status = luaU_dump(L, getproto(o), writer, data, strip);
   else
     status = 1;
   lua_unlock(L);
@@ -1047,19 +1037,21 @@
       break;
     }
     case LUA_GCSTEP: {
-      if (g->gckind == KGC_GEN) {  /* generational mode? */
-        res = (g->GCestimate == 0);  /* true if it will do major collection */
-        luaC_forcestep(L);  /* do a single step */
-      }
-      else {
-       lu_mem debt = cast(lu_mem, data) * 1024 - GCSTEPSIZE;
-       if (g->gcrunning)
-         debt += g->GCdebt;  /* include current debt */
-       luaE_setdebt(g, debt);
-       luaC_forcestep(L);
-       if (g->gcstate == GCSpause)  /* end of cycle? */
-         res = 1;  /* signal it */
-      }
+      l_mem debt = 1;  /* =1 to signal that it did an actual step */
+      int oldrunning = g->gcrunning;
+      g->gcrunning = 1;  /* allow GC to run */
+      if (data == 0) {
+        luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */
+        luaC_step(L);
+      }
+      else {  /* add 'data' to total debt */
+        debt = cast(l_mem, data) * 1024 + g->GCdebt;
+        luaE_setdebt(g, debt);
+        luaC_checkGC(L);
+      }
+      g->gcrunning = oldrunning;  /* restore previous state */
+      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */
+        res = 1;  /* signal it */
       break;
     }
     case LUA_GCSETPAUSE: {
@@ -1067,13 +1059,9 @@
       g->gcpause = data;
       break;
     }
-    case LUA_GCSETMAJORINC: {
-      res = g->gcmajorinc;
-      g->gcmajorinc = data;
-      break;
-    }
     case LUA_GCSETSTEPMUL: {
       res = g->gcstepmul;
+      if (data < 40) data = 40;  /* avoid ridiculous low values (and 0) */
       g->gcstepmul = data;
       break;
     }
@@ -1081,14 +1069,6 @@
       res = g->gcrunning;
       break;
     }
-    case LUA_GCGEN: {  /* change collector to generational mode */
-      luaC_changemode(L, KGC_GEN);
-      break;
-    }
-    case LUA_GCINC: {  /* change collector to incremental mode */
-      luaC_changemode(L, KGC_NORMAL);
-      break;
-    }
     default: res = -1;  /* invalid option */
   }
   lua_unlock(L);
@@ -1116,7 +1096,7 @@
   int more;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   more = luaH_next(L, hvalue(t), L->top - 1);
   if (more) {
     api_incr_top(L);
@@ -1176,23 +1156,23 @@
   Udata *u;
   lua_lock(L);
   luaC_checkGC(L);
-  u = luaS_newudata(L, size, NULL);
+  u = luaS_newudata(L, size);
   setuvalue(L, L->top, u);
   api_incr_top(L);
   lua_unlock(L);
-  return u + 1;
+  return getudatamem(u);
 }
 
 
 
 static const char *aux_upvalue (StkId fi, int n, TValue **val,
-                                GCObject **owner) {
+                                CClosure **owner, UpVal **uv) {
   switch (ttype(fi)) {
     case LUA_TCCL: {  /* C closure */
       CClosure *f = clCvalue(fi);
       if (!(1 <= n && n <= f->nupvalues)) return NULL;
       *val = &f->upvalue[n-1];
-      if (owner) *owner = obj2gco(f);
+      if (owner) *owner = f;
       return "";
     }
     case LUA_TLCL: {  /* Lua closure */
@@ -1201,9 +1181,9 @@
       Proto *p = f->p;
       if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
       *val = f->upvals[n-1]->v;
-      if (owner) *owner = obj2gco(f->upvals[n - 1]);
+      if (uv) *uv = f->upvals[n - 1];
       name = p->upvalues[n-1].name;
-      return (name == NULL) ? "" : getstr(name);
+      return (name == NULL) ? "(*no name)" : getstr(name);
     }
     default: return NULL;  /* not a closure */
   }
@@ -1214,7 +1194,7 @@
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
   lua_lock(L);
-  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL);
+  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL);
   if (name) {
     setobj2s(L, L->top, val);
     api_incr_top(L);
@@ -1227,16 +1207,18 @@
 LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
-  GCObject *owner = NULL;  /* to avoid warnings */
+  CClosure *owner = NULL;
+  UpVal *uv = NULL;
   StkId fi;
   lua_lock(L);
   fi = index2addr(L, funcindex);
   api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val, &owner);
+  name = aux_upvalue(fi, n, &val, &owner, &uv);
   if (name) {
     L->top--;
     setobj(L, val, L->top);
-    luaC_barrier(L, owner, L->top);
+    if (owner) { luaC_barrier(L, owner, L->top); }
+    else if (uv) { luaC_upvalbarrier(L, uv); }
   }
   lua_unlock(L);
   return name;
@@ -1246,9 +1228,9 @@
 static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) {
   LClosure *f;
   StkId fi = index2addr(L, fidx);
-  api_check(L, ttisLclosure(fi), "Lua function expected");
+  api_check(ttisLclosure(fi), "Lua function expected");
   f = clLvalue(fi);
-  api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
+  api_check((1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
   if (pf) *pf = f;
   return &f->upvals[n - 1];  /* get its upvalue pointer */
 }
@@ -1262,11 +1244,11 @@
     }
     case LUA_TCCL: {  /* C closure */
       CClosure *f = clCvalue(fi);
-      api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");
+      api_check(1 <= n && n <= f->nupvalues, "invalid upvalue index");
       return &f->upvalue[n - 1];
     }
     default: {
-      api_check(L, 0, "closure expected");
+      api_check(0, "closure expected");
       return NULL;
     }
   }
@@ -1278,7 +1260,11 @@
   LClosure *f1;
   UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
   UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
+  luaC_upvdeccount(L, *up1);
   *up1 = *up2;
-  luaC_objbarrier(L, f1, *up2);
+  (*up1)->refcount++;
+  if (upisopen(*up1)) (*up1)->u.open.touched = 1;
+  luaC_upvalbarrier(L, *up1);
 }
 
+

=== modified file 'src/third_party/eris/lapi.h'
--- src/third_party/eris/lapi.h	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lapi.h	2016-04-10 16:54:20 +0000
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lapi.h,v 2.8 2014/07/15 21:26:50 roberto Exp $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
@@ -11,13 +11,13 @@
 #include "llimits.h"
 #include "lstate.h"
 
-#define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
+#define api_incr_top(L)   {L->top++; api_check(L->top <= L->ci->top, \
 				"stack overflow");}
 
 #define adjustresults(L,nres) \
     { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
 
-#define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \
+#define api_checknelems(L,n)	api_check((n) < (L->top - L->ci->func), \
 				  "not enough elements in the stack")
 
 

=== modified file 'src/third_party/eris/lauxlib.c'
--- src/third_party/eris/lauxlib.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lauxlib.c	2016-04-10 16:54:20 +0000
@@ -1,9 +1,14 @@
 /*
-** $Id: lauxlib.c,v 1.248.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lauxlib.c,v 1.279 2014/12/14 18:32:26 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 
+#define lauxlib_c
+#define LUA_LIB
+
+#include "lprefix.h"
+
 
 #include <errno.h>
 #include <stdarg.h>
@@ -16,9 +21,6 @@
 ** Any function declared here could be written as an application function.
 */
 
-#define lauxlib_c
-#define LUA_LIB
-
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -64,11 +66,20 @@
 }
 
 
+/*
+** Search for a name for a function in all loaded modules
+** (registry._LOADED).
+*/
 static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
   int top = lua_gettop(L);
   lua_getinfo(L, "f", ar);  /* push function */
-  lua_pushglobaltable(L);
+  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
   if (findfield(L, top + 1, 2)) {
+    const char *name = lua_tostring(L, -1);
+    if (strncmp(name, "_G.", 3) == 0) {  /* name start with '_G.'? */
+      lua_pushstring(L, name + 3);  /* push name without prefix */
+      lua_remove(L, -2);  /* remove original name */
+    }
     lua_copy(L, -1, top + 1);  /* move name to proper place */
     lua_pop(L, 2);  /* remove pushed values */
     return 1;
@@ -81,20 +92,18 @@
 
 
 static void pushfuncname (lua_State *L, lua_Debug *ar) {
-  if (*ar->namewhat != '\0')  /* is there a name? */
-    lua_pushfstring(L, "function " LUA_QS, ar->name);
+  if (pushglobalfuncname(L, ar)) {  /* try first a global name */
+    lua_pushfstring(L, "function '%s'", lua_tostring(L, -1));
+    lua_remove(L, -2);  /* remove name */
+  }
+  else if (*ar->namewhat != '\0')  /* is there a name from code? */
+    lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name);  /* use it */
   else if (*ar->what == 'm')  /* main? */
       lua_pushliteral(L, "main chunk");
-  else if (*ar->what == 'C') {
-    if (pushglobalfuncname(L, ar)) {
-      lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
-      lua_remove(L, -2);  /* remove name */
-    }
-    else
-      lua_pushliteral(L, "?");
-  }
-  else
+  else if (*ar->what != 'C')  /* for Lua functions, use <file:line> */
     lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
+  else  /* nothing left... */
+    lua_pushliteral(L, "?");
 }
 
 
@@ -150,33 +159,40 @@
 ** =======================================================
 */
 
-LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
   lua_Debug ar;
   if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
+    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
   lua_getinfo(L, "n", &ar);
   if (strcmp(ar.namewhat, "method") == 0) {
-    narg--;  /* do not count `self' */
-    if (narg == 0)  /* error is in the self argument itself? */
-      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
+    arg--;  /* do not count 'self' */
+    if (arg == 0)  /* error is in the self argument itself? */
+      return luaL_error(L, "calling '%s' on bad self (%s)",
                            ar.name, extramsg);
   }
   if (ar.name == NULL)
     ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
-  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
-                        narg, ar.name, extramsg);
-}
-
-
-static int typeerror (lua_State *L, int narg, const char *tname) {
-  const char *msg = lua_pushfstring(L, "%s expected, got %s",
-                                    tname, luaL_typename(L, narg));
-  return luaL_argerror(L, narg, msg);
-}
-
-
-static void tag_error (lua_State *L, int narg, int tag) {
-  typeerror(L, narg, lua_typename(L, tag));
+  return luaL_error(L, "bad argument #%d to '%s' (%s)",
+                        arg, ar.name, extramsg);
+}
+
+
+static int typeerror (lua_State *L, int arg, const char *tname) {
+  const char *msg;
+  const char *typearg;  /* name for the type of the actual argument */
+  if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
+    typearg = lua_tostring(L, -1);  /* use the given type name */
+  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
+    typearg = "light userdata";  /* special name for messages */
+  else
+    typearg = luaL_typename(L, arg);  /* standard name */
+  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
+  return luaL_argerror(L, arg, msg);
+}
+
+
+static void tag_error (lua_State *L, int arg, int tag) {
+  typeerror(L, arg, lua_typename(L, tag));
 }
 
 
@@ -222,7 +238,7 @@
 }
 
 
-#if !defined(inspectstat)	/* { */
+#if !defined(l_inspectstat)	/* { */
 
 #if defined(LUA_USE_POSIX)
 
@@ -231,13 +247,13 @@
 /*
 ** use appropriate macros to interpret 'pclose' return status
 */
-#define inspectstat(stat,what)  \
+#define l_inspectstat(stat,what)  \
    if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
    else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
 
 #else
 
-#define inspectstat(stat,what)  /* no op */
+#define l_inspectstat(stat,what)  /* no op */
 
 #endif
 
@@ -249,7 +265,7 @@
   if (stat == -1)  /* error? */
     return luaL_fileresult(L, 0, NULL);
   else {
-    inspectstat(stat, what);  /* interpret result */
+    l_inspectstat(stat, what);  /* interpret result */
     if (*what == 'e' && stat == 0)  /* successful termination? */
       lua_pushboolean(L, 1);
     else
@@ -270,11 +286,12 @@
 */
 
 LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
-  luaL_getmetatable(L, tname);  /* try to get metatable */
-  if (!lua_isnil(L, -1))  /* name already in use? */
+  if (luaL_getmetatable(L, tname))  /* name already in use? */
     return 0;  /* leave previous value on top, but return 0 */
   lua_pop(L, 1);
   lua_newtable(L);  /* create metatable */
+  lua_pushstring(L, tname);
+  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
   lua_pushvalue(L, -1);
   lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
   return 1;
@@ -317,16 +334,16 @@
 ** =======================================================
 */
 
-LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
+LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
                                  const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, narg, def) :
-                             luaL_checkstring(L, narg);
+  const char *name = (def) ? luaL_optstring(L, arg, def) :
+                             luaL_checkstring(L, arg);
   int i;
   for (i=0; lst[i]; i++)
     if (strcmp(lst[i], name) == 0)
       return i;
-  return luaL_argerror(L, narg,
-                       lua_pushfstring(L, "invalid option " LUA_QS, name));
+  return luaL_argerror(L, arg,
+                       lua_pushfstring(L, "invalid option '%s'", name));
 }
 
 
@@ -342,77 +359,71 @@
 }
 
 
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
-  if (lua_type(L, narg) != t)
-    tag_error(L, narg, t);
-}
-
-
-LUALIB_API void luaL_checkany (lua_State *L, int narg) {
-  if (lua_type(L, narg) == LUA_TNONE)
-    luaL_argerror(L, narg, "value expected");
-}
-
-
-LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
-  const char *s = lua_tolstring(L, narg, len);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
+LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
+  if (lua_type(L, arg) != t)
+    tag_error(L, arg, t);
+}
+
+
+LUALIB_API void luaL_checkany (lua_State *L, int arg) {
+  if (lua_type(L, arg) == LUA_TNONE)
+    luaL_argerror(L, arg, "value expected");
+}
+
+
+LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
+  const char *s = lua_tolstring(L, arg, len);
+  if (!s) tag_error(L, arg, LUA_TSTRING);
   return s;
 }
 
 
-LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
+LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
                                         const char *def, size_t *len) {
-  if (lua_isnoneornil(L, narg)) {
+  if (lua_isnoneornil(L, arg)) {
     if (len)
       *len = (def ? strlen(def) : 0);
     return def;
   }
-  else return luaL_checklstring(L, narg, len);
-}
-
-
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
-  int isnum;
-  lua_Number d = lua_tonumberx(L, narg, &isnum);
-  if (!isnum)
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, narg, def);
-}
-
-
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
-  int isnum;
-  lua_Integer d = lua_tointegerx(L, narg, &isnum);
-  if (!isnum)
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) {
-  int isnum;
-  lua_Unsigned d = lua_tounsignedx(L, narg, &isnum);
-  if (!isnum)
-    tag_error(L, narg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
+  else return luaL_checklstring(L, arg, len);
+}
+
+
+LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
+  int isnum;
+  lua_Number d = lua_tonumberx(L, arg, &isnum);
+  if (!isnum)
+    tag_error(L, arg, LUA_TNUMBER);
+  return d;
+}
+
+
+LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
+  return luaL_opt(L, luaL_checknumber, arg, def);
+}
+
+
+static void interror (lua_State *L, int arg) {
+  if (lua_isnumber(L, arg))
+    luaL_argerror(L, arg, "number has no integer representation");
+  else
+    tag_error(L, arg, LUA_TNUMBER);
+}
+
+
+LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
+  int isnum;
+  lua_Integer d = lua_tointegerx(L, arg, &isnum);
+  if (!isnum) {
+    interror(L, arg);
+  }
+  return d;
+}
+
+
+LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
                                                       lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, narg, def);
-}
-
-
-LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg,
-                                                        lua_Unsigned def) {
-  return luaL_opt(L, luaL_checkunsigned, narg, def);
+  return luaL_opt(L, luaL_checkinteger, arg, def);
 }
 
 /* }====================================================== */
@@ -523,7 +534,7 @@
   int ref;
   if (lua_isnil(L, -1)) {
     lua_pop(L, 1);  /* remove from stack */
-    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
+    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */
   }
   t = lua_absindex(L, t);
   lua_rawgeti(L, t, freelist);  /* get first free element */
@@ -562,7 +573,7 @@
 typedef struct LoadF {
   int n;  /* number of pre-read characters */
   FILE *f;  /* file being read */
-  char buff[LUAL_BUFFERSIZE];  /* area for reading file */
+  char buff[BUFSIZ];  /* area for reading file */
 } LoadF;
 
 
@@ -655,7 +666,7 @@
   readstatus = ferror(lf.f);
   if (filename) fclose(lf.f);  /* close file (even in case of errors) */
   if (readstatus) {
-    lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
+    lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */
     return errfile(L, "read", fnameindex);
   }
   lua_remove(L, fnameindex);
@@ -698,23 +709,23 @@
 
 LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
   if (!lua_getmetatable(L, obj))  /* no metatable? */
-    return 0;
-  lua_pushstring(L, event);
-  lua_rawget(L, -2);
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 2);  /* remove metatable and metafield */
-    return 0;
-  }
+    return LUA_TNIL;
   else {
-    lua_remove(L, -2);  /* remove only metatable */
-    return 1;
+    int tt;
+    lua_pushstring(L, event);
+    tt = lua_rawget(L, -2);
+    if (tt == LUA_TNIL)  /* is metafield nil? */
+      lua_pop(L, 2);  /* remove metatable and metafield */
+    else
+      lua_remove(L, -2);  /* remove only metatable */
+    return tt;  /* return metafield type */
   }
 }
 
 
 LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
   obj = lua_absindex(L, obj);
-  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
+  if (luaL_getmetafield(L, obj, event) == LUA_TNIL)  /* no metafield? */
     return 0;
   lua_pushvalue(L, obj);
   lua_call(L, 1, 1);
@@ -722,13 +733,13 @@
 }
 
 
-LUALIB_API int luaL_len (lua_State *L, int idx) {
-  int l;
+LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
+  lua_Integer l;
   int isnum;
   lua_len(L, idx);
-  l = (int)lua_tointegerx(L, -1, &isnum);
+  l = lua_tointegerx(L, -1, &isnum);
   if (!isnum)
-    luaL_error(L, "object length is not a number");
+    luaL_error(L, "object length is not an integer");
   lua_pop(L, 1);  /* remove object */
   return l;
 }
@@ -737,7 +748,13 @@
 LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
   if (!luaL_callmeta(L, idx, "__tostring")) {  /* no metafield? */
     switch (lua_type(L, idx)) {
-      case LUA_TNUMBER:
+      case LUA_TNUMBER: {
+        if (lua_isinteger(L, idx))
+          lua_pushfstring(L, "%I", lua_tointeger(L, idx));
+        else
+          lua_pushfstring(L, "%f", lua_tonumber(L, idx));
+        break;
+      }
       case LUA_TSTRING:
         lua_pushvalue(L, idx);
         break;
@@ -772,8 +789,7 @@
     e = strchr(fname, '.');
     if (e == NULL) e = fname + strlen(fname);
     lua_pushlstring(L, fname, e - fname);
-    lua_rawget(L, -2);
-    if (lua_isnil(L, -1)) {  /* no such field? */
+    if (lua_rawget(L, -2) == LUA_TNIL) {  /* no such field? */
       lua_pop(L, 1);  /* remove this nil */
       lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
       lua_pushlstring(L, fname, e - fname);
@@ -810,13 +826,12 @@
 LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
                                  int sizehint) {
   luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);  /* get _LOADED table */
-  lua_getfield(L, -1, modname);  /* get _LOADED[modname] */
-  if (!lua_istable(L, -1)) {  /* not found? */
+  if (lua_getfield(L, -1, modname) != LUA_TTABLE) {  /* no _LOADED[modname]? */
     lua_pop(L, 1);  /* remove previous result */
     /* try global variable (and create one if it does not exist) */
     lua_pushglobaltable(L);
     if (luaL_findtable(L, 0, modname, sizehint) != NULL)
-      luaL_error(L, "name conflict for module " LUA_QS, modname);
+      luaL_error(L, "name conflict for module '%s'", modname);
     lua_pushvalue(L, -1);
     lua_setfield(L, -3, modname);  /* _LOADED[modname] = new table */
   }
@@ -846,7 +861,6 @@
 ** Returns with only the table at the stack.
 */
 LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
-  luaL_checkversion(L);
   luaL_checkstack(L, nup, "too many upvalues");
   for (; l->name != NULL; l++) {  /* fill the table with given functions */
     int i;
@@ -864,8 +878,8 @@
 ** into the stack
 */
 LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
-  lua_getfield(L, idx, fname);
-  if (lua_istable(L, -1)) return 1;  /* table already there */
+  if (lua_getfield(L, idx, fname) == LUA_TTABLE)
+    return 1;  /* table already there */
   else {
     lua_pop(L, 1);  /* remove previous result */
     idx = lua_absindex(L, idx);
@@ -878,22 +892,26 @@
 
 
 /*
-** stripped-down 'require'. Calls 'openf' to open a module,
-** registers the result in 'package.loaded' table and, if 'glb'
-** is true, also registers the result in the global table.
+** Stripped-down 'require': After checking "loaded" table, calls 'openf'
+** to open a module, registers the result in 'package.loaded' table and,
+** if 'glb' is true, also registers the result in the global table.
 ** Leaves resulting module on the top.
 */
 LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                                lua_CFunction openf, int glb) {
-  lua_pushcfunction(L, openf);
-  lua_pushstring(L, modname);  /* argument to open function */
-  lua_call(L, 1, 1);  /* open module */
   luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_pushvalue(L, -2);  /* make copy of module (call result) */
-  lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
-  lua_pop(L, 1);  /* remove _LOADED table */
+  lua_getfield(L, -1, modname);  /* _LOADED[modname] */
+  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
+    lua_pop(L, 1);  /* remove field */
+    lua_pushcfunction(L, openf);
+    lua_pushstring(L, modname);  /* argument to open function */
+    lua_call(L, 1, 1);  /* call 'openf' to open module */
+    lua_pushvalue(L, -1);  /* make copy of module (call result) */
+    lua_setfield(L, -3, modname);  /* _LOADED[modname] = module */
+  }
+  lua_remove(L, -2);  /* remove _LOADED table */
   if (glb) {
-    lua_pushvalue(L, -1);  /* copy of 'mod' */
+    lua_pushvalue(L, -1);  /* copy of module */
     lua_setglobal(L, modname);  /* _G[modname] = module */
   }
 }
@@ -908,7 +926,7 @@
   while ((wild = strstr(s, p)) != NULL) {
     luaL_addlstring(&b, s, wild - s);  /* push prefix */
     luaL_addstring(&b, r);  /* push replacement in place of pattern */
-    s = wild + l;  /* continue after `p' */
+    s = wild + l;  /* continue after 'p' */
   }
   luaL_addstring(&b, s);  /* push last suffix */
   luaL_pushresult(&b);
@@ -928,8 +946,8 @@
 
 
 static int panic (lua_State *L) {
-  luai_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
-                   lua_tostring(L, -1));
+  lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
+                        lua_tostring(L, -1));
   return 0;  /* return to Lua to abort */
 }
 
@@ -941,19 +959,14 @@
 }
 
 
-LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver) {
+LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
   const lua_Number *v = lua_version(L);
+  if (sz != LUAL_NUMSIZES)  /* check numeric types */
+    luaL_error(L, "core and library have incompatible numeric types");
   if (v != lua_version(NULL))
     luaL_error(L, "multiple Lua VMs detected");
   else if (*v != ver)
     luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                   ver, *v);
-  /* check conversions number -> integer types */
-  lua_pushnumber(L, -(lua_Number)0x1234);
-  if (lua_tointeger(L, -1) != -0x1234 ||
-      lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234)
-    luaL_error(L, "bad conversion number->int;"
-                  " must recompile Lua with proper settings");
-  lua_pop(L, 1);
 }
 

=== modified file 'src/third_party/eris/lauxlib.h'
--- src/third_party/eris/lauxlib.h	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lauxlib.h	2016-04-10 16:54:20 +0000
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lauxlib.h,v 1.128 2014/10/29 16:11:17 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -16,7 +16,7 @@
 
 
 
-/* extra error code for `luaL_load' */
+/* extra error code for 'luaL_load' */
 #define LUA_ERRFILE     (LUA_ERRERR+1)
 
 
@@ -26,30 +26,30 @@
 } luaL_Reg;
 
 
-LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
-#define luaL_checkversion(L)	luaL_checkversion_(L, LUA_VERSION_NUM)
+#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
+#define luaL_checkversion(L)  \
+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
 
 LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
 LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
 LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
-LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
-LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
                                                           size_t *l);
-LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
                                           const char *def, size_t *l);
-LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
-LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
 
-LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
-LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
                                           lua_Integer def);
-LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
-LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
-                                            lua_Unsigned def);
 
 LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
-LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
-LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
 
 LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
 LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
@@ -59,7 +59,7 @@
 LUALIB_API void (luaL_where) (lua_State *L, int lvl);
 LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
 
-LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
                                    const char *const lst[]);
 
 LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
@@ -83,7 +83,7 @@
 
 LUALIB_API lua_State *(luaL_newstate) (void);
 
-LUALIB_API int (luaL_len) (lua_State *L, int idx);
+LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
 
 LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
                                                   const char *r);
@@ -108,16 +108,13 @@
 #define luaL_newlibtable(L,l)	\
   lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
 
-#define luaL_newlib(L,l)	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+#define luaL_newlib(L,l)  \
+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
 
-#define luaL_argcheck(L, cond,numarg,extramsg)	\
-		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_argcheck(L, cond,arg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (arg), (extramsg))))
 #define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
 #define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
-#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
-#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
-#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
 
 #define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
 
@@ -207,6 +204,53 @@
 #endif
 
 
+/*
+** {==================================================================
+** "Abstraction Layer" for basic report of messages and errors
+** ===================================================================
+*/
+
+/* print a string */
+#if !defined(lua_writestring)
+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
+#endif
+
+/* print a newline and flush the output */
+#if !defined(lua_writeline)
+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
+#endif
+
+/* print an error message */
+#if !defined(lua_writestringerror)
+#define lua_writestringerror(s,p) \
+        (fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {============================================================
+** Compatibility with deprecated conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
+
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#endif
+/* }============================================================ */
+
+
+
 #endif
 
 

=== modified file 'src/third_party/eris/lbaselib.c'
--- src/third_party/eris/lbaselib.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lbaselib.c	2016-04-10 16:54:20 +0000
@@ -1,9 +1,13 @@
 /*
-** $Id: lbaselib.c,v 1.276.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lbaselib.c,v 1.309 2014/12/10 12:26:42 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 
+#define lbaselib_c
+#define LUA_LIB
+
+#include "lprefix.h"
 
 
 #include <ctype.h>
@@ -11,9 +15,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define lbaselib_c
-#define LUA_LIB
-
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -32,62 +33,74 @@
     lua_call(L, 1, 1);
     s = lua_tolstring(L, -1, &l);  /* get result */
     if (s == NULL)
-      return luaL_error(L,
-         LUA_QL("tostring") " must return a string to " LUA_QL("print"));
-    if (i>1) luai_writestring("\t", 1);
-    luai_writestring(s, l);
+      return luaL_error(L, "'tostring' must return a string to 'print'");
+    if (i>1) lua_writestring("\t", 1);
+    lua_writestring(s, l);
     lua_pop(L, 1);  /* pop result */
   }
-  luai_writeline();
+  lua_writeline();
   return 0;
 }
 
 
 #define SPACECHARS	" \f\n\r\t\v"
 
+static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
+  lua_Unsigned n = 0;
+  int neg = 0;
+  s += strspn(s, SPACECHARS);  /* skip initial spaces */
+  if (*s == '-') { s++; neg = 1; }  /* handle signal */
+  else if (*s == '+') s++;
+  if (!isalnum((unsigned char)*s))  /* no digit? */
+    return NULL;
+  do {
+    int digit = (isdigit((unsigned char)*s)) ? *s - '0'
+                   : toupper((unsigned char)*s) - 'A' + 10;
+    if (digit >= base) return NULL;  /* invalid numeral */
+    n = n * base + digit;
+    s++;
+  } while (isalnum((unsigned char)*s));
+  s += strspn(s, SPACECHARS);  /* skip trailing spaces */
+  *pn = (lua_Integer)((neg) ? (0u - n) : n);
+  return s;
+}
+
+
 static int luaB_tonumber (lua_State *L) {
-  if (lua_isnoneornil(L, 2)) {  /* standard conversion */
-    int isnum;
-    lua_Number n = lua_tonumberx(L, 1, &isnum);
-    if (isnum) {
-      lua_pushnumber(L, n);
-      return 1;
-    }  /* else not a number; must be something */
+  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */
     luaL_checkany(L, 1);
+    if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */
+      lua_settop(L, 1);  /* yes; return it */
+      return 1;
+    }
+    else {
+      size_t l;
+      const char *s = lua_tolstring(L, 1, &l);
+      if (s != NULL && lua_stringtonumber(L, s) == l + 1)
+        return 1;  /* successful conversion to number */
+      /* else not a number */
+    }
   }
   else {
     size_t l;
-    const char *s = luaL_checklstring(L, 1, &l);
-    const char *e = s + l;  /* end point for 's' */
-    int base = luaL_checkint(L, 2);
-    int neg = 0;
+    const char *s;
+    lua_Integer n = 0;  /* to avoid warnings */
+    lua_Integer base = luaL_checkinteger(L, 2);
+    luaL_checktype(L, 1, LUA_TSTRING);  /* before 'luaL_checklstring'! */
+    s = luaL_checklstring(L, 1, &l);
     luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    s += strspn(s, SPACECHARS);  /* skip initial spaces */
-    if (*s == '-') { s++; neg = 1; }  /* handle signal */
-    else if (*s == '+') s++;
-    if (isalnum((unsigned char)*s)) {
-      lua_Number n = 0;
-      do {
-        int digit = (isdigit((unsigned char)*s)) ? *s - '0'
-                       : toupper((unsigned char)*s) - 'A' + 10;
-        if (digit >= base) break;  /* invalid numeral; force a fail */
-        n = n * (lua_Number)base + (lua_Number)digit;
-        s++;
-      } while (isalnum((unsigned char)*s));
-      s += strspn(s, SPACECHARS);  /* skip trailing spaces */
-      if (s == e) {  /* no invalid trailing characters? */
-        lua_pushnumber(L, (neg) ? -n : n);
-        return 1;
-      }  /* else not a number */
+    if (b_str2int(s, (int)base, &n) == s + l) {
+      lua_pushinteger(L, n);
+      return 1;
     }  /* else not a number */
-  }
+  }  /* else not a number */
   lua_pushnil(L);  /* not a number */
   return 1;
 }
 
 
 static int luaB_error (lua_State *L) {
-  int level = luaL_optint(L, 2, 1);
+  int level = (int)luaL_optinteger(L, 2, 1);
   lua_settop(L, 1);
   if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
     luaL_where(L, level);
@@ -114,7 +127,7 @@
   luaL_checktype(L, 1, LUA_TTABLE);
   luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                     "nil or table expected");
-  if (luaL_getmetafield(L, 1, "__metatable"))
+  if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)
     return luaL_error(L, "cannot change a protected metatable");
   lua_settop(L, 2);
   lua_setmetatable(L, 1);
@@ -160,19 +173,18 @@
 static int luaB_collectgarbage (lua_State *L) {
   static const char *const opts[] = {"stop", "restart", "collect",
     "count", "step", "setpause", "setstepmul",
-    "setmajorinc", "isrunning", "generational", "incremental", NULL};
+    "isrunning", NULL};
   static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
     LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
-    LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
+    LUA_GCISRUNNING};
   int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
-  int ex = luaL_optint(L, 2, 0);
+  int ex = (int)luaL_optinteger(L, 2, 0);
   int res = lua_gc(L, o, ex);
   switch (o) {
     case LUA_GCCOUNT: {
       int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, res + ((lua_Number)b/1024));
-      lua_pushinteger(L, b);
-      return 2;
+      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
+      return 1;
     }
     case LUA_GCSTEP: case LUA_GCISRUNNING: {
       lua_pushboolean(L, res);
@@ -186,16 +198,19 @@
 }
 
 
+/*
+** This function has all type names as upvalues, to maximize performance.
+*/
 static int luaB_type (lua_State *L) {
   luaL_checkany(L, 1);
-  lua_pushstring(L, luaL_typename(L, 1));
+  lua_pushvalue(L, lua_upvalueindex(lua_type(L, 1) + 1));
   return 1;
 }
 
 
 static int pairsmeta (lua_State *L, const char *method, int iszero,
                       lua_CFunction iter) {
-  if (!luaL_getmetafield(L, 1, method)) {  /* no metamethod? */
+  if (luaL_getmetafield(L, 1, method) == LUA_TNIL) {  /* no metamethod? */
     luaL_checktype(L, 1, LUA_TTABLE);  /* argument must be a table */
     lua_pushcfunction(L, iter);  /* will return generator, */
     lua_pushvalue(L, 1);  /* state, */
@@ -227,18 +242,44 @@
 }
 
 
+/*
+** Traversal function for 'ipairs' for raw tables
+*/
+static int ipairsaux_raw (lua_State *L) {
+  lua_Integer i = luaL_checkinteger(L, 2) + 1;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushinteger(L, i);
+  return (lua_rawgeti(L, 1, i) == LUA_TNIL) ? 1 : 2;
+}
+
+
+/*
+** Traversal function for 'ipairs' for tables with metamethods
+*/
 static int ipairsaux (lua_State *L) {
-  int i = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i++;  /* next value */
+  lua_Integer i = luaL_checkinteger(L, 2) + 1;
   lua_pushinteger(L, i);
-  lua_rawgeti(L, 1, i);
-  return (lua_isnil(L, -1)) ? 1 : 2;
+  return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
 }
 
 
+/*
+** This function will use either 'ipairsaux' or 'ipairsaux_raw' to
+** traverse a table, depending on whether the table has metamethods
+** that can affect the traversal.
+*/
 static int luaB_ipairs (lua_State *L) {
-  return pairsmeta(L, "__ipairs", 1, ipairsaux);
+  lua_CFunction iter = (luaL_getmetafield(L, 1, "__index") != LUA_TNIL)
+                       ? ipairsaux : ipairsaux_raw;
+#if defined(LUA_COMPAT_IPAIRS)
+  return pairsmeta(L, "__ipairs", 1, iter);
+#else
+  luaL_checkany(L, 1);
+  lua_pushcfunction(L, iter);  /* iteration function */
+  lua_pushvalue(L, 1);  /* state */
+  lua_pushinteger(L, 0);  /* initial value */
+  return 3;
+#endif
 }
 
 
@@ -284,7 +325,7 @@
 
 
 /*
-** Reader for generic `load' function: `lua_load' uses the
+** Reader for generic 'load' function: 'lua_load' uses the
 ** stack for internal stuff, so the reader cannot change the
 ** stack top. Instead, it keeps its resulting string in a
 ** reserved slot inside the stack.
@@ -328,7 +369,8 @@
 /* }====================================================== */
 
 
-static int dofilecont (lua_State *L) {
+static int dofilecont (lua_State *L, int d1, lua_KContext d2) {
+  (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */
   return lua_gettop(L) - 1;
 }
 
@@ -339,14 +381,20 @@
   if (luaL_loadfile(L, fname) != LUA_OK)
     return lua_error(L);
   lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
-  return dofilecont(L);
+  return dofilecont(L, 0, 0);
 }
 
 
 static int luaB_assert (lua_State *L) {
-  if (!lua_toboolean(L, 1))
-    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
-  return lua_gettop(L);
+  if (lua_toboolean(L, 1))  /* condition is true? */
+    return lua_gettop(L);  /* return all arguments */
+  else {  /* error */
+    luaL_checkany(L, 1);  /* there must be a condition */
+    lua_remove(L, 1);  /* remove it */
+    lua_pushliteral(L, "assertion failed!");  /* default message */
+    lua_settop(L, 1);  /* leave only message (default if no other one) */
+    return luaB_error(L);  /* call 'error' */
+  }
 }
 
 
@@ -357,53 +405,57 @@
     return 1;
   }
   else {
-    int i = luaL_checkint(L, 1);
+    lua_Integer i = luaL_checkinteger(L, 1);
     if (i < 0) i = n + i;
     else if (i > n) i = n;
     luaL_argcheck(L, 1 <= i, 1, "index out of range");
-    return n - i;
+    return n - (int)i;
   }
 }
 
 
-static int finishpcall (lua_State *L, int status) {
-  if (!lua_checkstack(L, 1)) {  /* no space for extra boolean? */
-    lua_settop(L, 0);  /* create space for return values */
-    lua_pushboolean(L, 0);
-    lua_pushstring(L, "stack overflow");
+/*
+** Continuation function for 'pcall' and 'xpcall'. Both functions
+** already pushed a 'true' before doing the call, so in case of success
+** 'finishpcall' only has to return everything in the stack minus
+** 'extra' values (where 'extra' is exactly the number of items to be
+** ignored).
+*/
+static int finishpcall (lua_State *L, int status, lua_KContext extra) {
+  if (status != LUA_OK && status != LUA_YIELD) {  /* error? */
+    lua_pushboolean(L, 0);  /* first result (false) */
+    lua_pushvalue(L, -2);  /* error message */
     return 2;  /* return false, msg */
   }
-  lua_pushboolean(L, status);  /* first result (status) */
-  lua_replace(L, 1);  /* put first result in first slot */
-  return lua_gettop(L);
-}
-
-
-static int pcallcont (lua_State *L) {
-  int status = lua_getctx(L, NULL);
-  return finishpcall(L, (status == LUA_YIELD));
+  else
+    return lua_gettop(L) - (int)extra;  /* return all results */
 }
 
 
 static int luaB_pcall (lua_State *L) {
   int status;
   luaL_checkany(L, 1);
-  lua_pushnil(L);
-  lua_insert(L, 1);  /* create space for status result */
-  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont);
-  return finishpcall(L, (status == LUA_OK));
+  lua_pushboolean(L, 1);  /* first result if no errors */
+  lua_insert(L, 1);  /* put it in place */
+  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
+  return finishpcall(L, status, 0);
 }
 
 
+/*
+** Do a protected call with error handling. After 'lua_rotate', the
+** stack will have <f, err, true, f, [args...]>; so, the function passes
+** 2 to 'finishpcall' to skip the 2 first values when returning results.
+*/
 static int luaB_xpcall (lua_State *L) {
   int status;
   int n = lua_gettop(L);
-  luaL_argcheck(L, n >= 2, 2, "value expected");
-  lua_pushvalue(L, 1);  /* exchange function... */
-  lua_copy(L, 2, 1);  /* ...and error handler */
-  lua_replace(L, 2);
-  status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont);
-  return finishpcall(L, (status == LUA_OK));
+  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
+  lua_pushboolean(L, 1);  /* first result */
+  lua_pushvalue(L, 1);  /* function */
+  lua_rotate(L, 3, 2);  /* move them below function's arguments */
+  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
+  return finishpcall(L, status, 2);
 }
 
 
@@ -438,21 +490,31 @@
   {"setmetatable", luaB_setmetatable},
   {"tonumber", luaB_tonumber},
   {"tostring", luaB_tostring},
-  {"type", luaB_type},
   {"xpcall", luaB_xpcall},
+  /* placeholders */
+  {"type", NULL},
+  {"_G", NULL},
+  {"_VERSION", NULL},
   {NULL, NULL}
 };
 
 
 LUAMOD_API int luaopen_base (lua_State *L) {
+  int i;
+  /* open lib into global table */
+  lua_pushglobaltable(L);
+  luaL_setfuncs(L, base_funcs, 0);
   /* set global _G */
-  lua_pushglobaltable(L);
-  lua_pushglobaltable(L);
+  lua_pushvalue(L, -1);
   lua_setfield(L, -2, "_G");
-  /* open lib into global table */
-  luaL_setfuncs(L, base_funcs, 0);
+  /* set global _VERSION */
   lua_pushliteral(L, LUA_VERSION);
-  lua_setfield(L, -2, "_VERSION");  /* set global _VERSION */
+  lua_setfield(L, -2, "_VERSION");
+  /* set function 'type' with proper upvalues */
+  for (i = 0; i < LUA_NUMTAGS; i++)  /* push all type names as upvalues */
+    lua_pushstring(L, lua_typename(L, i));
+  lua_pushcclosure(L, luaB_type, LUA_NUMTAGS);
+  lua_setfield(L, -2, "type");
   return 1;
 }
 
@@ -461,33 +523,46 @@
   luaL_checktype(L, -1, LUA_TTABLE);
   luaL_checkstack(L, 2, NULL);
 
-  if (forUnpersist) {
-    lua_pushstring(L, "__eris.baselib_pcallcont");
-    lua_pushcfunction(L, pcallcont);
-  }
-  else {
-    lua_pushcfunction(L, pcallcont);
-    lua_pushstring(L, "__eris.baselib_pcallcont");
-  }
-  lua_rawset(L, -3);
-
-  if (forUnpersist) {
-    lua_pushstring(L, "__eris.baselib_luaB_next");
-    lua_pushcfunction(L, luaB_next);
-  }
-  else {
-    lua_pushcfunction(L, luaB_next);
-    lua_pushstring(L, "__eris.baselib_luaB_next");
-  }
-  lua_rawset(L, -3);
-
-  if (forUnpersist) {
-    lua_pushstring(L, "__eris.baselib_ipairsaux");
-    lua_pushcfunction(L, ipairsaux);
-  }
-  else {
-    lua_pushcfunction(L, ipairsaux);
-    lua_pushstring(L, "__eris.baselib_ipairsaux");
+  /* NOTE: This is a terrible, terrible hack. We push a continuation function
+   * as a normal C function. We kinda have to, though, to allow proper lookup
+   * in the ref table, and it is never ever called, so we get away with it. */
+  if (forUnpersist) {
+    lua_pushstring(L, "__eris.baselib_finishpcall");
+    lua_pushcfunction(L, (lua_CFunction)finishpcall);
+  }
+  else {
+    lua_pushcfunction(L, (lua_CFunction)finishpcall);
+    lua_pushstring(L, "__eris.baselib_finishpcall");
+  }
+  lua_rawset(L, -3);
+
+  if (forUnpersist) {
+    lua_pushstring(L, "__eris.baselib_luaB_next");
+    lua_pushcfunction(L, luaB_next);
+  }
+  else {
+    lua_pushcfunction(L, luaB_next);
+    lua_pushstring(L, "__eris.baselib_luaB_next");
+  }
+  lua_rawset(L, -3);
+
+  if (forUnpersist) {
+    lua_pushstring(L, "__eris.baselib_ipairsaux");
+    lua_pushcfunction(L, ipairsaux);
+  }
+  else {
+    lua_pushcfunction(L, ipairsaux);
+    lua_pushstring(L, "__eris.baselib_ipairsaux");
+  }
+  lua_rawset(L, -3);
+
+  if (forUnpersist) {
+    lua_pushstring(L, "__eris.baselib_ipairsaux_raw");
+    lua_pushcfunction(L, ipairsaux_raw);
+  }
+  else {
+    lua_pushcfunction(L, ipairsaux_raw);
+    lua_pushstring(L, "__eris.baselib_ipairsaux_raw");
   }
   lua_rawset(L, -3);
 }

=== modified file 'src/third_party/eris/lbitlib.c'
--- src/third_party/eris/lbitlib.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lbitlib.c	2016-04-10 16:54:20 +0000
@@ -1,5 +1,5 @@
 /*
-** $Id: lbitlib.c,v 1.18.1.2 2013/07/09 18:01:41 roberto Exp $
+** $Id: lbitlib.c,v 1.28 2014/11/02 19:19:04 roberto Exp $
 ** Standard library for bitwise operations
 ** See Copyright Notice in lua.h
 */
@@ -7,20 +7,32 @@
 #define lbitlib_c
 #define LUA_LIB
 
+#include "lprefix.h"
+
+
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
+#if defined(LUA_COMPAT_BITLIB)		/* { */
+
+
 /* number of bits to consider in a number */
 #if !defined(LUA_NBITS)
 #define LUA_NBITS	32
 #endif
 
 
+/*
+** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
+** be made in two parts to avoid problems when LUA_NBITS is equal to the
+** number of bits in a lua_Unsigned.)
+*/
 #define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
 
+
 /* macro to trim extra bits */
 #define trim(x)		((x) & ALLONES)
 
@@ -29,13 +41,10 @@
 #define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
 
 
-typedef lua_Unsigned b_uint;
-
-
-
-static b_uint andaux (lua_State *L) {
+
+static lua_Unsigned andaux (lua_State *L) {
   int i, n = lua_gettop(L);
-  b_uint r = ~(b_uint)0;
+  lua_Unsigned r = ~(lua_Unsigned)0;
   for (i = 1; i <= n; i++)
     r &= luaL_checkunsigned(L, i);
   return trim(r);
@@ -43,14 +52,14 @@
 
 
 static int b_and (lua_State *L) {
-  b_uint r = andaux(L);
+  lua_Unsigned r = andaux(L);
   lua_pushunsigned(L, r);
   return 1;
 }
 
 
 static int b_test (lua_State *L) {
-  b_uint r = andaux(L);
+  lua_Unsigned r = andaux(L);
   lua_pushboolean(L, r != 0);
   return 1;
 }
@@ -58,7 +67,7 @@
 
 static int b_or (lua_State *L) {
   int i, n = lua_gettop(L);
-  b_uint r = 0;
+  lua_Unsigned r = 0;
   for (i = 1; i <= n; i++)
     r |= luaL_checkunsigned(L, i);
   lua_pushunsigned(L, trim(r));
@@ -68,7 +77,7 @@
 
 static int b_xor (lua_State *L) {
   int i, n = lua_gettop(L);
-  b_uint r = 0;
+  lua_Unsigned r = 0;
   for (i = 1; i <= n; i++)
     r ^= luaL_checkunsigned(L, i);
   lua_pushunsigned(L, trim(r));
@@ -77,13 +86,13 @@
 
 
 static int b_not (lua_State *L) {
-  b_uint r = ~luaL_checkunsigned(L, 1);
+  lua_Unsigned r = ~luaL_checkunsigned(L, 1);
   lua_pushunsigned(L, trim(r));
   return 1;
 }
 
 
-static int b_shift (lua_State *L, b_uint r, int i) {
+static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {
   if (i < 0) {  /* shift right? */
     i = -i;
     r = trim(r);
@@ -101,33 +110,33 @@
 
 
 static int b_lshift (lua_State *L) {
-  return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2));
+  return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkinteger(L, 2));
 }
 
 
 static int b_rshift (lua_State *L) {
-  return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2));
+  return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkinteger(L, 2));
 }
 
 
 static int b_arshift (lua_State *L) {
-  b_uint r = luaL_checkunsigned(L, 1);
-  int i = luaL_checkint(L, 2);
-  if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1))))
+  lua_Unsigned r = luaL_checkunsigned(L, 1);
+  lua_Integer i = luaL_checkinteger(L, 2);
+  if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
     return b_shift(L, r, -i);
   else {  /* arithmetic shift for 'negative' number */
     if (i >= LUA_NBITS) r = ALLONES;
     else
-      r = trim((r >> i) | ~(~(b_uint)0 >> i));  /* add signal bit */
+      r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i));  /* add signal bit */
     lua_pushunsigned(L, r);
     return 1;
   }
 }
 
 
-static int b_rot (lua_State *L, int i) {
-  b_uint r = luaL_checkunsigned(L, 1);
-  i &= (LUA_NBITS - 1);  /* i = i % NBITS */
+static int b_rot (lua_State *L, lua_Integer d) {
+  lua_Unsigned r = luaL_checkunsigned(L, 1);
+  int i = d & (LUA_NBITS - 1);  /* i = d % NBITS */
   r = trim(r);
   if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
     r = (r << i) | (r >> (LUA_NBITS - i));
@@ -137,12 +146,12 @@
 
 
 static int b_lrot (lua_State *L) {
-  return b_rot(L, luaL_checkint(L, 2));
+  return b_rot(L, luaL_checkinteger(L, 2));
 }
 
 
 static int b_rrot (lua_State *L) {
-  return b_rot(L, -luaL_checkint(L, 2));
+  return b_rot(L, -luaL_checkinteger(L, 2));
 }
 
 
@@ -153,20 +162,20 @@
 ** 'width' being used uninitialized.)
 */
 static int fieldargs (lua_State *L, int farg, int *width) {
-  int f = luaL_checkint(L, farg);
-  int w = luaL_optint(L, farg + 1, 1);
+  lua_Integer f = luaL_checkinteger(L, farg);
+  lua_Integer w = luaL_optinteger(L, farg + 1, 1);
   luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
   luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
   if (f + w > LUA_NBITS)
     luaL_error(L, "trying to access non-existent bits");
-  *width = w;
-  return f;
+  *width = (int)w;
+  return (int)f;
 }
 
 
 static int b_extract (lua_State *L) {
   int w;
-  b_uint r = luaL_checkunsigned(L, 1);
+  lua_Unsigned r = trim(luaL_checkunsigned(L, 1));
   int f = fieldargs(L, 2, &w);
   r = (r >> f) & mask(w);
   lua_pushunsigned(L, r);
@@ -176,8 +185,8 @@
 
 static int b_replace (lua_State *L) {
   int w;
-  b_uint r = luaL_checkunsigned(L, 1);
-  b_uint v = luaL_checkunsigned(L, 2);
+  lua_Unsigned r = trim(luaL_checkunsigned(L, 1));
+  lua_Unsigned v = luaL_checkunsigned(L, 2);
   int f = fieldargs(L, 3, &w);
   int m = mask(w);
   v &= m;  /* erase bits outside given width */
@@ -210,3 +219,12 @@
   return 1;
 }
 
+
+#else					/* }{ */
+
+
+LUAMOD_API int luaopen_bit32 (lua_State *L) {
+  return luaL_error(L, "library 'bit32' has been deprecated");
+}
+
+#endif					/* } */

=== modified file 'src/third_party/eris/lcode.c'
--- src/third_party/eris/lcode.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lcode.c	2016-04-10 16:54:20 +0000
@@ -1,15 +1,18 @@
 /*
-** $Id: lcode.c,v 2.62.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lcode.c,v 2.99 2014/12/29 16:49:25 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 
-
-#include <stdlib.h>
-
 #define lcode_c
 #define LUA_CORE
 
+#include "lprefix.h"
+
+
+#include <math.h>
+#include <stdlib.h>
+
 #include "lua.h"
 
 #include "lcode.h"
@@ -26,11 +29,25 @@
 #include "lvm.h"
 
 
+/* Maximum number of registers in a Lua function */
+#define MAXREGS		250
+
+
 #define hasjumps(e)	((e)->t != (e)->f)
 
 
-static int isnumeral(expdesc *e) {
-  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
+static int tonumeral(expdesc *e, TValue *v) {
+  if (e->t != NO_JUMP || e->f != NO_JUMP)
+    return 0;  /* not a numeral */
+  switch (e->k) {
+    case VKINT:
+      if (v) setivalue(v, e->u.ival);
+      return 1;
+    case VKFLT:
+      if (v) setfltvalue(v, e->u.nval);
+      return 1;
+    default: return 0;
+  }
 }
 
 
@@ -88,7 +105,7 @@
 
 
 /*
-** returns current `pc' and marks it as a jump target (to avoid wrong
+** returns current 'pc' and marks it as a jump target (to avoid wrong
 ** optimizations with consecutive instructions not in the same basic block).
 */
 int luaK_getlabel (FuncState *fs) {
@@ -176,7 +193,7 @@
 }
 
 
-LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) {
+void luaK_patchclose (FuncState *fs, int list, int level) {
   level++;  /* argument is +1 to reserve 0 as non-op */
   while (list != NO_JUMP) {
     int next = getjump(fs, list);
@@ -211,7 +228,7 @@
 
 static int luaK_code (FuncState *fs, Instruction i) {
   Proto *f = fs->f;
-  dischargejpc(fs);  /* `pc' will change */
+  dischargejpc(fs);  /* 'pc' will change */
   /* put new instruction in code array */
   luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
                   MAX_INT, "opcodes");
@@ -261,7 +278,7 @@
 void luaK_checkstack (FuncState *fs, int n) {
   int newstack = fs->freereg + n;
   if (newstack > fs->f->maxstacksize) {
-    if (newstack >= MAXSTACK)
+    if (newstack >= MAXREGS)
       luaX_syntaxerror(fs->ls, "function or expression too complex");
     fs->f->maxstacksize = cast_byte(newstack);
   }
@@ -288,25 +305,28 @@
 }
 
 
+/*
+** Use scanner's table to cache position of constants in constant list
+** and try to reuse constants
+*/
 static int addk (FuncState *fs, TValue *key, TValue *v) {
   lua_State *L = fs->ls->L;
-  TValue *idx = luaH_set(L, fs->h, key);
   Proto *f = fs->f;
+  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
   int k, oldsize;
-  if (ttisnumber(idx)) {
-    lua_Number n = nvalue(idx);
-    lua_number2int(k, n);
-    if (luaV_rawequalobj(&f->k[k], v))
-      return k;
-    /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
-       go through and create a new entry for this value */
+  if (ttisinteger(idx)) {  /* is there an index there? */
+    k = cast_int(ivalue(idx));
+    /* correct value? (warning: must distinguish floats from integers!) */
+    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
+                      luaV_rawequalobj(&f->k[k], v))
+      return k;  /* reuse index */
   }
   /* constant not found; create a new entry */
   oldsize = f->sizek;
   k = fs->nk;
   /* numerical value does not need GC barrier;
      table has no metatable, so it does not need to invalidate cache */
-  setnvalue(idx, cast_num(k));
+  setivalue(idx, k);
   luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
   while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
   setobj(L, &f->k[k], v);
@@ -323,20 +343,23 @@
 }
 
 
-int luaK_numberK (FuncState *fs, lua_Number r) {
-  int n;
-  lua_State *L = fs->ls->L;
+/*
+** Integers use userdata as keys to avoid collision with floats with same
+** value; conversion to 'void*' used only for hashing, no "precision"
+** problems
+*/
+int luaK_intK (FuncState *fs, lua_Integer n) {
+  TValue k, o;
+  setpvalue(&k, cast(void*, cast(size_t, n)));
+  setivalue(&o, n);
+  return addk(fs, &k, &o);
+}
+
+
+static int luaK_numberK (FuncState *fs, lua_Number r) {
   TValue o;
-  setnvalue(&o, r);
-  if (r == 0 || luai_numisnan(NULL, r)) {  /* handle -0 and NaN */
-    /* use raw representation as key to avoid numeric problems */
-    setsvalue(L, L->top++, luaS_newlstr(L, (char *)&r, sizeof(r)));
-    n = addk(fs, L->top - 1, &o);
-    L->top--;
-  }
-  else
-    n = addk(fs, &o, &o);  /* regular case */
-  return n;
+  setfltvalue(&o, r);
+  return addk(fs, &o, &o);
 }
 
 
@@ -351,7 +374,7 @@
   TValue k, v;
   setnilvalue(&v);
   /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->ls->L, &k, fs->h);
+  sethvalue(fs->ls->L, &k, fs->ls->h);
   return addk(fs, &k, &v);
 }
 
@@ -433,10 +456,14 @@
       luaK_codek(fs, reg, e->u.info);
       break;
     }
-    case VKNUM: {
+    case VKFLT: {
       luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
       break;
     }
+    case VKINT: {
+      luaK_codek(fs, reg, luaK_intK(fs, e->u.ival));
+      break;
+    }
     case VRELOCABLE: {
       Instruction *pc = &getcode(fs, e);
       SETARG_A(*pc, reg);
@@ -468,7 +495,7 @@
 static void exp2reg (FuncState *fs, expdesc *e, int reg) {
   discharge2reg(fs, e, reg);
   if (e->k == VJMP)
-    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in `t' list */
+    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in 't' list */
   if (hasjumps(e)) {
     int final;  /* position after whole expression */
     int p_f = NO_JUMP;  /* position of an eventual LOAD false */
@@ -538,13 +565,19 @@
       }
       else break;
     }
-    case VKNUM: {
+    case VKINT: {
+      e->u.info = luaK_intK(fs, e->u.ival);
+      e->k = VK;
+      goto vk;
+    }
+    case VKFLT: {
       e->u.info = luaK_numberK(fs, e->u.nval);
       e->k = VK;
       /* go through */
     }
     case VK: {
-      if (e->u.info <= MAXINDEXRK)  /* constant fits in argC? */
+     vk:
+      if (e->u.info <= MAXINDEXRK)  /* constant fits in 'argC'? */
         return RKASK(e->u.info);
       else break;
     }
@@ -627,7 +660,7 @@
       pc = e->u.info;
       break;
     }
-    case VK: case VKNUM: case VTRUE: {
+    case VK: case VKFLT: case VKINT: case VTRUE: {
       pc = NO_JUMP;  /* always true; do nothing */
       break;
     }
@@ -636,7 +669,7 @@
       break;
     }
   }
-  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
+  luaK_concat(fs, &e->f, pc);  /* insert last jump in 'f' list */
   luaK_patchtohere(fs, e->t);
   e->t = NO_JUMP;
 }
@@ -659,7 +692,7 @@
       break;
     }
   }
-  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
+  luaK_concat(fs, &e->t, pc);  /* insert last jump in 't' list */
   luaK_patchtohere(fs, e->f);
   e->f = NO_JUMP;
 }
@@ -672,7 +705,7 @@
       e->k = VTRUE;
       break;
     }
-    case VK: case VKNUM: case VTRUE: {
+    case VK: case VKFLT: case VKINT: case VTRUE: {
       e->k = VFALSE;
       break;
     }
@@ -710,25 +743,70 @@
 }
 
 
-static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
-  lua_Number r;
-  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
-  if ((op == OP_DIV || op == OP_MOD) && e2->u.nval == 0)
-    return 0;  /* do not attempt to divide by 0 */
-  r = luaO_arith(op - OP_ADD + LUA_OPADD, e1->u.nval, e2->u.nval);
-  e1->u.nval = r;
+/*
+** return false if folding can raise an error
+*/
+static int validop (int op, TValue *v1, TValue *v2) {
+  switch (op) {
+    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
+    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */
+      lua_Integer i;
+      return (tointeger(v1, &i) && tointeger(v2, &i));
+    }
+    case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */
+      return (nvalue(v2) != 0);
+    default: return 1;  /* everything else is valid */
+  }
+}
+
+
+/*
+** Try to "constant-fold" an operation; return 1 iff successful
+*/
+static int constfolding (FuncState *fs, int op, expdesc *e1, expdesc *e2) {
+  TValue v1, v2, res;
+  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
+    return 0;  /* non-numeric operands or not safe to fold */
+  luaO_arith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */
+  if (ttisinteger(&res)) {
+    e1->k = VKINT;
+    e1->u.ival = ivalue(&res);
+  }
+  else {  /* folds neither NaN nor 0.0 (to avoid collapsing with -0.0) */
+    lua_Number n = fltvalue(&res);
+    if (luai_numisnan(n) || n == 0)
+      return 0;
+    e1->k = VKFLT;
+    e1->u.nval = n;
+  }
   return 1;
 }
 
 
-static void codearith (FuncState *fs, OpCode op,
-                       expdesc *e1, expdesc *e2, int line) {
-  if (constfolding(op, e1, e2))
-    return;
+/*
+** Code for binary and unary expressions that "produce values"
+** (arithmetic operations, bitwise operations, concat, length). First
+** try to do constant folding (only for numeric [arithmetic and
+** bitwise] operations, which is what 'lua_arith' accepts).
+** Expression to produce final result will be encoded in 'e1'.
+*/
+static void codeexpval (FuncState *fs, OpCode op,
+                        expdesc *e1, expdesc *e2, int line) {
+  lua_assert(op >= OP_ADD);
+  if (op <= OP_BNOT && constfolding(fs, op - OP_ADD + LUA_OPADD, e1, e2))
+    return;  /* result has been folded */
   else {
-    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
-    int o1 = luaK_exp2RK(fs, e1);
-    if (o1 > o2) {
+    int o1, o2;
+    /* move operands to registers (if needed) */
+    if (op == OP_UNM || op == OP_BNOT || op == OP_LEN) {  /* unary op? */
+      o2 = 0;  /* no second expression */
+      o1 = luaK_exp2anyreg(fs, e1);  /* cannot operate on constants */
+    }
+    else {  /* regular case (binary operators) */
+      o2 = luaK_exp2RK(fs, e2);  /* both operands are "RK" */
+      o1 = luaK_exp2RK(fs, e1);
+    }
+    if (o1 > o2) {  /* free registers in proper order */
       freeexp(fs, e1);
       freeexp(fs, e2);
     }
@@ -736,8 +814,8 @@
       freeexp(fs, e2);
       freeexp(fs, e1);
     }
-    e1->u.info = luaK_codeABC(fs, op, 0, o1, o2);
-    e1->k = VRELOCABLE;
+    e1->u.info = luaK_codeABC(fs, op, 0, o1, o2);  /* generate opcode */
+    e1->k = VRELOCABLE;  /* all those operations are relocable */
     luaK_fixline(fs, line);
   }
 }
@@ -750,7 +828,7 @@
   freeexp(fs, e2);
   freeexp(fs, e1);
   if (cond == 0 && op != OP_EQ) {
-    int temp;  /* exchange args to replace by `<' or `<=' */
+    int temp;  /* exchange args to replace by '<' or '<=' */
     temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
     cond = 1;
   }
@@ -761,23 +839,13 @@
 
 void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
   expdesc e2;
-  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
+  e2.t = e2.f = NO_JUMP; e2.k = VKINT; e2.u.ival = 0;
   switch (op) {
-    case OPR_MINUS: {
-      if (isnumeral(e))  /* minus constant? */
-        e->u.nval = luai_numunm(NULL, e->u.nval);  /* fold it */
-      else {
-        luaK_exp2anyreg(fs, e);
-        codearith(fs, OP_UNM, e, &e2, line);
-      }
+    case OPR_MINUS: case OPR_BNOT: case OPR_LEN: {
+      codeexpval(fs, cast(OpCode, (op - OPR_MINUS) + OP_UNM), e, &e2, line);
       break;
     }
     case OPR_NOT: codenot(fs, e); break;
-    case OPR_LEN: {
-      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
-      codearith(fs, OP_LEN, e, &e2, line);
-      break;
-    }
     default: lua_assert(0);
   }
 }
@@ -794,12 +862,15 @@
       break;
     }
     case OPR_CONCAT: {
-      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
+      luaK_exp2nextreg(fs, v);  /* operand must be on the 'stack' */
       break;
     }
-    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_MOD: case OPR_POW: {
-      if (!isnumeral(v)) luaK_exp2RK(fs, v);
+    case OPR_ADD: case OPR_SUB:
+    case OPR_MUL: case OPR_DIV: case OPR_IDIV:
+    case OPR_MOD: case OPR_POW:
+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
+    case OPR_SHL: case OPR_SHR: {
+      if (!tonumeral(v, NULL)) luaK_exp2RK(fs, v);
       break;
     }
     default: {
@@ -837,13 +908,15 @@
       }
       else {
         luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
-        codearith(fs, OP_CONCAT, e1, e2, line);
+        codeexpval(fs, OP_CONCAT, e1, e2, line);
       }
       break;
     }
     case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_MOD: case OPR_POW: {
-      codearith(fs, cast(OpCode, op - OPR_ADD + OP_ADD), e1, e2, line);
+    case OPR_IDIV: case OPR_MOD: case OPR_POW:
+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
+    case OPR_SHL: case OPR_SHR: {
+      codeexpval(fs, cast(OpCode, (op - OPR_ADD) + OP_ADD), e1, e2, line);
       break;
     }
     case OPR_EQ: case OPR_LT: case OPR_LE: {

=== modified file 'src/third_party/eris/lcode.h'
--- src/third_party/eris/lcode.h	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lcode.h	2016-04-10 16:54:20 +0000
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lcode.h,v 1.63 2013/12/30 20:47:58 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -24,7 +24,11 @@
 ** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
+  OPR_DIV,
+  OPR_IDIV,
+  OPR_BAND, OPR_BOR, OPR_BXOR,
+  OPR_SHL, OPR_SHR,
   OPR_CONCAT,
   OPR_EQ, OPR_LT, OPR_LE,
   OPR_NE, OPR_GT, OPR_GE,
@@ -33,7 +37,7 @@
 } BinOpr;
 
 
-typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
 
 
 #define getcode(fs,e)	((fs)->f->code[(e)->u.info])
@@ -52,7 +56,7 @@
 LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
 LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
 LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
-LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
+LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n);
 LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
 LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
 LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);

=== modified file 'src/third_party/eris/lcorolib.c'
--- src/third_party/eris/lcorolib.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lcorolib.c	2016-04-10 16:54:20 +0000
@@ -1,22 +1,30 @@
 /*
-** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lcorolib.c,v 1.9 2014/11/02 19:19:04 roberto Exp $
 ** Coroutine Library
 ** See Copyright Notice in lua.h
 */
 
-
-#include <stdlib.h>
-
-
 #define lcorolib_c
 #define LUA_LIB
 
+#include "lprefix.h"
+
+
+#include <stdlib.h>
+
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
+static lua_State *getco (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  luaL_argcheck(L, co, 1, "thread expected");
+  return co;
+}
+
+
 static int auxresume (lua_State *L, lua_State *co, int narg) {
   int status;
   if (!lua_checkstack(co, narg)) {
@@ -47,9 +55,8 @@
 
 
 static int luaB_coresume (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
+  lua_State *co = getco(L);
   int r;
-  luaL_argcheck(L, co, 1, "coroutine expected");
   r = auxresume(L, co, lua_gettop(L) - 1);
   if (r < 0) {
     lua_pushboolean(L, 0);
@@ -59,7 +66,7 @@
   else {
     lua_pushboolean(L, 1);
     lua_insert(L, -(r + 1));
-    return r + 1;  /* return true + `resume' returns */
+    return r + 1;  /* return true + 'resume' returns */
   }
 }
 
@@ -102,8 +109,7 @@
 
 
 static int luaB_costatus (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  luaL_argcheck(L, co, 1, "coroutine expected");
+  lua_State *co = getco(L);
   if (L == co) lua_pushliteral(L, "running");
   else {
     switch (lua_status(co)) {
@@ -129,6 +135,12 @@
 }
 
 
+static int luaB_yieldable (lua_State *L) {
+  lua_pushboolean(L, lua_isyieldable(L));
+  return 1;
+}
+
+
 static int luaB_corunning (lua_State *L) {
   int ismain = lua_pushthread(L);
   lua_pushboolean(L, ismain);
@@ -143,6 +155,7 @@
   {"status", luaB_costatus},
   {"wrap", luaB_cowrap},
   {"yield", luaB_yield},
+  {"isyieldable", luaB_yieldable},
   {NULL, NULL}
 };
 

=== modified file 'src/third_party/eris/lctype.c'
--- src/third_party/eris/lctype.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lctype.c	2016-04-10 16:54:20 +0000
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lctype.c,v 1.12 2014/11/02 19:19:04 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
@@ -7,6 +7,9 @@
 #define lctype_c
 #define LUA_CORE
 
+#include "lprefix.h"
+
+
 #include "lctype.h"
 
 #if !LUA_USE_CTYPE	/* { */

=== modified file 'src/third_party/eris/lctype.h'
--- src/third_party/eris/lctype.h	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/lctype.h	2016-04-10 16:54:20 +0000
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */

=== modified file 'src/third_party/eris/ldblib.c'
--- src/third_party/eris/ldblib.c	2014-02-22 14:47:28 +0000
+++ src/third_party/eris/ldblib.c	2016-04-10 16:54:20 +0000
@@ -1,25 +1,30 @@
 /*
-** $Id: ldblib.c,v 1.132.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: ldblib.c,v 1.148 2015/01/02 12:52:22 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 
+#define ldblib_c
+#define LUA_LIB
+
+#include "lprefix.h"
+
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define ldblib_c
-#define LUA_LIB
-
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
-#define HOOKKEY		"_HKEY"
-
+/*
+** The hook table at registry[&HOOKKEY] maps threads to their current
+** hook function. (We only need the unique address of 'HOOKKEY'.)
+*/
+static const int HOOKKEY = 0;
 
 
 static int db_getregistry (lua_State *L) {
@@ -57,35 +62,20 @@
 
 
 static int db_setuservalue (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TLIGHTUSERDATA)
-    luaL_argerror(L, 1, "full userdata expected, got light userdata");
   luaL_checktype(L, 1, LUA_TUSERDATA);
-  if (!lua_isnoneornil(L, 2))
-    luaL_checktype(L, 2, LUA_TTABLE);
+  luaL_checkany(L, 2);
   lua_settop(L, 2);
   lua_setuservalue(L, 1);
   return 1;
 }
 
 
-static void settabss (lua_State *L, const char *i, const char *v) {
-  lua_pushstring(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static void settabsi (lua_State *L, const char *i, int v) {
-  lua_pushinteger(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static void settabsb (lua_State *L, const char *i, int v) {
-  lua_pushboolean(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
+/*
+** Auxiliary function used by several library functions: check for
+** an optional thread as function's first argument and set 'arg' with
+** 1 if this argument is present (so that functions can skip it to
+** access their other arguments)
+*/
 static lua_State *getthread (lua_State *L, int *arg) {
   if (lua_isthread(L, 1)) {
     *arg = 1;
@@ -93,44 +83,70 @@
   }
   else {
     *arg = 0;
-    return L;
+    return L;  /* function will operate over current thread */
   }
 }
 
 
+/*
+** Variations of 'lua_settable', used by 'db_getinfo' to put results
+** from 'lua_getinfo' into result table. Key is always a string;
+** value can be a string, an int, or a boolean.
+*/
+static void settabss (lua_State *L, const char *k, const char *v) {
+  lua_pushstring(L, v);
+  lua_setfield(L, -2, k);
+}
+
+static void settabsi (lua_State *L, const char *k, int v) {
+  lua_pushinteger(L, v);
+  lua_setfield(L, -2, k);
+}
+
+static void settabsb (lua_State *L, const char *k, int v) {
+  lua_pushboolean(L, v);
+  lua_setfield(L, -2, k);
+}
+
+
+/*
+** In function 'db_getinfo', the call to 'lua_getinfo' may push
+** results on the stack; later it creates the result table to put
+** these objects. Function 'treatstackoption' puts the result from
+** 'lua_getinfo' on top of the result table so that it can call
+** 'lua_setfield'.
+*/
 static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
-  if (L == L1) {
-    lua_pushvalue(L, -2);
-    lua_remove(L, -3);
-  }
+  if (L == L1)
+    lua_rotate(L, -2, 1);  /* exchange object and table */
   else
-    lua_xmove(L1, L, 1);
-  lua_setfield(L, -2, fname);
+    lua_xmove(L1, L, 1);  /* move object to the "main" stack */
+  lua_setfield(L, -2, fname);  /* put object into table */
 }
 
 
+/*
+** Calls 'lua_getinfo' and collects all results in a new table.
+*/
 static int db_getinfo (lua_State *L) {
   lua_Debug ar;
   int arg;
   lua_State *L1 = getthread(L, &arg);
   const char *options = luaL_optstring(L, arg+2, "flnStu");
-  if (lua_isnumber(L, arg+1)) {
-    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
+  if (lua_isfunction(L, arg + 1)) {  /* info about a function? */
+    options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */
+    lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */
+    lua_xmove(L, L1, 1);
+  }
+  else {  /* stack level */
+    if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
       lua_pushnil(L);  /* level out of range */
       return 1;
     }
   }
-  else if (lua_isfunction(L, arg+1)) {
-    lua_pushfstring(L, ">%s", options);
-    options = lua_tostring(L, -1);
-    lua_pushvalue(L, arg+1);
-    lua_xmove(L, L1, 1);
-  }
-  else
-    return luaL_argerror(L, arg+1, "function or level expected");
   if (!lua_getinfo(L1, options, &ar))
     return luaL_argerror(L, arg+2, "invalid option");
-  lua_createtable(L, 0, 2);
+  lua_newtable(L);  /* table to collect results */
   if (strchr(options, 'S')) {
     settabss(L, "source", ar.source);
     settabss(L, "short_src", ar.short_src);
@@ -164,20 +180,21 @@
   lua_State *L1 = getthread(L, &arg);
   lua_Debug ar;
   const char *name;
-  int nvar = luaL_checkint(L, arg+2);  /* local-variable index */
+  int nvar = (int)luaL_checkinteger(L, arg + 2);  /* local-variable index */
   if (lua_isfunction(L, arg + 1)) {  /* function argument? */
     lua_pushvalue(L, arg + 1);  /* push function */
     lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */
-    return 1;
+    return 1;  /* return only name (there is no value) */
   }
   else {  /* stack-level argument */
-    if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+    int level = (int)luaL_checkinteger(L, arg + 1);
+    if (!lua_getstack(L1, level, &ar))  /* out of range? */
       return luaL_argerror(L, arg+1, "level out of range");
     name = lua_getlocal(L1, &ar, nvar);
     if (name) {
-      lua_xmove(L1, L, 1);  /* push local value */
+      lua_xmove(L1, L, 1);  /* move local value */
       lua_pushstring(L, name);  /* push name */
-      lua_pushvalue(L, -2);  /* re-order */
+      lua_rotate(L, -2, 1);  /* re-order */
       return 2;
     }
     else {
@@ -190,26 +207,35 @@
 
 static int db_setlocal (lua_State *L) {
   int arg;
+  const char *name;
   lua_State *L1 = getthread(L, &arg);
   lua_Debug ar;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+  int level = (int)luaL_checkinteger(L, arg + 1);
+  int nvar = (int)luaL_checkinteger(L, arg + 2);
+  if (!lua_getstack(L1, level, &ar))  /* out of range? */
     return luaL_argerror(L, arg+1, "level out of range");
   luaL_checkany(L, arg+3);
   lua_settop(L, arg+3);
   lua_xmove(L, L1, 1);
-  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
+  name = lua_setlocal(L1, &ar, nvar);
+  if (name == NULL)
+    lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */
+  lua_pushstring(L, name);
   return 1;
 }
 
 
+/*
+** get (if 'get' is true) or set an upvalue from a closure
+*/
 static int auxupvalue (lua_State *L, int get) {
   const char *name;
-  int n = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TFUNCTION);
+  int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */
+  luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */
   name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
   if (name == NULL) return 0;
   lua_pushstring(L, name);
-  lua_insert(L, -(get+1));
+  lua_insert(L, -(get+1));  /* no-op if get is false */
   return get + 1;
 }
 
@@ -225,13 +251,15 @@
 }
 
 
+/*
+** Check whether a given upvalue from a given closure exists and
+** returns its index
+*/
 static int checkupval (lua_State *L, int argf, int argnup) {
-  lua_Debug ar;
-  int nup = luaL_checkint(L, argnup);
-  luaL_checktype(L, argf, LUA_TFUNCTION);
-  lua_pushvalue(L, argf);
-  lua_getinfo(L, ">u", &ar);
-  luaL_argcheck(L, 1 <= nup && nup <= ar.nups, argnup, "invalid upvalue index");
+  int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */
+  luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */
+  luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup,
+                   "invalid upvalue index");
   return nup;
 }
 
@@ -253,26 +281,29 @@
 }
 
 
-#define gethooktable(L)	luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)
-
-
+/*
+** Call hook function registered at hook table for the current
+** thread (if there is one)
+*/
 static void hookf (lua_State *L, lua_Debug *ar) {
   static const char *const hooknames[] =
     {"call", "return", "line", "count", "tail call"};
-  gethooktable(L);
+  lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);
   lua_pushthread(L);
-  lua_rawget(L, -2);
-  if (lua_isfunction(L, -1)) {
-    lua_pushstring(L, hooknames[(int)ar->event]);
+  if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */
+    lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */
     if (ar->currentline >= 0)
-      lua_pushinteger(L, ar->currentline);
+      lua_pushinteger(L, ar->currentline);  /* push current line */
     else lua_pushnil(L);
     lua_assert(lua_getinfo(L, "lS", ar));
-    lua_call(L, 2, 0);
+    lua_call(L, 2, 0);  /* call hook function */
   }
 }
 
 
+/*
+** Convert a string mask (for 'sethook') into a bit mask
+*/
 static int makemask (const char *smask, int count) {
   int mask = 0;
   if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
@@ -283,6 +314,9 @@
 }
 
 
+/*
+** Convert a bit mask (for 'gethook') into a string mask
+*/
 static char *unmakemask (int mask, char *smask) {
   int i = 0;
   if (mask & LUA_MASKCALL) smask[i++] = 'c';
@@ -297,26 +331,29 @@
   int arg, mask, count;
   lua_Hook func;
   lua_State *L1 = getthread(L, &arg);
-  if (lua_isnoneornil(L, arg+1)) {
+  if (lua_isnoneornil(L, arg+1)) {  /* no hook? */
     lua_settop(L, arg+1);
     func = NULL; mask = 0; count = 0;  /* turn off hooks */
   }
   else {
     const char *smask = luaL_checkstring(L, arg+2);
     luaL_checktype(L, arg+1, LUA_TFUNCTION);
-    count = luaL_optint(L, arg+3, 0);
+    count = (int)luaL_optinteger(L, arg + 3, 0);
     func = hookf; mask = makemask(smask, count);
   }
-  if (gethooktable(L) == 0) {  /* creating hook table? */
+  if (lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY) == LUA_TNIL) {
+    lua_createtable(L, 0, 2);  /* create a hook table */
+    lua_pushvalue(L, -1);
+    lua_rawsetp(L, LUA_REGISTRYINDEX, &HOOKKEY);  /* set it in position */
     lua_pushstring(L, "k");
     lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */
     lua_pushvalue(L, -1);
     lua_setmetatable(L, -2);  /* setmetatable(hooktable) = hooktable */
   }
-  lua_pushthread(L1); lua_xmove(L1, L, 1);
-  lua_pushvalue(L, arg+1);
-  lua_rawset(L, -3);  /* set new hook */
-  lua_sethook(L1, func, mask, count);  /* set hooks */
+  lua_pushthread(L1); lua_xmove(L1, L, 1);  /* key (thread) */
+  lua_pushvalue(L, arg + 1);  /* value (hook function) */
+  lua_rawset(L, -3);  /* hooktable[L1] = new Lua hook */
+  lua_sethook(L1, func, mask, count);
   return 0;
 }
 
@@ -327,16 +364,18 @@
   char buff[5];
   int mask = lua_gethookmask(L1);
   lua_Hook hook = lua_gethook(L1);
-  if (hook != NULL && hook != hookf)  /* external hook? */
+  if (hook == NULL)  /* no hook? */
+    lua_pushnil(L);
+  else if (hook != hookf)  /* external hook? */
     lua_pushliteral(L, "external hook");
-  else {
-    gethooktable(L);
+  else {  /* hook table must exist */
+    lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);
     lua_pushthread(L1); lua_xmove(L1, L, 1);
-    lua_rawget(L, -2);   /* get hook */
+    lua_rawget(L, -2);   /* 1st result = hooktable[L1] */
     lua_remove(L, -2);  /* remove hook table */
   }
-  lua_pushstring(L, unmakemask(mask, buff));
-  lua_pushinteger(L, lua_gethookcount(L1));
+  lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */