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