+/**
+ * @brief Pops a value from the stack of a source state and pushes it on the
+ * stack of another state.
+ *
+ * If the value is a table, its content is copied recursively. To avoid cycles,
+ * a table of previsously visited tables must be present at index 1 of dst.
+ * Its keys are pointers to visited tables in src and its values are the tables
+ * already built.
+ *
+ * TODO: add support of upvalues
+ *
+ * @param src the source state
+ * @param dst the destination state
+ * @param name a name describing the value
+ */
+static void move_value(lua_State* dst, lua_State *src, const char* name) {
+
+ luaL_checkany(src, -1); /* check the value to copy */
+ luaL_checktype(dst, 1, LUA_TTABLE); /* check the presence of a table of
+ previously visited tables */
+
+ XBT_DEBUG("Copying value %s", name);
+
+ stack_dump("src before copying a value (should be ... value): ", src);
+ stack_dump("dst before copying a value (should be visited ...): ", dst);
+
+ switch (lua_type(src, -1)) {
+
+ case LUA_TNIL:
+ lua_pushnil(dst);
+ break;
+
+ case LUA_TNUMBER:
+ lua_pushnumber(dst, lua_tonumber(src, -1));
+ break;
+
+ case LUA_TBOOLEAN:
+ lua_pushboolean(dst, lua_toboolean(src, -1));
+ break;
+
+ case LUA_TSTRING:
+ /* no worries about memory: lua_pushstring makes a copy */
+ lua_pushstring(dst, lua_tostring(src, -1));
+ break;
+
+ case LUA_TFUNCTION:
+ /* it's a function that does not exist yet in L2 */
+
+ if (lua_iscfunction(src, -1)) {
+ /* it's a C function: just copy the pointer */
+ XBT_DEBUG("Copying C function '%s'", name);
+ lua_CFunction f = lua_tocfunction(src, -1);
+ lua_pushcfunction(dst, f);
+ }
+ else {
+ /* it's a Lua function: dump it from src */
+ XBT_DEBUG("Dumping Lua function '%s'", name);
+
+ s_buffer_t buffer;
+ buffer.capacity = 64;
+ buffer.size = 0;
+ buffer.data = xbt_new(char, buffer.capacity);
+
+ /* copy the binary chunk from src into a buffer */
+ int error = lua_dump(src, writer, &buffer);
+ xbt_assert(!error, "Failed to dump function '%s' from the source state: error %d",
+ name, error);
+
+ /* load the chunk into dst */
+ error = luaL_loadbuffer(dst, buffer.data, buffer.size, name);
+ xbt_assert(!error, "Failed to load function '%s' from the source state: %s",
+ name, lua_tostring(dst, -1));
+ XBT_DEBUG("Function '%s' successfully dumped from source state.", name);
+ }
+ break;
+
+ case LUA_TTABLE:
+
+ /* see if this table was already visited */
+ lua_pushlightuserdata(dst, (void*) lua_topointer(src, -1));
+ /* dst: visited ... psrctable */
+ lua_gettable(dst, 1);
+ /* dst: visited ... table/nil */
+ if (lua_istable(dst, -1)) {
+ XBT_DEBUG("Nothing to do: table already visited");
+ /* dst: visited ... table */
+ }
+ else {
+ XBT_DEBUG("First visit of this table");
+ /* dst: visited ... nil */
+ lua_pop(dst, 1);
+ /* dst: visited ... */
+
+ /* first visit: create the new table in dst */
+ lua_newtable(dst);
+ /* dst: visited ... table */
+
+ /* mark the table as visited to avoid infinite recursion */
+ lua_pushlightuserdata(dst, (void*) lua_topointer(src, -1));
+ /* dst: visited ... table psrctable */
+ lua_pushvalue(dst, -2);
+ /* dst: visited ... table psrctable table */
+ lua_settable(dst, 1);
+ /* dst: visited ... table */
+ XBT_DEBUG("Table marked as visited");
+
+ stack_dump("dst after marking the table as visited (should be visited ... table): ", dst);
+
+ /* copy the metatable if any */
+ int has_meta_table = lua_getmetatable(src, -1);
+ /* src: ... table mt? */
+ if (has_meta_table) {
+ XBT_DEBUG("Copying metatable");
+ /* src: ... table mt */
+ move_value(dst, src, "metatable");
+ /* src: ... table
+ dst: visited ... table mt */
+ lua_setmetatable(dst, -2);
+ /* dst: visited ... table */
+ }
+ else {
+ XBT_DEBUG("No metatable");
+ }
+
+ stack_dump("src before traversing the table (should be ... table): ", src);
+ stack_dump("dst before traversing the table (should be visited ... table): ", dst);
+
+ /* traverse the table of src and copy each element */
+ lua_pushnil(src);
+ /* src: ... table nil */
+ while (lua_next(src, -2) != 0) {
+ /* src: ... table key value */
+
+ XBT_DEBUG("Copying table element %s", keyvalue_tostring(src, -2, -1));
+
+ stack_dump("src before copying table element (should be ... table key value): ", src);
+ stack_dump("dst before copying table element (should be visited ... table): ", dst);
+
+ /* copy the key */
+ lua_pushvalue(src, -2);
+ /* src: ... table key value key */
+ XBT_DEBUG("Copying the element key");
+ move_value(dst, src, value_tostring(src, -1));
+ /* src: ... table key value
+ dst: visited ... table key */
+ XBT_DEBUG("Copied the element key");
+
+ /* copy the value */
+ XBT_DEBUG("Copying the element value");
+ move_value(dst, src, value_tostring(src, -1));
+ /* src: ... table key
+ dst: visited ... table key value */
+ XBT_DEBUG("Copied the element value");
+
+ /* set the table element */
+ lua_settable(dst, -3);
+ /* dst: visited ... table */
+
+ /* the key stays on top of src for next iteration */
+ stack_dump("src before next iteration (should be ... table key): ", src);
+ stack_dump("dst before next iteration (should be visited ... table): ", dst);
+ }
+ XBT_DEBUG("Finished traversing the table");
+ }
+ break;
+
+ case LUA_TLIGHTUSERDATA:
+ lua_pushlightuserdata(dst, lua_touserdata(src, -1));
+ break;
+
+ case LUA_TUSERDATA:
+ XBT_WARN("Cannot copy a full userdata from the source state.");
+ lua_pushnil(dst);
+ break;
+
+ case LUA_TTHREAD:
+ XBT_WARN("Cannot copy a thread from the source state.");
+ lua_pushnil(dst);
+ break;
+ }
+
+ /* pop the value from src */
+ lua_pop(src, 1);
+
+ stack_dump("src after copying a value (should be ...): ", src);
+ stack_dump("dst after copying a value (should be visited ... value): ", dst);
+}
+
+/**
+ * @brief Copies a global value from the father state.
+ *
+ * The state L must have a father, i.e. it should have been created by
+ * clone_lua_state().
+ * This function is meant to be an __index metamethod.
+ * Consequently, it assumes that the stack has two elements:
+ * a table (usually the environment of L) and the string key of a value
+ * that does not exist yet in this table. It copies the corresponding global
+ * value from the father state and pushes it on the stack of L.
+ * If the global value does not exist in the father state either, nil is
+ * pushed.
+ *
+ * TODO: make this function thread safe. If the simulation runs in parallel,
+ * several simulated processes may trigger this __index metamethod at the same
+ * time and get globals from maestro.
+ *
+ * @param L the current state
+ * @return number of return values pushed (always 1)
+ */
+static int l_get_from_father(lua_State *L) {
+
+ /* retrieve the father */
+ lua_getfield(L, LUA_REGISTRYINDEX, "simgrid.father_state");
+ lua_State* father = lua_touserdata(L, -1);
+ xbt_assert(father != NULL, "This Lua state has no father");
+ lua_pop(L, 1);
+
+ /* get the global from the father */
+ const char* key = luaL_checkstring(L, 2); /* L: table key */
+ lua_getglobal(father, key); /* father: ... value */
+ XBT_DEBUG("__index of '%s' begins", key);
+
+ /* push the value onto the stack of L */
+ lua_newtable(L); /* L: table key visited */
+ lua_insert(L, 1); /* L: visited table key */
+ move_value(L, father, key); /* father: ...
+ L: visited table key value */
+ lua_remove(L, 1); /* L: table key value */
+
+ /* prepare the return value of __index */
+ lua_pushvalue(L, -1); /* L: table key value value */
+ lua_insert(L, 1); /* L: value table key value */
+
+ /* save the copied value in the table for subsequent accesses */
+ lua_settable(L, -3); /* L: value table */
+ lua_remove(L, 2); /* L: value */
+
+ XBT_DEBUG("__index of '%s' returns %s", key, value_tostring(L, -1));
+
+ return 1;
+}
+
+/**
+ * @brief Creates a new Lua state and get its environment from an existing state.
+ *
+ * The state created is independent from the existing one and has its own
+ * copies of global variables and functions.
+ * However, the global variables and functions are not copied right now from
+ * the original state; they are copied only the first time they are accessed.
+ * This behavior saves time and memory, and is okay for Simgrid's needs.
+ *
+ * @param father an existing state
+ * @return the state created
+ */
+static lua_State* clone_lua_state(lua_State *father) {
+
+ /* create the new state */
+ lua_State *L = luaL_newstate();
+
+ /* set its environment:
+ * - create a table newenv
+ * - create a metatable mt
+ * - set mt.__index = a function that copies the global from the father state
+ * - set mt as the metatable of newenv
+ * - set newenv as the environment of the new state
+ */
+ lua_pushthread(L); /* thread */
+ lua_newtable(L); /* thread newenv */
+ lua_newtable(L); /* thread newenv mt */
+ lua_pushcfunction(L, l_get_from_father); /* thread newenv mt f */
+ lua_setfield(L, -2, "__index"); /* thread newenv mt */
+ lua_setmetatable(L, -2); /* thread newenv */
+ lua_setfenv(L, -2); /* thread */
+ lua_pop(L, 1); /* -- */
+
+ /* open the standard libs (theoretically, this is not necessary) */
+ luaL_openlibs(L);
+
+ /* put a pointer to the father */
+ lua_pushlightuserdata(L, father);
+ lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.father_state");
+
+ XBT_DEBUG("New state created");
+
+ return L;
+}
+
+/**
+ * @brief Ensures that a userdata on the stack is a task
+ * and returns the pointer inside the userdata.
+ * @param L a Lua state
+ * @param index an index in the Lua stack
+ * @return the task at this index
+ */
+static m_task_t checkTask(lua_State * L, int index)
+{
+ m_task_t *pi, tk;
+ luaL_checktype(L, index, LUA_TTABLE);
+ lua_getfield(L, index, "__simgrid_task");
+ pi = (m_task_t *) luaL_checkudata(L, -1, TASK_MODULE_NAME);
+ if (pi == NULL)
+ luaL_typerror(L, index, TASK_MODULE_NAME);