luaa.c

   1 /*
   2  * luaa.c - Lua configuration management
   3  *
   4  * Copyright © 2008-2009 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #define _GNU_SOURCE
  23
  24 #include <ev.h>
  25
  26 #include <lua.h>
  27 #include <lauxlib.h>
  28 #include <lualib.h>
  29
  30 #include <basedir_fs.h>
  31
  32 #include "awesome.h"
  33 #include "config.h"
  34 #include "objects/timer.h"
  35 #include "awesome-version-internal.h"
  36 #include "ewmh.h"
  37 #include "luaa.h"
  38 #include "spawn.h"
  39 #include "objects/tag.h"
  40 #include "objects/client.h"
  41 #include "objects/drawin.h"
  42 #include "screen.h"
  43 #include "event.h"
  44 #include "selection.h"
  45 #include "systray.h"
  46 #include "common/xcursor.h"
  47 #include "common/buffer.h"
  48 #include "common/backtrace.h"
  49
  50 #ifdef WITH_DBUS
  51 extern const struct luaL_reg awesome_dbus_lib[];
  52 #endif
  53 extern const struct luaL_reg awesome_keygrabber_lib[];
  54 extern const struct luaL_reg awesome_mousegrabber_lib[];
  55 extern const struct luaL_reg awesome_root_lib[];
  56 extern const struct luaL_reg awesome_mouse_methods[];
  57 extern const struct luaL_reg awesome_mouse_meta[];
  58 extern const struct luaL_reg awesome_screen_methods[];
  59 extern const struct luaL_reg awesome_screen_meta[];
  60
  61 /** Path to config file */
  62 static char *conffile;
  63
  64 /** Quit awesome.
  65  * \param L The Lua VM state.
  66  * \return The number of elements pushed on stack.
  67  */
  68 static int
  69 luaA_quit(lua_State *L)
  70 {
  71     ev_unloop(globalconf.loop, 1);
  72     return 0;
  73 }
  74
  75 /** Execute another application, probably a window manager, to replace
  76  * awesome.
  77  * \param L The Lua VM state.
  78  * \return The number of elements pushed on stack.
  79  * \luastack
  80  * \lparam The command line to execute.
  81  */
  82 static int
  83 luaA_exec(lua_State *L)
  84 {
  85     const char *cmd = luaL_checkstring(L, 1);
  86
  87     awesome_atexit(false);
  88
  89     a_exec(cmd);
  90     return 0;
  91 }
  92
  93 /** Restart awesome.
  94  */
  95 static int
  96 luaA_restart(lua_State *L)
  97 {
  98     awesome_restart();
  99     return 0;
 100 }
 101
 102 /** Load an image from a given path.
 103  * \param L The Lua VM state.
 104  * \return The number of elements pushed on stack.
 105  * \luastack
 106  * \lparam The command line to execute.
 107  */
 108 static int
 109 luaA_load_image(lua_State *L)
 110 {
 111     const char *filename = luaL_checkstring(L, 1);
 112     return draw_load_image(L, filename);
 113 }
 114
 115 /** UTF-8 aware string length computing.
 116  * \param L The Lua VM state.
 117  * \return The number of elements pushed on stack.
 118  */
 119 static int
 120 luaA_mbstrlen(lua_State *L)
 121 {
 122     const char *cmd = luaL_checkstring(L, 1);
 123     lua_pushnumber(L, (ssize_t) mbstowcs(NULL, NONULL(cmd), 0));
 124     return 1;
 125 }
 126
 127 /** Overload standard Lua next function to use __next key on metatable.
 128  * \param L The Lua VM state.
 129  * \return The number of elements pushed on stack.
 130  */
 131 static int
 132 luaAe_next(lua_State *L)
 133 {
 134     if(luaL_getmetafield(L, 1, "__next"))
 135     {
 136         lua_insert(L, 1);
 137         lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
 138         return lua_gettop(L);
 139     }
 140
 141     luaL_checktype(L, 1, LUA_TTABLE);
 142     lua_settop(L, 2);
 143     if(lua_next(L, 1))
 144         return 2;
 145     lua_pushnil(L);
 146     return 1;
 147 }
 148
 149 /** Overload lua_next() function by using __next metatable field
 150  * to get next elements.
 151  * \param L The Lua VM stack.
 152  * \param idx The index number of elements in stack.
 153  * \return 1 if more elements to come, 0 otherwise.
 154  */
 155 static int
 156 luaA_next(lua_State *L, int idx)
 157 {
 158     if(luaL_getmetafield(L, idx, "__next"))
 159     {
 160         /* if idx is relative, reduce it since we got __next */
 161         if(idx < 0) idx--;
 162         /* copy table and then move key */
 163         lua_pushvalue(L, idx);
 164         lua_pushvalue(L, -3);
 165         lua_remove(L, -4);
 166         lua_pcall(L, 2, 2, 0);
 167         /* next returned nil, it's the end */
 168         if(lua_isnil(L, -1))
 169         {
 170             /* remove nil */
 171             lua_pop(L, 2);
 172             return 0;
 173         }
 174         return 1;
 175     }
 176     else if(lua_istable(L, idx))
 177         return lua_next(L, idx);
 178     /* remove the key */
 179     lua_pop(L, 1);
 180     return 0;
 181 }
 182
 183 /** Generic pairs function.
 184  * \param L The Lua VM state.
 185  * \return The number of elements pushed on stack.
 186  */
 187 static int
 188 luaA_generic_pairs(lua_State *L)
 189 {
 190     lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
 191     lua_pushvalue(L, 1);  /* state, */
 192     lua_pushnil(L);  /* and initial value */
 193     return 3;
 194 }
 195
 196 /** Overload standard pairs function to use __pairs field of metatables.
 197  * \param L The Lua VM state.
 198  * \return The number of elements pushed on stack.
 199  */
 200 static int
 201 luaAe_pairs(lua_State *L)
 202 {
 203     if(luaL_getmetafield(L, 1, "__pairs"))
 204     {
 205         lua_insert(L, 1);
 206         lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
 207         return lua_gettop(L);
 208     }
 209
 210     luaL_checktype(L, 1, LUA_TTABLE);
 211     return luaA_generic_pairs(L);
 212 }
 213
 214 static int
 215 luaA_ipairs_aux(lua_State *L)
 216 {
 217     int i = luaL_checkint(L, 2) + 1;
 218     luaL_checktype(L, 1, LUA_TTABLE);
 219     lua_pushinteger(L, i);
 220     lua_rawgeti(L, 1, i);
 221     return (lua_isnil(L, -1)) ? 0 : 2;
 222 }
 223
 224 /** Overload standard ipairs function to use __ipairs field of metatables.
 225  * \param L The Lua VM state.
 226  * \return The number of elements pushed on stack.
 227  */
 228 static int
 229 luaAe_ipairs(lua_State *L)
 230 {
 231     if(luaL_getmetafield(L, 1, "__ipairs"))
 232     {
 233         lua_insert(L, 1);
 234         lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
 235         return lua_gettop(L);
 236     }
 237
 238     luaL_checktype(L, 1, LUA_TTABLE);
 239     lua_pushvalue(L, lua_upvalueindex(1));
 240     lua_pushvalue(L, 1);
 241     lua_pushinteger(L, 0);  /* and initial value */
 242     return 3;
 243 }
 244
 245 /** Enhanced type() function which recognize awesome objects.
 246  * \param L The Lua VM state.
 247  * \return The number of arguments pushed on the stack.
 248  */
 249 static int
 250 luaAe_type(lua_State *L)
 251 {
 252     luaL_checkany(L, 1);
 253     lua_pushstring(L, luaA_typename(L, 1));
 254     return 1;
 255 }
 256
 257 /** Replace various standards Lua functions with our own.
 258  * \param L The Lua VM state.
 259  */
 260 static void
 261 luaA_fixups(lua_State *L)
 262 {
 263     /* export string.wlen */
 264     lua_getglobal(L, "string");
 265     lua_pushcfunction(L, luaA_mbstrlen);
 266     lua_setfield(L, -2, "wlen");
 267     lua_pop(L, 1);
 268     /* replace next */
 269     lua_pushliteral(L, "next");
 270     lua_pushcfunction(L, luaAe_next);
 271     lua_settable(L, LUA_GLOBALSINDEX);
 272     /* replace pairs */
 273     lua_pushliteral(L, "pairs");
 274     lua_pushcfunction(L, luaAe_next);
 275     lua_pushcclosure(L, luaAe_pairs, 1); /* pairs get next as upvalue */
 276     lua_settable(L, LUA_GLOBALSINDEX);
 277     /* replace ipairs */
 278     lua_pushliteral(L, "ipairs");
 279     lua_pushcfunction(L, luaA_ipairs_aux);
 280     lua_pushcclosure(L, luaAe_ipairs, 1);
 281     lua_settable(L, LUA_GLOBALSINDEX);
 282     /* replace type */
 283     lua_pushliteral(L, "type");
 284     lua_pushcfunction(L, luaAe_type);
 285     lua_settable(L, LUA_GLOBALSINDEX);
 286     /* set selection */
 287     lua_pushliteral(L, "selection");
 288     lua_pushcfunction(L, luaA_selection_get);
 289     lua_settable(L, LUA_GLOBALSINDEX);
 290 }
 291
 292 /** Look for an item: table, function, etc.
 293  * \param L The Lua VM state.
 294  * \param item The pointer item.
 295  */
 296 bool
 297 luaA_hasitem(lua_State *L, const void *item)
 298 {
 299     lua_pushnil(L);
 300     while(luaA_next(L, -2))
 301     {
 302         if(lua_topointer(L, -1) == item)
 303         {
 304             /* remove value and key */
 305             lua_pop(L, 2);
 306             return true;
 307         }
 308         if(lua_istable(L, -1))
 309             if(luaA_hasitem(L, item))
 310             {
 311                 /* remove key and value */
 312                 lua_pop(L, 2);
 313                 return true;
 314             }
 315         /* remove value */
 316         lua_pop(L, 1);
 317     }
 318     return false;
 319 }
 320
 321 /** Browse a table pushed on top of the index, and put all its table and
 322  * sub-table into an array.
 323  * \param L The Lua VM state.
 324  * \param elems The elements array.
 325  * \return False if we encounter an elements already in list.
 326  */
 327 static bool
 328 luaA_isloop_check(lua_State *L, cptr_array_t *elems)
 329 {
 330     if(lua_istable(L, -1))
 331     {
 332         const void *object = lua_topointer(L, -1);
 333
 334         /* Check that the object table is not already in the list */
 335         for(int i = 0; i < elems->len; i++)
 336             if(elems->tab[i] == object)
 337                 return false;
 338
 339         /* push the table in the elements list */
 340         cptr_array_append(elems, object);
 341
 342         /* look every object in the "table" */
 343         lua_pushnil(L);
 344         while(luaA_next(L, -2))
 345         {
 346             if(!luaA_isloop_check(L, elems))
 347             {
 348                 /* remove key and value */
 349                 lua_pop(L, 2);
 350                 return false;
 351             }
 352             /* remove value, keep key for next iteration */
 353             lua_pop(L, 1);
 354         }
 355     }
 356     return true;
 357 }
 358
 359 /** Check if a table is a loop. When using tables as direct acyclic digram,
 360  * this is useful.
 361  * \param L The Lua VM state.
 362  * \param idx The index of the table in the stack
 363  * \return True if the table loops.
 364  */
 365 bool
 366 luaA_isloop(lua_State *L, int idx)
 367 {
 368     /* elems is an elements array that we will fill with all array we
 369      * encounter while browsing the tables */
 370     cptr_array_t elems;
 371
 372     cptr_array_init(&elems);
 373
 374     /* push table on top */
 375     lua_pushvalue(L, idx);
 376
 377     bool ret = luaA_isloop_check(L, &elems);
 378
 379     /* remove pushed table */
 380     lua_pop(L, 1);
 381
 382     cptr_array_wipe(&elems);
 383
 384     return !ret;
 385 }
 386
 387 /** awesome global table.
 388  * \param L The Lua VM state.
 389  * \return The number of elements pushed on stack.
 390  * \luastack
 391  * \lfield font The default font.
 392  * \lfield font_height The default font height.
 393  * \lfield conffile The configuration file which has been loaded.
 394  */
 395 static int
 396 luaA_awesome_index(lua_State *L)
 397 {
 398     if(luaA_usemetatable(L, 1, 2))
 399         return 1;
 400
 401     const char *buf = luaL_checkstring(L, 2);
 402
 403     if(A_STREQ(buf, "conffile"))
 404     {
 405         lua_pushstring(L, conffile);
 406         return 1;
 407     }
 408
 409     if(A_STREQ(buf, "version"))
 410     {
 411         lua_pushliteral(L, AWESOME_VERSION);
 412         return 1;
 413     }
 414
 415     if(A_STREQ(buf, "release"))
 416     {
 417         lua_pushliteral(L, AWESOME_RELEASE);
 418         return 1;
 419     }
 420
 421     if(A_STREQ(buf, "startup_errors") && globalconf.startup_errors.len != 0)
 422     {
 423         lua_pushstring(L, globalconf.startup_errors.s);
 424         return 1;
 425     }
 426
 427     return 0;
 428 }
 429
 430 /** Add a global signal.
 431  * \param L The Lua VM state.
 432  * \return The number of elements pushed on stack.
 433  * \luastack
 434  * \lparam A string with the event name.
 435  * \lparam The function to call.
 436  */
 437 static int
 438 luaA_awesome_connect_signal(lua_State *L)
 439 {
 440     const char *name = luaL_checkstring(L, 1);
 441     luaA_checkfunction(L, 2);
 442     signal_connect(&global_signals, name, luaA_object_ref(L, 2));
 443     return 0;
 444 }
 445
 446 /** Remove a global signal.
 447  * \param L The Lua VM state.
 448  * \return The number of elements pushed on stack.
 449  * \luastack
 450  * \lparam A string with the event name.
 451  * \lparam The function to call.
 452  */
 453 static int
 454 luaA_awesome_disconnect_signal(lua_State *L)
 455 {
 456     const char *name = luaL_checkstring(L, 1);
 457     luaA_checkfunction(L, 2);
 458     const void *func = lua_topointer(L, 2);
 459     signal_disconnect(&global_signals, name, func);
 460     luaA_object_unref(L, (void *) func);
 461     return 0;
 462 }
 463
 464 /** Emit a global signal.
 465  * \param L The Lua VM state.
 466  * \return The number of elements pushed on stack.
 467  * \luastack
 468  * \lparam A string with the event name.
 469  * \lparam The function to call.
 470  */
 471 static int
 472 luaA_awesome_emit_signal(lua_State *L)
 473 {
 474     signal_object_emit(L, &global_signals, luaL_checkstring(L, 1), lua_gettop(L) - 1);
 475     return 0;
 476 }
 477
 478 static int
 479 luaA_panic(lua_State *L)
 480 {
 481     warn("unprotected error in call to Lua API (%s)",
 482          lua_tostring(L, -1));
 483     buffer_t buf;
 484     backtrace_get(&buf);
 485     warn("dumping backtrace\n%s", buf.s);
 486     warn("restarting awesome");
 487     awesome_restart();
 488     return 0;
 489 }
 490
 491 static int
 492 luaA_dofunction_on_error(lua_State *L)
 493 {
 494     /* duplicate string error */
 495     lua_pushvalue(L, -1);
 496     /* emit error signal */
 497     signal_object_emit(L, &global_signals, "debug::error", 1);
 498
 499     if(!luaL_dostring(L, "return debug.traceback(\"error while running function\", 3)"))
 500     {
 501         /* Move traceback before error */
 502         lua_insert(L, -2);
 503         /* Insert sentence */
 504         lua_pushliteral(L, "\nerror: ");
 505         /* Move it before error */
 506         lua_insert(L, -2);
 507         lua_concat(L, 3);
 508     }
 509     return 1;
 510 }
 511
 512 /** Initialize the Lua VM
 513  * \param xdg An xdg handle to use to get XDG basedir.
 514  */
 515 void
 516 luaA_init(xdgHandle* xdg)
 517 {
 518     lua_State *L;
 519     static const struct luaL_reg awesome_lib[] =
 520     {
 521         { "quit", luaA_quit },
 522         { "exec", luaA_exec },
 523         { "spawn", luaA_spawn },
 524         { "restart", luaA_restart },
 525         { "connect_signal", luaA_awesome_connect_signal },
 526         { "disconnect_signal", luaA_awesome_disconnect_signal },
 527         { "emit_signal", luaA_awesome_emit_signal },
 528         { "systray", luaA_systray },
 529         { "load_image", luaA_load_image },
 530         { "__index", luaA_awesome_index },
 531         { NULL, NULL }
 532     };
 533
 534     L = globalconf.L = luaL_newstate();
 535
 536     /* Set panic function */
 537     lua_atpanic(L, luaA_panic);
 538
 539     /* Set error handling function */
 540     lualib_dofunction_on_error = luaA_dofunction_on_error;
 541
 542     luaL_openlibs(L);
 543
 544     luaA_fixups(L);
 545
 546     luaA_object_setup(L);
 547
 548     /* Export awesome lib */
 549     luaA_openlib(L, "awesome", awesome_lib, awesome_lib);
 550
 551     /* Export root lib */
 552     luaL_register(L, "root", awesome_root_lib);
 553     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 554
 555 #ifdef WITH_DBUS
 556     /* Export D-Bus lib */
 557     luaL_register(L, "dbus", awesome_dbus_lib);
 558     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 559 #endif
 560
 561     /* Export keygrabber lib */
 562     luaL_register(L, "keygrabber", awesome_keygrabber_lib);
 563     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 564
 565     /* Export mousegrabber lib */
 566     luaL_register(L, "mousegrabber", awesome_mousegrabber_lib);
 567     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 568
 569     /* Export screen */
 570     luaA_openlib(L, "screen", awesome_screen_methods, awesome_screen_meta);
 571
 572     /* Export mouse */
 573     luaA_openlib(L, "mouse", awesome_mouse_methods, awesome_mouse_meta);
 574
 575     /* Export button */
 576     button_class_setup(L);
 577
 578     /* Export tag */
 579     tag_class_setup(L);
 580
 581     /* Export window */
 582     window_class_setup(L);
 583
 584     /* Export drawin */
 585     drawin_class_setup(L);
 586
 587     /* Export client */
 588     client_class_setup(L);
 589
 590     /* Export keys */
 591     key_class_setup(L);
 592
 593     /* Export timer */
 594     timer_class_setup(L);
 595
 596     /* add Lua search paths */
 597     lua_getglobal(L, "package");
 598     if (LUA_TTABLE != lua_type(L, 1))
 599     {
 600         warn("package is not a table");
 601         return;
 602     }
 603     lua_getfield(L, 1, "path");
 604     if (LUA_TSTRING != lua_type(L, 2))
 605     {
 606         warn("package.path is not a string");
 607         lua_pop(L, 1);
 608         return;
 609     }
 610
 611     /* add XDG_CONFIG_DIR as include path */
 612     const char * const *xdgconfigdirs = xdgSearchableConfigDirectories(xdg);
 613     for(; *xdgconfigdirs; xdgconfigdirs++)
 614     {
 615         size_t len = a_strlen(*xdgconfigdirs);
 616         lua_pushliteral(L, ";");
 617         lua_pushlstring(L, *xdgconfigdirs, len);
 618         lua_pushliteral(L, "/awesome/?.lua");
 619         lua_concat(L, 3);
 620
 621         lua_pushliteral(L, ";");
 622         lua_pushlstring(L, *xdgconfigdirs, len);
 623         lua_pushliteral(L, "/awesome/?/init.lua");
 624         lua_concat(L, 3);
 625
 626         lua_concat(L, 3); /* concatenate with package.path */
 627     }
 628
 629     /* add Lua lib path (/usr/share/awesome/lib by default) */
 630     lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?.lua");
 631     lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?/init.lua");
 632     lua_concat(L, 3); /* concatenate with package.path */
 633     lua_setfield(L, 1, "path"); /* package.path = "concatenated string" */
 634
 635     lua_getfield(L, 1, "loaded");
 636
 637     lua_pop(L, 2); /* pop "package" and "package.loaded" */
 638
 639     signal_add(&global_signals, "debug::error");
 640     signal_add(&global_signals, "debug::deprecation");
 641     signal_add(&global_signals, "debug::index::miss");
 642     signal_add(&global_signals, "debug::newindex::miss");
 643     signal_add(&global_signals, "systray::update");
 644     signal_add(&global_signals, "wallpaper_changed");
 645     signal_add(&global_signals, "refresh");
 646     signal_add(&global_signals, "exit");
 647 }
 648
 649 static void
 650 luaA_startup_error(const char *err)
 651 {
 652     if (globalconf.startup_errors.len > 0)
 653         buffer_addsl(&globalconf.startup_errors, "\n\n");
 654     buffer_adds(&globalconf.startup_errors, err);
 655 }
 656
 657 static bool
 658 luaA_loadrc(const char *confpath, bool run)
 659 {
 660     if(!luaL_loadfile(globalconf.L, confpath))
 661     {
 662         if(run)
 663         {
 664             /* Set the conffile right now so it can be used inside the
 665              * configuration file. */
 666             conffile = a_strdup(confpath);
 667             if(lua_pcall(globalconf.L, 0, LUA_MULTRET, 0))
 668             {
 669                 const char *err = lua_tostring(globalconf.L, -1);
 670                 luaA_startup_error(err);
 671                 fprintf(stderr, "%s\n", err);
 672                 /* An error happened, so reset this. */
 673                 conffile = NULL;
 674             }
 675             else
 676                 return true;
 677         }
 678         else
 679         {
 680             lua_pop(globalconf.L, 1);
 681             return true;
 682         }
 683     }
 684     else
 685     {
 686         const char *err = lua_tostring(globalconf.L, -1);
 687         luaA_startup_error(err);
 688         fprintf(stderr, "%s\n", err);
 689     }
 690
 691     return false;
 692 }
 693
 694 /** Load a configuration file.
 695  * \param xdg An xdg handle to use to get XDG basedir.
 696  * \param confpatharg The configuration file to load.
 697  * \param run Run the configuration file.
 698  */
 699 bool
 700 luaA_parserc(xdgHandle* xdg, const char *confpatharg, bool run)
 701 {
 702     char *confpath = NULL;
 703     bool ret = false;
 704
 705     /* try to load, return if it's ok */
 706     if(confpatharg)
 707     {
 708         if(luaA_loadrc(confpatharg, run))
 709         {
 710             ret = true;
 711             goto bailout;
 712         }
 713         else if(!run)
 714             goto bailout;
 715     }
 716
 717     confpath = xdgConfigFind("awesome/rc.lua", xdg);
 718
 719     char *tmp = confpath;
 720
 721     /* confpath is "string1\0string2\0string3\0\0" */
 722     while(*tmp)
 723     {
 724         if(luaA_loadrc(tmp, run))
 725         {
 726             ret = true;
 727             goto bailout;
 728         }
 729         else if(!run)
 730             goto bailout;
 731         tmp += a_strlen(tmp) + 1;
 732     }
 733
 734 bailout:
 735
 736     p_delete(&confpath);
 737
 738     return ret;
 739 }
 740
 741 int
 742 luaA_class_index_miss_property(lua_State *L, lua_object_t *obj)
 743 {
 744     signal_object_emit(L, &global_signals, "debug::index::miss", 2);
 745     return 0;
 746 }
 747
 748 int
 749 luaA_class_newindex_miss_property(lua_State *L, lua_object_t *obj)
 750 {
 751     signal_object_emit(L, &global_signals, "debug::newindex::miss", 3);
 752     return 0;
 753 }
 754
 755 void
 756 luaA_emit_refresh()
 757 {
 758     signal_object_emit(globalconf.L, &global_signals, "refresh", 0);
 759 }
 760
 761 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80