Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
First series of changes to lua-bindings in order to
[simgrid.git] / src / bindings / lua / lua_state_cloner.c
1 /* Copyright (c) 2010-2014. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 /* SimGrid Lua state management                                             */
8
9 #include "lua_state_cloner.h"
10 #include "lua_utils.h"
11 #include "xbt.h"
12 #include "xbt/log.h"
13 #include <lauxlib.h>
14 #include <lualib.h>
15
16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua_state_cloner, bindings, "Lua state management");
17
18 static void sglua_add_maestro_table(lua_State* L, int index, void* maestro_table_ptr);
19 static void sglua_remove_maestro_table(lua_State* L, int index, void* maestro_table_ptr);
20 static void* sglua_get_maestro_table_ptr(lua_State* L, int index);
21 static void sglua_get_table_by_ptr(lua_State* L, void* table_ptr);
22 static int l_get_from_maestro(lua_State* L);
23
24 static void sglua_copy_nil(lua_State* src, lua_State* dst);
25 static void sglua_copy_number(lua_State* src, lua_State* dst);
26 static void sglua_copy_boolean(lua_State* src, lua_State* dst);
27 static void sglua_copy_string(lua_State* src, lua_State* dst);
28 static void sglua_copy_table(lua_State* src, lua_State* dst);
29 static void sglua_copy_function(lua_State* src, lua_State* dst);
30 static void sglua_copy_lightuserdata(lua_State* src, lua_State* dst);
31 static void sglua_copy_userdata(lua_State* src, lua_State* dst);
32 static void sglua_copy_thread(lua_State* src, lua_State* dst);
33
34 /**
35  * @brief Adds a reference to a maestro table to the list of known maestro
36  * tables of a state.
37  *
38  * TODO identify maestro's tables with my own IDs instead of pointers
39  * to Lua internals
40  *
41  * @param L a state (can be maestro itself)
42  * @param index index of the copy of the maestro table in the stack of L
43  * @param maestro_table_ptr pointer to the original table in maestro's world
44  */
45 static void sglua_add_maestro_table(lua_State* L, int index, void* maestro_table_ptr) {
46
47   /* we will set both [ptr] -> table and [table] -> ptr */
48
49                                   /* ... */
50   lua_pushvalue(L, index);
51                                   /* ... table */
52   lua_pushstring(L, "simgrid.maestro_tables");
53                                   /* ... table "simgrid.maestro_tables" */
54   lua_rawget(L, LUA_REGISTRYINDEX);
55                                   /* ... table maestrotbs */
56   lua_pushvalue(L, -2);
57                                   /* ... table maestrotbs table */
58   lua_pushlightuserdata(L, maestro_table_ptr);
59                                   /* ... table maestrotbs table tableptr */
60   lua_pushvalue(L, -1);
61                                   /* ... table maestrotbs table tableptr tableptr */
62   lua_pushvalue(L, -3);
63                                   /* ... table maestrotbs table tableptr tableptr table */
64   lua_settable(L, -5);
65                                   /* ... table maestrotbs table tableptr */
66   lua_settable(L, -3);
67                                   /* ... table maestrotbs */
68   lua_pop(L, 2);
69                                   /* ... */
70 }
71
72 /**
73  * @brief Removes a reference to a maestro table to the list of known maestro
74  * tables of a state.
75  *
76  * @param L a state (can be maestro itself)
77  * @param index index of the copy of the maestro table in the stack of L
78  * @param maestro_table_ptr pointer to the original table in maestro's world
79  */
80 static void sglua_remove_maestro_table(lua_State* L, int index, void* maestro_table_ptr) {
81
82   /* we will unset both [ptr] -> table and [table] -> ptr */
83
84                                   /* ... */
85   lua_pushvalue(L, index);
86                                   /* ... table */
87   lua_pushstring(L, "simgrid.maestro_tables");
88                                   /* ... table "simgrid.maestro_tables" */
89   lua_rawget(L, LUA_REGISTRYINDEX);
90                                   /* ... table maestrotbs */
91   lua_pushvalue(L, -2);
92                                   /* ... table maestrotbs table */
93   lua_pushnil(L);
94                                   /* ... table maestrotbs table nil */
95   lua_pushlightuserdata(L, maestro_table_ptr);
96                                   /* ... table maestrotbs table nil tableptr */
97   lua_pushnil(L);
98                                   /* ... table maestrotbs table nil tableptr nil*/
99   lua_settable(L, -5);
100                                   /* ... table maestrotbs table nil */
101   lua_settable(L, -3);
102                                   /* ... table maestrotbs */
103   lua_pop(L, 2);
104                                   /* ... */
105 }
106
107 /**
108  * @brief For a table in the stack of L, returns a pointer that identifies the
109  * same table in in maestro's world.
110  * @param L a Lua state
111  * @param index index of a table in the stack of L
112  * @return a pointer to maestro's copy of this table, or NULL if this table
113  * did not come from maestro
114  */
115 static void* sglua_get_maestro_table_ptr(lua_State* L, int index) {
116
117   void* maestro_table_ptr = NULL;
118                                   /* ... */
119   lua_pushvalue(L, index);
120                                   /* ... table */
121   lua_pushstring(L, "simgrid.maestro_tables");
122                                   /* ... table "simgrid.maestro_tables" */
123   lua_rawget(L, LUA_REGISTRYINDEX);
124                                   /* ... table maestrotbs */
125   lua_pushvalue(L, -2);
126                                   /* ... table maestrotbs table */
127   lua_gettable(L, -2);
128                                   /* ... table maestrotbs tableptr/nil */
129   if (!lua_isnil(L, -1)) {
130                                   /* ... table maestrotbs tableptr */
131     maestro_table_ptr = (void*) lua_topointer(L, -1);
132   }
133
134   lua_pop(L, 3);
135                                   /* ... */
136   return maestro_table_ptr;
137 }
138
139 /**
140  * @brief Pushes a table knowing a pointer to maestro's copy of this table.
141  *
142  * Pushes nil if L does not know this table in maestro.
143  *
144  * @param L a Lua state
145  * @param maestro_table_ptr pointer that identifies a table in maestro's world
146  */
147 static void sglua_get_table_by_ptr(lua_State* L, void* maestro_table_ptr) {
148
149                                   /* ... */
150   lua_pushstring(L, "simgrid.maestro_tables");
151                                   /* ... "simgrid.maestro_tables" */
152   lua_rawget(L, LUA_REGISTRYINDEX);
153                                   /* ... maestrotbs */
154   lua_pushlightuserdata(L, maestro_table_ptr);
155                                   /* ... maestrotbs tableptr */
156   lua_gettable(L, -2);
157                                   /* ... maestrotbs table/nil */
158   lua_remove(L, -2);
159                                   /* ... table/nil */
160 }
161
162 /**
163  * @brief Pops a value from the stack of a source state and pushes it on the
164  * stack of another state.
165  * If the value is a table, its content is copied recursively.
166  *
167  * This function is similar to lua_xmove() but it allows to move a value
168  * between two different global states.
169  *
170  * @param src the source state (not necessarily maestro)
171  * @param dst the destination state
172  */
173 void sglua_move_value(lua_State* src, lua_State* dst) {
174
175   sglua_copy_value(src, dst);
176   lua_pop(src, 1);
177 }
178
179 /**
180  * @brief Pushes onto the stack a copy of the value on top another stack.
181  * If the value is a table, its content is copied recursively.
182  *
183  * This function allows to move a value between two different global states.
184  *
185  * @param src the source state (not necessarily maestro)
186  * @param dst the destination state
187  */
188 void sglua_copy_value(lua_State* src, lua_State* dst) {
189
190   luaL_checkany(src, -1);                  /* check the value to copy */
191
192   int indent = (lua_gettop(dst) - 1) * 6;
193   XBT_DEBUG("%sCopying data %s", sglua_get_spaces(indent), sglua_tostring(src, -1));
194
195   sglua_stack_dump("src before copying a value (should be ... value): ", src);
196   sglua_stack_dump("dst before copying a value (should be ...): ", dst);
197
198   switch (lua_type(src, -1)) {
199
200     case LUA_TNIL:
201       sglua_copy_nil(src, dst);
202       break;
203
204     case LUA_TNUMBER:
205       sglua_copy_number(src, dst);
206       break;
207
208     case LUA_TBOOLEAN:
209       sglua_copy_boolean(src, dst);
210       break;
211
212     case LUA_TSTRING:
213       sglua_copy_string(src, dst);
214       break;
215
216     case LUA_TFUNCTION:
217       sglua_copy_function(src, dst);
218       break;
219
220     case LUA_TTABLE:
221       sglua_copy_table(src, dst);
222       break;
223
224     case LUA_TLIGHTUSERDATA:
225       sglua_copy_lightuserdata(src, dst);
226       break;
227
228     case LUA_TUSERDATA:
229       sglua_copy_userdata(src, dst);
230       break;
231
232     case LUA_TTHREAD:
233       sglua_copy_thread(src, dst);
234       break;
235   }
236
237   XBT_DEBUG("%sData copied", sglua_get_spaces(indent));
238
239   sglua_stack_dump("src after copying a value (should be ... value): ", src);
240   sglua_stack_dump("dst after copying a value (should be ... value): ", dst);
241 }
242
243 /**
244  * @brief Copies the nil value on the top of src to the top of dst.
245  * @param src source state
246  * @param dst destination state
247  */
248 static void sglua_copy_nil(lua_State* src, lua_State* dst) {
249   lua_pushnil(dst);
250 }
251
252 /**
253  * @brief Copies the number value on the top of src to the top of dst.
254  * @param src source state
255  * @param dst destination state
256  */
257 static void sglua_copy_number(lua_State* src, lua_State* dst) {
258   lua_pushnumber(dst, lua_tonumber(src, -1));
259 }
260
261 /**
262  * @brief Copies the boolean value on the top of src to the top of dst.
263  * @param src source state
264  * @param dst destination state
265  */
266 static void sglua_copy_boolean(lua_State* src, lua_State* dst) {
267   lua_pushboolean(dst, lua_toboolean(src, -1));
268 }
269
270 /**
271  * @brief Copies the string value on the top of src to the top of dst.
272  * @param src source state
273  * @param dst destination state
274  */
275 static void sglua_copy_string(lua_State* src, lua_State* dst) {
276
277   /* no worries about memory: lua_pushstring makes a copy */
278   lua_pushstring(dst, lua_tostring(src, -1));
279 }
280
281 /**
282  * @brief Copies the table value on top of src to the top of dst.
283  *
284  * A deep copy of the table is made. If the table has a metatable, the
285  * metatable is also copied.
286  * If the table comes from maestro and is already known by the destination
287  * state, it is not copied again.
288  *
289  * @param src source state
290  * @param dst destination state
291  */
292 static void sglua_copy_table(lua_State* src, lua_State* dst) {
293
294                                   /* src: ... table
295                                      dst: ... */
296   int indent = lua_gettop(dst) * 6  + 2;
297
298   /* get from maestro the pointer that identifies this table */
299   void* table_ptr = sglua_get_maestro_table_ptr(src, -1);
300   int known_by_maestro = (table_ptr != NULL);
301
302   if (!known_by_maestro) {
303     /* the table didn't come from maestro: nevermind, use the pointer of src */
304     table_ptr = (void*) lua_topointer(src, -1);
305     XBT_DEBUG("%sMaestro does not know this table",
306         sglua_get_spaces(indent));
307   }
308
309   if (sglua_is_maestro(src)) {
310     /* register the table in maestro itself */
311     XBT_DEBUG("%sKeeping track of this table in maestro itself",
312         sglua_get_spaces(indent));
313     sglua_add_maestro_table(src, -1, table_ptr);
314     known_by_maestro = 1;
315     xbt_assert(sglua_get_maestro_table_ptr(src, -1) == table_ptr);
316   }
317
318   /* to avoid infinite recursion, see if this table is already known by dst */
319   sglua_get_table_by_ptr(dst, table_ptr);
320                                   /* dst: ... table/nil */
321   if (!lua_isnil(dst, -1)) {
322     XBT_DEBUG("%sNothing to do: table already known (%p)",
323         sglua_get_spaces(indent), table_ptr);
324                                   /* dst: ... table */
325   }
326   else {
327     XBT_DEBUG("%sFirst visit of this table (%p)", sglua_get_spaces(indent),
328         table_ptr);
329                                   /* dst: ... nil */
330     lua_pop(dst, 1);
331                                   /* dst: ... */
332
333     /* first visit: create the new table in dst */
334     lua_newtable(dst);
335                                   /* dst: ... table */
336
337     /* mark the table as known right now to avoid infinite recursion */
338     sglua_add_maestro_table(dst, -1, table_ptr);
339     /* we may have added a table with a non-maestro pointer, but if it was the
340      * case, we will remove it later */
341     XBT_DEBUG("%sTable marked as known", sglua_get_spaces(indent));
342     xbt_assert(sglua_get_maestro_table_ptr(dst, -1) == table_ptr);
343
344     sglua_stack_dump("dst after marking the table as known (should be ... table): ", dst);
345
346     /* copy the metatable if any */
347     int has_meta_table = lua_getmetatable(src, -1);
348                                   /* src: ... table mt? */
349     if (has_meta_table) {
350       XBT_DEBUG("%sCopying the metatable", sglua_get_spaces(indent));
351                                   /* src: ... table mt */
352       sglua_copy_table(src, dst);
353                                   /* dst: ... table mt */
354       lua_pop(src, 1);
355                                   /* src: ... table */
356       lua_setmetatable(dst, -2);
357                                   /* dst: ... table */
358     }
359     else {
360                                   /* src: ... table */
361       XBT_DEBUG("%sNo metatable", sglua_get_spaces(indent));
362     }
363
364     sglua_stack_dump("src before traversing the table (should be ... table): ", src);
365     sglua_stack_dump("dst before traversing the table (should be ... table): ", dst);
366
367     /* traverse the table of src and copy each element */
368     lua_pushnil(src);
369                                   /* src: ... table nil */
370     while (lua_next(src, -2) != 0) {
371                                   /* src: ... table key value */
372
373       XBT_DEBUG("%sCopying table element %s", sglua_get_spaces(indent),
374           sglua_keyvalue_tostring(src, -2, -1));
375
376       sglua_stack_dump("src before copying table element (should be ... table key value): ", src);
377       sglua_stack_dump("dst before copying table element (should be ... table): ", dst);
378
379       /* copy the key */
380       lua_pushvalue(src, -2);
381                                   /* src: ... table key value key */
382       indent += 2;
383       XBT_DEBUG("%sCopying the key part of the table element",
384           sglua_get_spaces(indent));
385       sglua_move_value(src, dst);
386                                   /* src: ... table key value
387                                      dst: ... table key */
388       XBT_DEBUG("%sCopied the key part of the table element",
389           sglua_get_spaces(indent));
390
391       /* copy the value */
392       XBT_DEBUG("%sCopying the value part of the table element",
393           sglua_get_spaces(indent));
394       sglua_move_value(src, dst);
395                                   /* src: ... table key
396                                      dst: ... table key value */
397       XBT_DEBUG("%sCopied the value part of the table element",
398           sglua_get_spaces(indent));
399       indent -= 2;
400
401       /* set the table element */
402       lua_settable(dst, -3);
403                                   /* dst: ... table */
404
405       /* the key stays on top of src for next iteration */
406       sglua_stack_dump("src before next iteration (should be ... table key): ", src);
407       sglua_stack_dump("dst before next iteration (should be ... table): ", dst);
408
409       XBT_DEBUG("%sTable element copied", sglua_get_spaces(indent));
410     }
411     XBT_DEBUG("%sFinished traversing the table", sglua_get_spaces(indent));
412   }
413
414   if (!known_by_maestro) {
415     /* actually,it was not a maestro table: forget the pointer */
416     sglua_remove_maestro_table(dst, -1, table_ptr);
417   }
418 }
419
420 /**
421  * @brief Copies the function on the top of src to the top of dst.
422  *
423  * It can be a Lua function or a C function.
424  *
425  * @param src source state
426  * @param dst destination state
427  */
428 static void sglua_copy_function(lua_State* src, lua_State* dst) {
429
430   if (lua_iscfunction(src, -1)) {
431     /* it's a C function */
432
433     XBT_DEBUG("It's a C function");
434     sglua_stack_dump("src before copying upvalues: ", src);
435
436     /* get the function pointer */
437     int function_index = lua_gettop(src);
438     lua_CFunction f = lua_tocfunction(src, function_index);
439
440     /* copy the upvalues */
441     int i = 0;
442     const char* upvalue_name = NULL;
443     do {
444       i++;
445       upvalue_name = lua_getupvalue(src, function_index, i);
446
447       if (upvalue_name != NULL) {
448         XBT_DEBUG("Upvalue %s", upvalue_name);
449         sglua_move_value(src, dst);
450       }
451     } while (upvalue_name != NULL);
452
453     sglua_stack_dump("src before copying pointer: ", src);
454
455     /* set the function */
456     lua_pushcclosure(dst, f, i - 1);
457     XBT_DEBUG("Function pointer copied");
458   }
459   else {
460     /* it's a Lua function: dump it from src */
461
462     s_sglua_buffer_t buffer;
463     buffer.capacity = 128; /* an empty function uses 77 bytes */
464     buffer.size = 0;
465     buffer.data = xbt_new(char, buffer.capacity);
466
467     /* copy the binary chunk from src into a buffer
468      * c.heinrich: Added parameter TRUE for Lua 5.3 - this strips all debug
469      * information from the function.
470      */
471     // Was before merge: XBT_GNUC_UNUSED and was replaced with XBT_ATTRIB_UNUSED
472     XBT_ATTRIB_UNUSED int error = lua_dump(src, sglua_memory_writer, &buffer, TRUE);
473     xbt_assert(!error, "Failed to dump the function from the source state: error %d",
474         error);
475     XBT_DEBUG("Fonction dumped: %zu bytes", buffer.size);
476
477     /*
478     fwrite(buffer.data, buffer.size, buffer.size, stderr);
479     fprintf(stderr, "\n");
480     */
481
482     /* load the chunk into dst */
483     error = luaL_loadbuffer(dst, buffer.data, buffer.size, "(dumped function)");
484     xbt_assert(!error, "Failed to load the function into the destination state: %s",
485         lua_tostring(dst, -1));
486   }
487 }
488
489 /**
490  * @brief Copies the light userdata on the top of src to the top of dst.
491  * @param src source state
492  * @param dst destination state
493  */
494 static void sglua_copy_lightuserdata(lua_State* src, lua_State* dst) {
495   lua_pushlightuserdata(dst, lua_touserdata(src, -1));
496 }
497
498 /**
499  * @brief Copies the full userdata on the top of src to the top of dst.
500  *
501  * If the userdata has a metatable, the metatable is also copied.
502  *
503  * @param src source state
504  * @param dst destination state
505  */
506 static void sglua_copy_userdata(lua_State* src, lua_State* dst) {
507
508   int indent = lua_gettop(dst) * 6  + 2;
509
510   /* copy the data */
511                                   /* src: ... udata
512                                      dst: ... */
513   size_t size = lua_rawlen(src, -1);
514   void* src_block = lua_touserdata(src, -1);
515   void* dst_block = lua_newuserdata(dst, size);
516                                   /* dst: ... udata */
517   memcpy(dst_block, src_block, size);
518
519   /* copy the metatable if any */
520   int has_meta_table = lua_getmetatable(src, -1);
521                                   /* src: ... udata mt? */
522   if (has_meta_table) {
523     XBT_DEBUG("%sCopying metatable of userdata (%p)",
524         sglua_get_spaces(indent), lua_topointer(src, -1));
525                                   /* src: ... udata mt */
526     sglua_copy_table(src, dst);
527                                   /* src: ... udata mt
528                                      dst: ... udata mt */
529     lua_pop(src, 1);
530                                   /* src: ... udata */
531     lua_setmetatable(dst, -2);
532                                   /* dst: ... udata */
533
534     XBT_DEBUG("%sMetatable of userdata copied", sglua_get_spaces(indent));
535   }
536   else {
537     XBT_DEBUG("%sNo metatable for this userdata",
538         sglua_get_spaces(indent));
539                                   /* src: ... udata */
540   }
541 }
542
543 /**
544  * @brief This operation is not supported (yet?) so it just pushes nil.
545  *
546  * @param src source state
547  * @param dst destination state
548  */
549 static void sglua_copy_thread(lua_State* src, lua_State* dst) {
550
551   XBT_WARN("Copying a thread from another state is not implemented (yet?).");
552   lua_pushnil(dst);
553 }
554
555 /**
556  * @brief Copies a global value or a registry value from the maestro state.
557  *
558  * The state L must have been created by sglua_clone_maestro_state().
559  * This function is meant to be an __index metamethod.
560  * Consequently, it assumes that the stack has two elements:
561  * a table (either the environment or the registry of L) and the string key of
562  * a value that does not exist yet in this table. It copies the corresponding
563  * value from maestro and pushes it on the stack of L.
564  * If the value does not exist in maestro state either, nil is pushed.
565  *
566  * TODO: make this function thread safe. If the simulation runs in parallel,
567  * several simulated processes may trigger this __index metamethod at the same
568  * time and get globals from maestro.
569  *
570  * @param L the current state
571  * @return number of return values pushed (always 1)
572  */
573 static int l_get_from_maestro(lua_State *L) {
574
575   /* check the arguments */
576   luaL_checktype(L, 1, LUA_TTABLE);
577   const char* key = luaL_checkstring(L, 2);
578                                   /* L:      table key */
579   XBT_DEBUG("__index of '%s' begins", key);
580
581   /* want a global or a registry value? */
582   int pseudo_index;
583   if (lua_compare(L, 1, LUA_REGISTRYINDEX, LUA_OPEQ)) {
584     /* registry */
585     pseudo_index = LUA_REGISTRYINDEX;
586     XBT_DEBUG("Will get the value from the registry of maestro");
587   }
588   else {
589     /* global */
590     pseudo_index = lua_getfield(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
591     XBT_DEBUG("Will get the value from the globals of maestro");
592   }
593
594   /* get the father */
595   lua_State* maestro = sglua_get_maestro();
596
597                                   /* L:      table key */
598
599   /* get the value from maestro */
600   lua_getfield(maestro, pseudo_index, key);
601                                   /* maestro: ... value */
602
603   /* push the value onto the stack of L */
604   sglua_move_value(maestro, L);
605                                   /* maestro: ...
606                                      L:      table key value */
607
608   /* prepare the return value of __index */
609   lua_pushvalue(L, -1);
610                                   /* L:      table key value value */
611   lua_insert(L, 1);
612                                   /* L:      value table key value */
613
614   /* save the copied value in the table for subsequent accesses */
615   lua_settable(L, -3);
616                                   /* L:      value table */
617   lua_settop(L, 1);
618                                   /* L:      value */
619
620   XBT_DEBUG("__index of '%s' returns %s", key, sglua_tostring(L, -1));
621
622   return 1;
623 }
624
625 /**
626  * @brief Creates a new Lua state and get its environment from the maestro
627  * state.
628  *
629  * The state created is independent from maestro and has its own copies of
630  * global and registry values.
631  * However, the global and registry values are not copied right now from
632  * the original state; they are copied only the first time they are accessed.
633  * This behavior saves time and memory, and is okay for Simgrid's needs.
634  *
635  * TODO: if the simulation runs in parallel, copy everything right now?
636  *
637  * @return the state created
638  */
639 lua_State* sglua_clone_maestro(void) {
640
641   /* create the new state */
642   lua_State *L = luaL_newstate();
643
644   /* set its environment and its registry:
645    * - create a table newenv
646    * - create a metatable mt
647    * - set mt.__index = a function that copies the global from the father state
648    * - set mt as the metatable of the registry
649    * - set mt as the metatable of newenv
650    * - set newenv as the environment of the new state
651    */
652   lua_pushthread(L);                        /* thread */
653   lua_newtable(L);                          /* thread newenv */
654   lua_newtable(L);                          /* thread newenv mt */
655   lua_pushvalue(L, LUA_REGISTRYINDEX);      /* thread newenv mt reg */
656   lua_pushcfunction(L, l_get_from_maestro); /* thread newenv mt reg f */
657   lua_setfield(L, -3, "__index");           /* thread newenv mt reg */
658   lua_pushvalue(L, -2);                     /* thread newenv mt reg mt */
659   lua_setmetatable(L, -2);                  /* thread newenv mt reg */
660   lua_pop(L, 1);                            /* thread newenv mt */
661   lua_setmetatable(L, -2);                  /* thread newenv */
662   // TODO c.heinrich This needs to be re-implemented
663   /*lua_setfenv(L, -2);                       [> thread <]*/
664   lua_pop(L, 1);                            /* -- */
665
666   /* create the table of known tables from maestro */
667   lua_pushstring(L, "simgrid.maestro_tables");
668                                             /* "simgrid.maestro_tables" */
669   lua_newtable(L);                          /* "simgrid.maestro_tables" maestrotbs */
670   lua_rawset(L, LUA_REGISTRYINDEX);
671                                             /* -- */
672
673   /* opening the standard libs is not necessary as they are
674    * inherited like any global values */
675   /* luaL_openlibs(L); */
676
677   XBT_DEBUG("New state created");
678
679   return L;
680 }