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();
  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, "font") == 0)
 394     {
 395         char *font = pango_font_description_to_string(globalconf.font->desc);
 396         lua_pushstring(L, font);
 397         g_free(font);
 398     }
 399     else if(a_strcmp(buf, "font_height") == 0)
 400         lua_pushnumber(L, globalconf.font->height);
 401     else if(a_strcmp(buf, "conffile") == 0)
 402         lua_pushstring(L, conffile);
 403     else if(a_strcmp(buf, "fg") == 0)
 404         luaA_pushxcolor(L, globalconf.colors.fg);
 405     else if(a_strcmp(buf, "bg") == 0)
 406         luaA_pushxcolor(L, globalconf.colors.bg);
 407     else if(a_strcmp(buf, "version") == 0)
 408         lua_pushliteral(L, AWESOME_VERSION);
 409     else if(a_strcmp(buf, "release") == 0)
 410         lua_pushliteral(L, AWESOME_RELEASE);
 411     else
 412         return 0;
 413
 414     return 1;
 415 }
 416
 417 /** Newindex function for the awesome global table.
 418  * \param L The Lua VM state.
 419  * \return The number of elements pushed on stack.
 420  */
 421 static int
 422 luaA_awesome_newindex(lua_State *L)
 423 {
 424     if(luaA_usemetatable(L, 1, 2))
 425         return 1;
 426
 427     const char *buf = luaL_checkstring(L, 2);
 428
 429     if(a_strcmp(buf, "font") == 0)
 430     {
 431         const char *newfont = luaL_checkstring(L, 3);
 432         font_delete(&globalconf.font);
 433         globalconf.font = font_new(newfont);
 434     }
 435     else if(a_strcmp(buf, "fg") == 0)
 436     {
 437         size_t len;
 438         if((buf = luaL_checklstring(L, 3, &len)))
 439            xcolor_init_reply(xcolor_init_unchecked(&globalconf.colors.fg, buf, len));
 440     }
 441     else if(a_strcmp(buf, "bg") == 0)
 442     {
 443         size_t len;
 444         if((buf = luaL_checklstring(L, 3, &len)))
 445            xcolor_init_reply(xcolor_init_unchecked(&globalconf.colors.bg, buf, len));
 446     }
 447
 448     return 0;
 449 }
 450
 451 /** Add a global signal.
 452  * \param L The Lua VM state.
 453  * \return The number of elements pushed on stack.
 454  * \luastack
 455  * \lparam A string with the event name.
 456  * \lparam The function to call.
 457  */
 458 static int
 459 luaA_awesome_connect_signal(lua_State *L)
 460 {
 461     const char *name = luaL_checkstring(L, 1);
 462     luaA_checkfunction(L, 2);
 463     signal_connect(&global_signals, name, luaA_object_ref(L, 2));
 464     return 0;
 465 }
 466
 467 /** Remove a global signal.
 468  * \param L The Lua VM state.
 469  * \return The number of elements pushed on stack.
 470  * \luastack
 471  * \lparam A string with the event name.
 472  * \lparam The function to call.
 473  */
 474 static int
 475 luaA_awesome_disconnect_signal(lua_State *L)
 476 {
 477     const char *name = luaL_checkstring(L, 1);
 478     luaA_checkfunction(L, 2);
 479     const void *func = lua_topointer(L, 2);
 480     signal_disconnect(&global_signals, name, func);
 481     luaA_object_unref(L, (void *) func);
 482     return 0;
 483 }
 484
 485 /** Emit a global signal.
 486  * \param L The Lua VM state.
 487  * \return The number of elements pushed on stack.
 488  * \luastack
 489  * \lparam A string with the event name.
 490  * \lparam The function to call.
 491  */
 492 static int
 493 luaA_awesome_emit_signal(lua_State *L)
 494 {
 495     signal_object_emit(L, &global_signals, luaL_checkstring(L, 1), lua_gettop(L) - 1);
 496     return 0;
 497 }
 498
 499 static int
 500 luaA_panic(lua_State *L)
 501 {
 502     warn("unprotected error in call to Lua API (%s)",
 503          lua_tostring(L, -1));
 504     buffer_t buf;
 505     backtrace_get(&buf);
 506     warn("dumping backtrace\n%s", buf.s);
 507     warn("restarting awesome");
 508     awesome_restart();
 509     return 0;
 510 }
 511
 512 static int
 513 luaA_dofunction_on_error(lua_State *L)
 514 {
 515     /* duplicate string error */
 516     lua_pushvalue(L, -1);
 517     /* emit error signal */
 518     signal_object_emit(L, &global_signals, "debug::error", 1);
 519
 520     if(!luaL_dostring(L, "return debug.traceback(\"error while running function\", 3)"))
 521     {
 522         /* Move traceback before error */
 523         lua_insert(L, -2);
 524         /* Insert sentence */
 525         lua_pushliteral(L, "\nerror: ");
 526         /* Move it before error */
 527         lua_insert(L, -2);
 528         lua_concat(L, 3);
 529     }
 530     return 1;
 531 }
 532
 533 /** Initialize the Lua VM
 534  * \param xdg An xdg handle to use to get XDG basedir.
 535  */
 536 void
 537 luaA_init(xdgHandle* xdg)
 538 {
 539     lua_State *L;
 540     static const struct luaL_reg awesome_lib[] =
 541     {
 542         { "quit", luaA_quit },
 543         { "exec", luaA_exec },
 544         { "spawn", luaA_spawn },
 545         { "restart", luaA_restart },
 546         { "connect_signal", luaA_awesome_connect_signal },
 547         { "disconnect_signal", luaA_awesome_disconnect_signal },
 548         { "emit_signal", luaA_awesome_emit_signal },
 549         { "systray", luaA_systray },
 550         { "__index", luaA_awesome_index },
 551         { "__newindex", luaA_awesome_newindex },
 552         { NULL, NULL }
 553     };
 554
 555     L = globalconf.L = luaL_newstate();
 556
 557     /* Set panic function */
 558     lua_atpanic(L, luaA_panic);
 559
 560     /* Set error handling function */
 561     lualib_dofunction_on_error = luaA_dofunction_on_error;
 562
 563     luaL_openlibs(L);
 564
 565     luaA_fixups(L);
 566
 567     luaA_object_setup(L);
 568
 569     /* Export awesome lib */
 570     luaA_openlib(L, "awesome", awesome_lib, awesome_lib);
 571
 572     /* Export root lib */
 573     luaL_register(L, "root", awesome_root_lib);
 574     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 575
 576 #ifdef WITH_DBUS
 577     /* Export D-Bus lib */
 578     luaL_register(L, "dbus", awesome_dbus_lib);
 579     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 580 #endif
 581
 582     /* Export keygrabber lib */
 583     luaL_register(L, "keygrabber", awesome_keygrabber_lib);
 584     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 585
 586     /* Export mousegrabber lib */
 587     luaL_register(L, "mousegrabber", awesome_mousegrabber_lib);
 588     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 589
 590     /* Export screen */
 591     luaA_openlib(L, "screen", awesome_screen_methods, awesome_screen_meta);
 592
 593     /* Export mouse */
 594     luaA_openlib(L, "mouse", awesome_mouse_methods, awesome_mouse_meta);
 595
 596     /* Export button */
 597     button_class_setup(L);
 598
 599     /* Export tag */
 600     tag_class_setup(L);
 601
 602     /* Export window */
 603     window_class_setup(L);
 604
 605     /* Export drawin */
 606     drawin_class_setup(L);
 607
 608     /* Export client */
 609     client_class_setup(L);
 610
 611     /* Export keys */
 612     key_class_setup(L);
 613
 614     /* Export timer */
 615     timer_class_setup(L);
 616
 617     /* add Lua search paths */
 618     lua_getglobal(L, "package");
 619     if (LUA_TTABLE != lua_type(L, 1))
 620     {
 621         warn("package is not a table");
 622         return;
 623     }
 624     lua_getfield(L, 1, "path");
 625     if (LUA_TSTRING != lua_type(L, 2))
 626     {
 627         warn("package.path is not a string");
 628         lua_pop(L, 1);
 629         return;
 630     }
 631
 632     /* add XDG_CONFIG_DIR as include path */
 633     const char * const *xdgconfigdirs = xdgSearchableConfigDirectories(xdg);
 634     for(; *xdgconfigdirs; xdgconfigdirs++)
 635     {
 636         size_t len = a_strlen(*xdgconfigdirs);
 637         lua_pushliteral(L, ";");
 638         lua_pushlstring(L, *xdgconfigdirs, len);
 639         lua_pushliteral(L, "/awesome/?.lua");
 640         lua_concat(L, 3);
 641
 642         lua_pushliteral(L, ";");
 643         lua_pushlstring(L, *xdgconfigdirs, len);
 644         lua_pushliteral(L, "/awesome/?/init.lua");
 645         lua_concat(L, 3);
 646
 647         lua_concat(L, 3); /* concatenate with package.path */
 648     }
 649
 650     /* add Lua lib path (/usr/share/awesome/lib by default) */
 651     lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?.lua");
 652     lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?/init.lua");
 653     lua_concat(L, 3); /* concatenate with package.path */
 654     lua_setfield(L, 1, "path"); /* package.path = "concatenated string" */
 655
 656     lua_getfield(L, 1, "loaded");
 657
 658     /* Load oocairo */
 659     if (luaopen_oocairo(L) != 1)
 660         fatal("Loading oocairo failed");
 661     lua_pushvalue(L, 3); /* Copy the module */
 662     lua_setglobal(L, "oocairo"); /* Set the global entry */
 663     lua_setfield(L, 2, "oocairo"); /* Make it require()able */
 664
 665     /* Load oopango */
 666     if (luaopen_oopango(L) != 1)
 667         fatal("Loading oopango failed");
 668     lua_pushvalue(L, 3); /* Copy the module */
 669     lua_setglobal(L, "oopango"); /* Set the global entry */
 670     lua_setfield(L, 2, "oopango"); /* Make it require()able */
 671
 672     lua_pop(L, 2); /* pop "package" and "package.loaded" */
 673
 674     signal_add(&global_signals, "debug::error");
 675     signal_add(&global_signals, "debug::index::miss");
 676     signal_add(&global_signals, "debug::newindex::miss");
 677     signal_add(&global_signals, "systray::update");
 678     signal_add(&global_signals, "exit");
 679 }
 680
 681 static bool
 682 luaA_loadrc(const char *confpath, bool run)
 683 {
 684     if(!luaL_loadfile(globalconf.L, confpath))
 685     {
 686         if(run)
 687         {
 688             if(lua_pcall(globalconf.L, 0, LUA_MULTRET, 0))
 689                 fprintf(stderr, "%s\n", lua_tostring(globalconf.L, -1));
 690             else
 691             {
 692                 conffile = a_strdup(confpath);
 693                 return true;
 694             }
 695         }
 696         else
 697         {
 698             lua_pop(globalconf.L, 1);
 699             return true;
 700         }
 701     }
 702     else
 703         fprintf(stderr, "%s\n", lua_tostring(globalconf.L, -1));
 704
 705     return false;
 706 }
 707
 708 /** Load a configuration file.
 709  * \param xdg An xdg handle to use to get XDG basedir.
 710  * \param confpatharg The configuration file to load.
 711  * \param run Run the configuration file.
 712  */
 713 bool
 714 luaA_parserc(xdgHandle* xdg, const char *confpatharg, bool run)
 715 {
 716     char *confpath = NULL;
 717     bool ret = false;
 718
 719     /* try to load, return if it's ok */
 720     if(confpatharg)
 721     {
 722         if(luaA_loadrc(confpatharg, run))
 723         {
 724             ret = true;
 725             goto bailout;
 726         }
 727         else if(!run)
 728             goto bailout;
 729     }
 730
 731     confpath = xdgConfigFind("awesome/rc.lua", xdg);
 732
 733     char *tmp = confpath;
 734
 735     /* confpath is "string1\0string2\0string3\0\0" */
 736     while(*tmp)
 737     {
 738         if(luaA_loadrc(tmp, run))
 739         {
 740             ret = true;
 741             goto bailout;
 742         }
 743         else if(!run)
 744             goto bailout;
 745         tmp += a_strlen(tmp) + 1;
 746     }
 747
 748 bailout:
 749
 750     p_delete(&confpath);
 751
 752     return ret;
 753 }
 754
 755 int
 756 luaA_class_index_miss_property(lua_State *L, lua_object_t *obj)
 757 {
 758     signal_object_emit(L, &global_signals, "debug::index::miss", 2);
 759     return 0;
 760 }
 761
 762 int
 763 luaA_class_newindex_miss_property(lua_State *L, lua_object_t *obj)
 764 {
 765     signal_object_emit(L, &global_signals, "debug::newindex::miss", 3);
 766     return 0;
 767 }
 768
 769 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80