src/lua.c

   1 /* Lua scripting support
   2  *
   3  * Copyright (c) 2008 Sadrul Habib Chowdhury (sadrul@users.sf.net)
   4  * Copyright (c) 2009
   5  *      Sadrul Habib Chowdhury (sadrul@users.sf.net)
   6  *      Rui Guo (firemeteor.guo@gmail.com)
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program (see the file COPYING); if not, write to the
  20  * Free Software Foundation, Inc.,
  21  * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  22  *
  23  ****************************************************************
  24  */
  25 #include <sys/types.h>
  26 #include "config.h"
  27 #include "screen.h"
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <stdlib.h>
  34
  35 #include "extern.h"
  36 #include "logfile.h"
  37
  38 #include <lua.h>
  39 #include <lauxlib.h>
  40 #include <lualib.h>
  41
  42 static int StackDump(lua_State *L, const char *message)
  43 {
  44   FILE *f = fopen("/tmp/debug/stack", "ab");
  45   int i = lua_gettop(L);
  46   if (message)
  47     fprintf(f, "%s", message);
  48   while (i)
  49     {
  50       int t = lua_type(L, i);
  51       switch (t)
  52         {
  53           case LUA_TSTRING:
  54             fprintf(f, "String: %s\n", lua_tostring(L, i));
  55             break;
  56
  57           case LUA_TBOOLEAN:
  58             fprintf(f, "Boolean: %s\n", lua_toboolean(L, i) ? "true" : "false");
  59             break;
  60
  61           case LUA_TNUMBER:
  62             fprintf(f, "Number: %g\n", lua_tonumber(L, i));
  63             break;
  64
  65           default:
  66             fprintf(f, "Type: %s\n", lua_typename(L, t));
  67         }
  68       i--;
  69     }
  70   if (message)
  71     fprintf(f, "----\n");
  72   fclose(f);
  73   return 0;
  74 }
  75
  76 extern struct win *windows, *fore;
  77 extern struct display *displays, *display;
  78 extern struct LayFuncs WinLf;
  79 extern struct layer *flayer;
  80 extern void AppendWinMsgRend(const char *str, const char *color);
  81 extern void FocusCanvas(struct canvas *cv);
  82
  83 static int LuaDispatch(void *handler, const char *params, va_list va);
  84 static int LuaRegEvent(lua_State *L);
  85 static void LuaShowErr(lua_State *L);
  86 struct binding lua_binding;
  87
  88 enum
  89 {
  90   LUA_HANDLER_TYPE_N = 1,
  91   LUA_HANDLER_TYPE_F
  92 };
  93
  94 struct lua_handler
  95 {
  96   int type;
  97   lua_State *L;
  98   union
  99   {
 100     const char *name;
 101     int reference;
 102   } u;
 103 };
 104
 105 typedef struct lua_handler *lua_handler;
 106 void LuaPushHandler(lua_handler lh);
 107 void LuaHUnRef(lua_State *L, int key);
 108 lua_handler LuaCheckHandler(lua_State *L, int idx, int ref);
 109
 110 lua_handler
 111 LuaAllocHandler(lua_State *L, const char *name, int ref)
 112 {
 113   struct lua_handler *lh;
 114   lh = (struct lua_handler*) malloc(sizeof(struct lua_handler));
 115   if (!lh)
 116     return NULL;
 117
 118   lh->L = L;
 119   if (name)
 120     {
 121       lh->type = LUA_HANDLER_TYPE_N;
 122       lh->u.name = SaveStr(name);
 123     }
 124   else
 125     {
 126       lh->type = LUA_HANDLER_TYPE_F;
 127       lh->u.reference = ref;
 128     }
 129
 130   return lh;
 131 }
 132
 133 void
 134 LuaFreeHandler(lua_State *L, struct lua_handler **lh)
 135 {
 136   if ((*lh)->type == LUA_HANDLER_TYPE_N)
 137     Free((*lh)->u.name)
 138   else
 139     {
 140       LuaHUnRef(L, (*lh)->u.reference);
 141       (*lh)->u.reference = 0;
 142     }
 143   Free(*lh);
 144 }
 145 /** Template {{{ */
 146
 147 #define CHECK_TYPE(name, type) \
 148 static type * \
 149 check_##name(lua_State *L, int index) \
 150 { \
 151   struct broker **broker; \
 152   type *var; \
 153   luaL_checktype(L, index, LUA_TUSERDATA); \
 154   broker = (struct broker **) luaL_checkudata(L, index, #name); \
 155   if (broker) { \
 156       var = (type *)get_broker_obj(broker); \
 157   } \
 158   if (!broker || !*broker) \
 159     luaL_typerror(L, index, #name); \
 160   return var; \
 161 }
 162
 163 #define PUSH_TYPE(name, type) \
 164 static void \
 165 push_##name(lua_State *L, type **t) \
 166 { \
 167   if (!t || !*t) \
 168     lua_pushnil(L); \
 169   else \
 170     { \
 171       struct broker **r; \
 172       r = (struct broker **)lua_newuserdata(L, sizeof(struct broker *)); \
 173       *r = get_obj_broker(*t); \
 174       luaL_getmetatable(L, #name); \
 175       lua_setmetatable(L,-2); \
 176     } \
 177 }
 178
 179 /* Much of the following template comes from:
 180  *      http://lua-users.org/wiki/BindingWithMembersAndMethods
 181  */
 182
 183 static int get_int (lua_State *L, void *v)
 184 {
 185   lua_pushinteger (L, *(int*)v);
 186   return 1;
 187 }
 188
 189 static int set_int (lua_State *L, void *v)
 190 {
 191   *(int*)v = luaL_checkint(L, 3);
 192   return 0;
 193 }
 194
 195 static int get_number (lua_State *L, void *v)
 196 {
 197   lua_pushnumber(L, *(lua_Number*)v);
 198   return 1;
 199 }
 200
 201 static int set_number (lua_State *L, void *v)
 202 {
 203   *(lua_Number*)v = luaL_checknumber(L, 3);
 204   return 0;
 205 }
 206
 207 static int get_string (lua_State *L, void *v)
 208 {
 209   lua_pushstring(L, (char*)v );
 210   return 1;
 211 }
 212
 213 static int set_string (lua_State *L, void *v)
 214 {
 215   *(const char**)v = luaL_checkstring(L, 3);
 216   return 0;
 217 }
 218
 219 typedef int (*Xet_func) (lua_State *L, void *v);
 220
 221 /* member info for get and set handlers */
 222 struct Xet_reg
 223 {
 224   const char *name;  /* member name */
 225   Xet_func func;     /* get or set function for type of member */
 226   size_t offset;     /* offset of member within the struct */
 227   int (*absolute)(lua_State *);
 228 };
 229
 230 static void Xet_add (lua_State *L, const struct Xet_reg *l)
 231 {
 232   if (!l)
 233     return;
 234   for (; l->name; l++)
 235     {
 236       lua_pushstring(L, l->name);
 237       lua_pushlightuserdata(L, (void*)l);
 238       lua_settable(L, -3);
 239     }
 240 }
 241
 242 static int Xet_call (lua_State *L)
 243 {
 244   /* for get: stack has userdata, index, lightuserdata */
 245   /* for set: stack has userdata, index, value, lightuserdata */
 246   const struct Xet_reg *m = (const struct Xet_reg *)lua_touserdata(L, -1);  /* member info */
 247   void *obj;
 248   lua_pop(L, 1);                               /* drop lightuserdata */
 249   luaL_checktype(L, 1, LUA_TUSERDATA);
 250   if (m->absolute)
 251     return m->absolute(L);
 252   obj = get_broker_obj((struct broker **)lua_touserdata(L, 1));
 253   return m->func(L, (char *)obj + m->offset);
 254 }
 255
 256 static int index_handler (lua_State *L)
 257 {
 258   /* stack has userdata, index */
 259   lua_pushvalue(L, 2);                     /* dup index */
 260   lua_rawget(L, lua_upvalueindex(1));      /* lookup member by name */
 261   if (!lua_islightuserdata(L, -1))
 262     {
 263       lua_pop(L, 1);                         /* drop value */
 264       lua_pushvalue(L, 2);                   /* dup index */
 265       lua_gettable(L, lua_upvalueindex(2));  /* else try methods */
 266       if (lua_isnil(L, -1))                  /* invalid member */
 267         luaL_error(L, "cannot get member '%s'", lua_tostring(L, 2));
 268       return 1;
 269     }
 270   return Xet_call(L);                      /* call get function */
 271 }
 272
 273 static int newindex_handler (lua_State *L)
 274 {
 275   /* stack has userdata, index, value */
 276   lua_pushvalue(L, 2);                     /* dup index */
 277   lua_rawget(L, lua_upvalueindex(1));      /* lookup member by name */
 278   if (!lua_islightuserdata(L, -1))         /* invalid member */
 279     luaL_error(L, "cannot set member '%s'", lua_tostring(L, 2));
 280   return Xet_call(L);                      /* call set function */
 281 }
 282
 283 static int
 284 struct_register(lua_State *L, const char *name, const luaL_reg fn_methods[], const luaL_reg meta_methods[],
 285     const struct Xet_reg setters[], const struct Xet_reg getters[])
 286 {
 287   int metatable, methods;
 288
 289   /* create methods table & add it to the table of globals */
 290   luaL_register(L, name, fn_methods);
 291   methods = lua_gettop(L);
 292
 293   /* create metatable & add it to the registry */
 294   luaL_newmetatable(L, name);
 295   luaL_register(L, 0, meta_methods);  /* fill metatable */
 296
 297   /* To identify the type of object */
 298   lua_pushstring(L, "_objname");
 299   lua_pushstring(L, name);
 300   lua_rawset(L, -3);
 301
 302   metatable = lua_gettop(L);
 303
 304   lua_pushliteral(L, "__metatable");
 305   lua_pushvalue(L, methods);    /* dup methods table*/
 306   lua_rawset(L, metatable);     /* hide metatable:
 307                                    metatable.__metatable = methods */
 308
 309   lua_pushliteral(L, "__index");
 310   lua_pushvalue(L, metatable);  /* upvalue index 1 */
 311   Xet_add(L, getters);     /* fill metatable with getters */
 312   lua_pushvalue(L, methods);    /* upvalue index 2 */
 313   lua_pushcclosure(L, index_handler, 2);
 314   lua_rawset(L, metatable);     /* metatable.__index = index_handler */
 315
 316   lua_pushliteral(L, "__newindex");
 317   lua_newtable(L);              /* table for members you can set */
 318   Xet_add(L, setters);     /* fill with setters */
 319   lua_pushcclosure(L, newindex_handler, 1);
 320   lua_rawset(L, metatable);     /* metatable.__newindex = newindex_handler */
 321
 322   /* FIXME: Why do we leave an element on the stack? */
 323   lua_pop(L, 1);                /* drop metatable */
 324   return 1;                     /* return methods on the stack */
 325 }
 326
 327 /** }}} */
 328
 329 /** Callback {{{ */
 330 static void
 331 push_callback(lua_State *L, struct listener **t)
 332 {
 333   if (!t || !*t)
 334     lua_pushnil(L);
 335   else
 336     {
 337       struct listener **r;
 338       r = (struct listener **)lua_newuserdata(L, sizeof(struct listener *));
 339       *r = *t;
 340       luaL_getmetatable(L, "callback");
 341       lua_setmetatable(L,-2);
 342     }
 343 }
 344
 345
 346 static int
 347 internal_unhook(lua_State *L, int warn)
 348 {
 349   /*Emulate check_callback() */
 350   struct listener **ppl;
 351   luaL_checktype(L, 1, LUA_TUSERDATA);
 352   ppl = (struct listener **) luaL_checkudata(L, 1, "callback");
 353
 354   if (!ppl)
 355     luaL_typerror(L, 1, "callback");
 356
 357   if (!*ppl)
 358     {
 359       if (warn)
 360         {
 361           lua_pushboolean(L, 0);
 362           lua_pushstring(L, "Callback already unhooked.");
 363           LuaShowErr(L);
 364         }
 365     }
 366   else
 367     {
 368       LuaFreeHandler(L, (lua_handler *)&(*ppl)->handler);
 369       unregister_listener(*ppl);
 370       *ppl = 0;
 371       if (warn)
 372         lua_pushboolean(L, 1);
 373     }
 374   return warn != 0;
 375 }
 376 static int
 377 callback_unhook(lua_State *L)
 378 {
 379   return internal_unhook(L, 1);
 380 }
 381
 382 static const luaL_reg callback_methods[] = {
 383   {"unhook", callback_unhook},
 384   {0, 0}
 385 };
 386
 387 int
 388 callback_collect(lua_State *L)
 389 {
 390   return internal_unhook(L, 0);
 391 }
 392
 393 static const luaL_reg callback_metamethods[] = {
 394   {"__gc", callback_collect},
 395   {0, 0}
 396 };
 397
 398 static const struct Xet_reg callback_setters[] = {
 399   {0, 0}
 400 };
 401
 402 static const struct Xet_reg callback_getters[] = {
 403   {0, 0}
 404 };
 405
 406
 407 /** }}} */
 408
 409 static int
 410 screen_object_collect(lua_State *L)
 411 {
 412   struct broker **pbroker;
 413   luaL_checktype(L, 1, LUA_TUSERDATA);
 414   pbroker = (struct broker **)lua_touserdata(L, 1);
 415   broker_unref(pbroker);
 416   return 0;
 417 }
 418
 419 /** Window {{{ */
 420
 421 PUSH_TYPE(window, struct win)
 422
 423 CHECK_TYPE(window, struct win)
 424
 425 static int get_window(lua_State *L, void *v)
 426 {
 427   push_window(L, (struct win **)v);
 428   return 1;
 429 }
 430
 431 static int
 432 window_change_title(lua_State *L)
 433 {
 434   struct win *w = check_window(L, 1);
 435   unsigned int len;
 436   const char *title = luaL_checklstring(L, 3, &len);
 437   ChangeAKA(w, (char *)title, len);
 438   return 0;
 439 }
 440
 441 static int
 442 window_change_number(lua_State *L)
 443 {
 444   struct win *w = check_window(L, 1);
 445   int newnum = luaL_checkint(L, 3);
 446   ChangeWinNum(w->w_number, newnum);
 447   return 0;
 448 }
 449
 450 static int
 451 window_get_monitor_status(lua_State *L)
 452 {
 453   struct win *w = check_window(L, 1);
 454   int activity = luaL_checkint(L, 2);
 455   if (activity)
 456     /*monitor*/
 457     lua_pushinteger(L, w->w_monitor != MON_OFF);
 458   else
 459     /*silence*/
 460     lua_pushinteger(L, w->w_silence == SILENCE_ON ? w->w_silencewait: 0);
 461
 462   return 1;
 463 }
 464
 465 static int
 466 window_stuff(lua_State *L)
 467 {
 468   unsigned int len;
 469   struct layer *oldflayer = flayer;
 470   struct win *w = check_window(L, 1);
 471   const char *str = luaL_checklstring(L, 2, &len);
 472
 473   flayer = &w->w_layer;
 474   while(len)
 475     LayProcess((char **)&str, (int *) &len);
 476   flayer = oldflayer;
 477   return 0;
 478 }
 479
 480 static int
 481 window_activate(lua_State *L)
 482 {
 483   struct win *w = check_window(L, 1);
 484   SetForeWindow(w);
 485   return 0;
 486 }
 487
 488 static void push_canvas(lua_State *L, struct canvas **t);
 489
 490 static int
 491 window_get_showing_canvases(lua_State *L)
 492 {
 493   struct win *w = check_window(L, 1);
 494   int count = 0;
 495   struct canvas *cv = w->w_layer.l_cvlist;
 496   if (!cv) {
 497       lua_pushnil(L);
 498       return 1;
 499   }
 500   lua_newtable(L);
 501   while (cv) {
 502     lua_pushinteger(L, count++);
 503     push_canvas(L, &cv);
 504     lua_settable(L, -3);
 505     cv = cv->c_lnext;
 506   }
 507
 508   return 1;
 509 }
 510
 511 static int
 512 window_getlines(lua_State *L)
 513 {
 514   struct win *w = check_window(L, 1);
 515   int i;
 516   lua_newtable(L);
 517   for (i = 0; i < fore->w_height; i++)
 518     {
 519       char *p = (char *)w->w_mlines[i].image;
 520       int k, save;
 521       for (k = fore->w_width - 1; k >= 0 && p[k] == ' '; k--)
 522         ;
 523       k +=(p[k] != ' ');
 524       save = p[k];
 525       p[k] = 0;
 526       lua_pushinteger(L, i);
 527       lua_pushstring(L, p);
 528       lua_settable(L, -3);
 529       p[k] = save;
 530     }
 531
 532   return 1;
 533 }
 534
 535 static int
 536 window_gethistory(lua_State *L)
 537 {
 538   struct win *w = check_window(L, 1);
 539   int i;
 540   lua_newtable(L);
 541   for (i = 0; i < fore->w_height; i++)
 542     {
 543       char *p = (char *) w->w_hlines[(w->w_histidx + i) % w->w_histheight].image;
 544       int k, save;
 545       for (k = fore->w_width - 1; k >= 0 && p[k] == ' '; k--)
 546         ;
 547       k +=(p[k] != ' ');
 548       save = p[k];
 549       p[k] = 0;
 550       lua_pushinteger(L, i);
 551       lua_pushstring(L, p);
 552       lua_settable(L, -3);
 553       p[k] = save;
 554     }
 555
 556   return 1;
 557 }
 558
 559 static const luaL_reg window_methods[] = {
 560   {"get_monitor_status", window_get_monitor_status},
 561   {"showing_canvases", window_get_showing_canvases},
 562   {"stuff", window_stuff},
 563   {"activate", window_activate},
 564   {"get_lines", window_getlines},
 565   {"get_history", window_gethistory},
 566   {"hook", LuaRegEvent},
 567   {0, 0}
 568 };
 569
 570 static int
 571 window_tostring(lua_State *L)
 572 {
 573   char str[128];
 574   struct win *w = check_window(L, 1);
 575   snprintf(str, sizeof(str), "{window #%d: '%s'}", w->w_number, w->w_title);
 576   lua_pushstring(L, str);
 577   return 1;
 578 }
 579
 580 static int
 581 window_equality(lua_State *L)
 582 {
 583   struct win *w1 = check_window(L, 1), *w2 = check_window(L, 2);
 584   lua_pushboolean(L, (w1 == w2 || (w1 && w2 && w1->w_number == w2->w_number)));
 585   return 1;
 586 }
 587
 588 static const luaL_reg window_metamethods[] = {
 589   {"__tostring", window_tostring},
 590   {"__eq", window_equality},
 591   {"__gc", screen_object_collect},
 592   {0, 0}
 593 };
 594
 595 static const struct Xet_reg window_setters[] = {
 596   {"title", 0, 0, window_change_title/*absolute setter*/},
 597   {"number", 0, 0, window_change_number/*absolute setter*/},
 598   {0, 0}
 599 };
 600
 601 static const struct Xet_reg window_getters[] = {
 602   {"title", get_string, offsetof(struct win, w_title) + 8},
 603   {"number", get_int, offsetof(struct win, w_number)},
 604   {"dir", get_string, offsetof(struct win, w_dir)},
 605   {"tty", get_string, offsetof(struct win, w_tty)},
 606   {"pid", get_int, offsetof(struct win, w_pid)},
 607   {"group", get_window, offsetof(struct win, w_group)},
 608   {"bell", get_int, offsetof(struct win, w_bell)},
 609   {0, 0}
 610 };
 611
 612
 613 /** }}} */
 614
 615 /** AclUser {{{ */
 616
 617 PUSH_TYPE(user, struct acluser)
 618
 619 CHECK_TYPE(user, struct acluser)
 620
 621 static int
 622 get_user(lua_State *L, void *v)
 623 {
 624   push_user(L, (struct acluser **)v);
 625   return 1;
 626 }
 627
 628 static const luaL_reg user_methods[] = {
 629   {0, 0}
 630 };
 631
 632 static int
 633 user_tostring(lua_State *L)
 634 {
 635   char str[128];
 636   struct acluser *u = check_user(L, 1);
 637   snprintf(str, sizeof(str), "{user '%s'}", u->u_name);
 638   lua_pushstring(L, str);
 639   return 1;
 640 }
 641
 642 static const luaL_reg user_metamethods[] = {
 643   {"__tostring", user_tostring},
 644   {"__gc", screen_object_collect},
 645   {0, 0}
 646 };
 647
 648 static const struct Xet_reg user_setters[] = {
 649   {0, 0}
 650 };
 651
 652 static const struct Xet_reg user_getters[] = {
 653   {"name", get_string, offsetof(struct acluser, u_name)},
 654   {"password", get_string, offsetof(struct acluser, u_password)},
 655   {0, 0}
 656 };
 657
 658 /** }}} */
 659
 660 static int get_display(lua_State *L, void *v);
 661 /** Canvas {{{ */
 662
 663 PUSH_TYPE(canvas, struct canvas)
 664
 665 CHECK_TYPE(canvas, struct canvas)
 666
 667 static int
 668 get_canvas(lua_State *L, void *v)
 669 {
 670   push_canvas(L, (struct canvas **)v);
 671   return 1;
 672 }
 673
 674 static int
 675 canvas_select(lua_State *L)
 676 {
 677   struct canvas *c = check_canvas(L, 1);
 678   if (!display || D_forecv == c)
 679     return 0;
 680   /* FIXME: why do we need this? */
 681   SetCanvasWindow(c, Layer2Window(c->c_layer));
 682
 683   FocusCanvas(c);
 684   return 0;
 685 }
 686
 687 static int
 688 canvas_split(lua_State *L)
 689 {
 690   struct canvas *c = check_canvas(L, 1);
 691   struct canvas *oldfore = D_forecv;
 692   D_forecv = c;
 693   int hori = lua_toboolean(L, 2);
 694   if (hori)
 695     AddCanvas(SLICE_HORI);
 696   else
 697     AddCanvas(SLICE_VERT);
 698   Activate(-1);
 699   D_forecv = oldfore;
 700   return 0;
 701 }
 702
 703 static int
 704 canvas_showwin(lua_State *L)
 705 {
 706   struct canvas *c = check_canvas(L, 1);
 707   if (lua_isnil(L, 2))
 708     SetCanvasWindow(c, 0);
 709   else
 710     {
 711       struct win *w = check_window(L, 2);
 712       SetCanvasWindow(c, w);
 713     }
 714   return 0;
 715 }
 716
 717 static const luaL_reg canvas_methods[] = {
 718   {"select", canvas_select},
 719   {"split", canvas_split},
 720   {"showwin", canvas_showwin},
 721   {0, 0}
 722 };
 723
 724 static const luaL_reg canvas_metamethods[] = {
 725   {"__gc", screen_object_collect},
 726   {0, 0}
 727 };
 728
 729 extern struct mchar mchar_so;
 730 static int
 731 canvas_update_caption(lua_State *L)
 732 {
 733   struct canvas *cv = check_canvas(L, 1);
 734   unsigned int len;
 735   const char *caption = luaL_checklstring(L, 3, &len);
 736   int l, padlen;
 737   padlen = cv->c_xe - cv->c_xs +
 738     (display ? (cv->c_xe + 1 < D_width || D_CLP): 0);
 739   struct win *w = Layer2Window(cv->c_layer);
 740   char * buf = MakeWinMsgEv((char *)caption, w, '%', padlen, &cv->c_captev, 0);
 741   if (cv->c_captev.timeout.tv_sec)
 742     evenq(&cv->c_captev);
 743   l = strlen(buf);
 744
 745   GotoPos(cv->c_xs, cv->c_ye+1);
 746   /*XXX:what does this mean?*/
 747   SetRendition(&mchar_so);
 748   if (l > cv->c_xe - cv->c_xs + 1)
 749     l = cv->c_xe - cv->c_xs + 1;
 750   PutWinMsg(buf, cv->c_xs, l);
 751   l += cv->c_xs;
 752   for (; l <= cv->c_xe; l++)
 753     PUTCHARLP(' ');
 754
 755   return 0;
 756 }
 757
 758 static const struct Xet_reg canvas_setters[] = {
 759   {"caption", 0, 0, canvas_update_caption/*absolute setter*/},
 760   {0, 0}
 761 };
 762
 763 static int
 764 canvas_get_window(lua_State *L)
 765 {
 766   struct canvas *c = check_canvas(L, 1);
 767   struct win *win = Layer2Window(c->c_layer);
 768   if (win)
 769     push_window(L, &win);
 770   else
 771     lua_pushnil(L);
 772   return 1;
 773 }
 774
 775 static const struct Xet_reg canvas_getters[] = {
 776   {"next", get_canvas, offsetof(struct canvas, c_next)},
 777   {"xoff", get_int, offsetof(struct canvas, c_xoff)},
 778   {"yoff", get_int, offsetof(struct canvas, c_yoff)},
 779   {"xs", get_int, offsetof(struct canvas, c_xs)},
 780   {"ys", get_int, offsetof(struct canvas, c_ys)},
 781   {"xe", get_int, offsetof(struct canvas, c_xe)},
 782   {"ye", get_int, offsetof(struct canvas, c_ye)},
 783   {"window", 0, 0, canvas_get_window},
 784   {"display", get_display, offsetof(struct canvas, c_display)},
 785   {0, 0}
 786 };
 787
 788 /** }}} */
 789
 790 /** Layout {{{ */
 791
 792 PUSH_TYPE(layout, struct layout)
 793 CHECK_TYPE(layout, struct layout)
 794
 795 static const struct Xet_reg layout_getters[] = {
 796   {"title", get_string, offsetof(struct layout, lay_title)},
 797   {"number", get_string, offsetof(struct layout, lay_title)},
 798   {"autosave", get_string, offsetof(struct layout, lay_autosave)},
 799   {0,0}
 800 };
 801
 802 int
 803 layout_change_title(lua_State *L)
 804 {
 805   struct layout *lay = check_layout(L, 1);
 806   unsigned int len;
 807   const char *title = luaL_checklstring(L, 3, &len);
 808   free(lay->lay_title);
 809   lay->lay_title= SaveStr(title);
 810   return 0;
 811 }
 812
 813 void LayoutChangeNumber(struct layout *lay, int newnum);
 814
 815 int
 816 layout_change_number(lua_State *L)
 817 {
 818   struct layout *lay = check_layout(L, 1);
 819   int newnum = luaL_checkint(L, 3);
 820   LayoutChangeNumber(lay, newnum);
 821   return 0;
 822 }
 823
 824 static const struct Xet_reg layout_setters[] = {
 825   {"title", 0, 0, layout_change_title/*absolute setter*/},
 826   {"number", 0, 0, layout_change_number/*absolute setter*/},
 827   {"autosave", get_string, offsetof(struct layout, lay_autosave)},
 828   {0, 0}
 829 };
 830
 831 int
 832 layout_select(lua_State *L)
 833 {
 834   struct layout *lay = check_layout(L, 1);
 835   if (!display) return 0;
 836   LoadLayout(lay, &D_canvas);
 837   Activate(0);
 838   return 0;
 839 }
 840
 841 static const luaL_reg layout_methods[] = {
 842   {"select", layout_select},
 843   {0, 0}
 844 };
 845
 846 static const luaL_reg layout_metamethods[] = {
 847   {"__gc", screen_object_collect},
 848   {0, 0}
 849 };
 850
 851 static int
 852 get_layout(lua_State *L, void *v)
 853 {
 854   push_layout(L, (struct layout **)v);
 855   return 1;
 856 }
 857
 858 /** }}} */
 859
 860 /** Display {{{ */
 861
 862 PUSH_TYPE(display, struct display)
 863
 864 CHECK_TYPE(display, struct display)
 865
 866 static int
 867 get_display(lua_State *L, void *v)
 868 {
 869   push_display(L, (struct display **)v);
 870   return 1;
 871 }
 872
 873 static int
 874 display_get_canvases(lua_State *L)
 875 {
 876   struct display *d;
 877   struct canvas *iter;
 878   int count;
 879
 880   d = check_display(L, 1);
 881   lua_newtable(L);
 882   for (iter = d->d_cvlist, count = 0; iter; iter = iter->c_next, count++) {
 883     lua_pushinteger(L, count);
 884     push_canvas(L, &iter);
 885     lua_settable(L, -3);
 886   }
 887
 888   return 1;
 889 }
 890
 891 static int
 892 display_top_canvas(lua_State *L)
 893 {
 894   struct display *d;
 895   d = check_display(L, 1);
 896   push_canvas(L, &d->d_cvlist);
 897
 898   return 1;
 899 }
 900
 901 static int
 902 display_bot_canvas(lua_State *L)
 903 {
 904   struct display *d;
 905   struct canvas *c;
 906   d = check_display(L, 1);
 907
 908   for (c = d->d_cvlist; c->c_next; c = c->c_next)
 909     ;
 910   push_canvas(L, &c);
 911
 912   return 1;
 913 }
 914
 915 static const luaL_reg display_methods[] = {
 916   {"get_canvases", display_get_canvases},
 917   {"top_canvas", display_top_canvas},
 918   {"bottom_canvas", display_bot_canvas},
 919   {0, 0}
 920 };
 921
 922 static int
 923 display_tostring(lua_State *L)
 924 {
 925   char str[128];
 926   struct display *d = check_display(L, 1);
 927   snprintf(str, sizeof(str), "{display: tty = '%s', term = '%s'}", d->d_usertty, d->d_termname);
 928   lua_pushstring(L, str);
 929   return 1;
 930 }
 931
 932 static const luaL_reg display_metamethods[] = {
 933   {"__tostring", display_tostring},
 934   {"__gc", screen_object_collect},
 935   {0, 0}
 936 };
 937
 938 static int
 939 display_new_idle_timeout(lua_State *L)
 940 {
 941   struct display *disp = check_display(L, 1);
 942   int timeout = luaL_checkinteger(L, 3) * 1000;
 943   struct event *ev = &disp->d_idleev;
 944   if (timeout > 0)
 945     {
 946       SetTimeout(ev, timeout);
 947       if (!ev->queued)
 948         evenq(ev);
 949     }
 950   else
 951     evdeq(ev);
 952
 953   return 0;
 954 }
 955
 956 static const struct Xet_reg display_setters[] = {
 957   {"idle_timeout", 0, 0, display_new_idle_timeout/*absolute setter*/},
 958   {0, 0}
 959 };
 960
 961 static const struct Xet_reg display_getters[] = {
 962   {"tty", get_string, offsetof(struct display, d_usertty)},
 963   {"term", get_string, offsetof(struct display, d_termname)},
 964   {"fore", get_window, offsetof(struct display, d_fore)},
 965   {"other", get_window, offsetof(struct display, d_other)},
 966   {"width", get_int, offsetof(struct display, d_width)},
 967   {"height", get_int, offsetof(struct display, d_height)},
 968   {"user", get_user, offsetof(struct display, d_user)},
 969   {"layout", get_layout, offsetof(struct display, d_layout)},
 970   {0, 0}
 971 };
 972
 973 /** }}} */
 974
 975 /** Screen {{{ */
 976
 977 static int
 978 screen_get_windows(lua_State *L)
 979 {
 980   struct win *iter;
 981   int count;
 982
 983   lua_newtable(L);
 984   for (iter = windows, count = 0; iter; iter = iter->w_next, count++) {
 985     lua_pushinteger(L, iter->w_number);
 986     push_window(L, &iter);
 987     lua_settable(L, -3);
 988   }
 989
 990   return 1;
 991 }
 992
 993 static int
 994 screen_get_displays(lua_State *L)
 995 {
 996   struct display *iter;
 997   int count;
 998
 999   lua_newtable(L);
1000   for (iter = displays, count = 0; iter; iter = iter->d_next, count++) {
1001     lua_pushinteger(L, count);
1002     push_display(L, &iter);
1003     lua_settable(L, -3);
1004   }
1005
1006   return 1;
1007 }
1008
1009 extern struct layout *layouts;
1010 static int
1011 screen_get_layouts(lua_State *L)
1012 {
1013   struct layout *iter;
1014   int count;
1015
1016   lua_newtable(L);
1017   for (iter = layouts, count = 0; iter; iter = iter->lay_next, count++) {
1018     lua_pushinteger(L, iter->lay_number);
1019     push_layout(L, &iter);
1020     lua_settable(L, -3);
1021   }
1022
1023   return 1;
1024 }
1025
1026 static int
1027 screen_get_display(lua_State *L)
1028 {
1029   push_display(L, &display);
1030   return 1;
1031 }
1032
1033 static int
1034 screen_exec_command(lua_State *L)
1035 {
1036   const char *command;
1037   unsigned int len;
1038
1039   command = luaL_checklstring(L, 1, &len);
1040   if (command)
1041     RcLine((char *)command, len);
1042
1043   return 0;
1044 }
1045
1046 static int
1047 screen_append_msg(lua_State *L)
1048 {
1049   const char *msg, *color;
1050   unsigned int len;
1051   msg = luaL_checklstring(L, 1, &len);
1052   if (lua_isnil(L, 2))
1053     color = NULL;
1054   else
1055     color = luaL_checklstring(L, 2, &len);
1056   AppendWinMsgRend(msg, color);
1057   return 0;
1058 }
1059
1060 struct sinput_data
1061 {
1062   lua_State *L;
1063   lua_handler lh;
1064 };
1065
1066 void
1067 script_input_fn(char *buf, int len, char *priv)
1068 {
1069   struct sinput_data *sidata = (struct sinput_data *)priv;
1070   lua_handler lh = sidata->lh;
1071   lua_State *L = sidata->L;
1072
1073   LuaPushHandler(lh);
1074   lua_pushstring(L, buf);
1075   if (lua_pcall(L, 1, 0, 0) == LUA_ERRRUN)
1076     {
1077       if(lua_isstring(L, -1))
1078         {
1079           LuaShowErr(L);
1080         }
1081     }
1082   free(sidata);
1083   LuaFreeHandler(L, &lh);
1084 }
1085
1086 static int
1087 screen_input(lua_State *L)
1088 {
1089   char *ss;
1090   int n;
1091   const char * prompt = NULL, *prefill = NULL;
1092   lua_handler lh;
1093   struct sinput_data *sidata;
1094
1095   prompt = luaL_checkstring(L, 1);
1096   lh = LuaCheckHandler(L, 2, 1);
1097   if (!lh)
1098     luaL_error(L, "Out of Memory");
1099
1100   if (lua_gettop(L) >= 3)
1101     prefill = luaL_checkstring(L, 3);
1102
1103
1104   sidata = (struct sinput_data *)malloc(sizeof(struct sinput_data));
1105   if (!sidata)
1106     {
1107       LuaFreeHandler(L, &lh);
1108       luaL_error(L, "Out of Memory");
1109     }
1110
1111   sidata->L = L;
1112   sidata->lh = lh;
1113   Input((char *)prompt, 100, INP_COOKED, script_input_fn, (char *)sidata, 0);
1114
1115   if (!prefill)
1116     return 0;
1117   for (; *prefill; prefill++)
1118     {
1119       if ((*(unsigned char *)prefill & 0x7f) < 0x20 || *prefill == 0x7f)
1120         continue;
1121       ss = (char *)prefill;
1122       n = 1;
1123       LayProcess(&ss, &n);
1124     }
1125   return 0;
1126 }
1127
1128 static void
1129 sev_schedule_fn(struct event *ev, char *data)
1130 {
1131   struct sinput_data *si = (struct sinput_data *)data;
1132   lua_handler lh = si->lh;
1133   lua_State *L = si->L;
1134   free(si);
1135   evdeq(ev);
1136   Free(ev);
1137
1138   LuaPushHandler(lh);
1139   if (lua_pcall(L, 1, 0, 0) == LUA_ERRRUN)
1140     {
1141       if(lua_isstring(L, -1))
1142         {
1143           LuaShowErr(L);
1144         }
1145     }
1146   LuaFreeHandler(L, &lh);
1147 }
1148
1149 static int
1150 screen_schedule(lua_State *L)
1151 {
1152   int timeout = luaL_checkinteger(L, 1);
1153   lua_handler lh = LuaCheckHandler(L, 2, 1);
1154   struct sinput_data *si;
1155   struct event *ev;
1156   if (timeout <= 0)
1157     return 0;
1158
1159   ev = (struct event *) calloc(1, sizeof(struct event));
1160   if (!ev)
1161     {
1162       LuaFreeHandler(L, &lh);
1163       luaL_error(L, "Out of Memory");
1164     }
1165   si = (struct sinput_data *) malloc(sizeof(struct sinput_data));
1166   if (!si)
1167     {
1168       LuaFreeHandler(L, &lh);
1169       Free(ev);
1170       luaL_error(L, "Out of Memory");
1171     }
1172   si->lh = lh;
1173   si->L = L;
1174
1175   ev->type = EV_TIMEOUT;
1176   ev->data = (char *)si;
1177   ev->handler = sev_schedule_fn;
1178   evenq(ev);
1179   SetTimeout(ev, timeout * 1000);
1180   return 0;
1181 }
1182
1183 static const luaL_reg screen_methods[] = {
1184   {"windows", screen_get_windows},
1185   {"displays", screen_get_displays},
1186   {"layouts", screen_get_layouts},
1187   {"display", screen_get_display},
1188   {"command", screen_exec_command},
1189   {"append_msg", screen_append_msg},
1190   {"hook", LuaRegEvent},
1191   {"input", screen_input},
1192   {"schedule", screen_schedule},
1193   {0, 0}
1194 };
1195
1196 static const luaL_reg screen_metamethods[] = {
1197   {0, 0}
1198 };
1199
1200 static const struct Xet_reg screen_setters[] = {
1201   {0, 0}
1202 };
1203
1204 static const struct Xet_reg screen_getters[] = {
1205   {0, 0}
1206 };
1207
1208 /** }}} */
1209
1210 /** Public functions {{{ */
1211
1212 /* FIXME: This code only tracks one unhook ticket for a lua func.
1213  * So it does not work if one func is registered more than one times. */
1214 static void
1215 prepare_weak_table(lua_State *L, const char *name, const char *mode)
1216 {
1217   luaL_getmetatable(L, "screen");
1218
1219   lua_pushstring(L, name);
1220   lua_newtable(L);
1221
1222   /* prepare a metatable to indicate weak table */
1223   lua_newtable(L);
1224   lua_pushstring(L, "__mode");
1225   lua_pushstring(L, mode);
1226   lua_rawset(L, -3);
1227   /* Mark weak table */
1228   lua_setmetatable(L, -2);
1229   lua_rawset(L, -3);
1230   lua_pop(L, 1);
1231 }
1232
1233 struct sfile {
1234     lua_State *L;
1235     ino_t inode;
1236     struct sfile *next;
1237 };
1238
1239 struct sfile *scripts = NULL;
1240
1241 int LuaInit(void)
1242 {
1243   return 0;
1244 }
1245 lua_State *
1246 LuaNewState(struct sfile *slist)
1247 {
1248   lua_State *L = luaL_newstate();
1249
1250   luaL_openlibs(L);
1251
1252 #define REGISTER(X) struct_register(L, #X , X ## _methods, X##_metamethods, X##_setters, X##_getters)
1253
1254   REGISTER(screen);
1255   REGISTER(window);
1256   REGISTER(display);
1257   REGISTER(user);
1258   REGISTER(canvas);
1259   REGISTER(callback);
1260
1261   /* To store handler funcs */
1262
1263   /*_two kinds of information are mantained:
1264    *
1265    * funcreg[key]->func
1266    * The 'func' part of the tables are weak. That means the registered funcs
1267    * will be collected once the func is no longer available (e.g. overwritten
1268    * by a new instance of the script)
1269    *
1270    * To make this process happens faster, GC is forced at the end of each
1271    * source.
1272    * TODO: What if some events are triggered within the sourcing
1273    * procedure?
1274    * */
1275   prepare_weak_table(L, "_funcreg", " ");
1276
1277   /* funcunhook[func]->listener
1278    * The listener is the unhook ticket of the hook. which should be collected
1279    * once the func is collected. The gc metamethod will be triggered
1280    * accordingly. */
1281   prepare_weak_table(L, "_funcunhook", " ");
1282
1283   /* Hold a reference to the sfile structure to ease unloading the script.*/
1284   luaL_getmetatable(L, "screen");
1285   lua_pushstring(L, "_sfile");
1286   lua_pushlightuserdata(L, slist);
1287   lua_rawset(L, -3);
1288   lua_pop(L, 1);
1289   slist->L = L;
1290   return L;
1291 }
1292
1293 /* An error message on top of the stack. */
1294 static void
1295 LuaShowErr(lua_State *L)
1296 {
1297   struct display *d = display;
1298   unsigned int len;
1299   const char *message = luaL_checklstring(L, -1, &len);
1300   lua_pop(L, 1);
1301   LMsg(0, "%s", message ? message : "Unknown error");
1302   display = d;
1303 }
1304
1305 void
1306 LuaUnload(struct sfile *slist)
1307 {
1308   struct sfile **plist = &scripts;
1309   lua_close(slist->L);
1310   while (*plist) {
1311       if (*plist == slist) {
1312           *plist = slist->next;
1313           break;
1314       }
1315       plist = &(*plist)->next;
1316   }
1317   free(slist);
1318 }
1319
1320 /* FIXME: Think about this: will it affect the registered handlers?*/
1321 int LuaSource(const char *file, int async)
1322 {
1323   struct stat st;
1324   if (stat(file, &st) == -1)
1325     Msg(errno, "Error loading lua script file '%s'", file);
1326   else
1327     {
1328       int len = strlen(file);
1329       ino_t inode = st.st_ino;
1330       struct sfile *slist = scripts;
1331
1332       if (len < 4 || strncmp(file + len - 4, ".lua", 4) != 0)
1333         return 0;
1334
1335       while (slist) {
1336           if (slist->inode == inode)
1337             break;
1338           slist = slist->next;
1339       }
1340       if (slist)
1341         LuaUnload(slist);
1342
1343       slist = (struct sfile *) malloc(sizeof(struct sfile));
1344       slist->next = scripts;
1345       LuaNewState(slist);
1346       slist->inode = inode;
1347
1348       if (luaL_dofile(slist->L, file) && lua_isstring(slist->L, -1))
1349         {
1350           LuaShowErr(slist->L);
1351           lua_close(slist->L);
1352           free(slist);
1353           return 0;
1354         }
1355       else
1356         {
1357           /* It seems that I need two GC passes to really collect the unhook
1358            * ticket, after changing the reference to ticket in the
1359            * 'funcunhook' table from weak to strong. This should not be
1360            * harmful, but how can I make sure that two passes is enough?
1361            *
1362            * Possible reason:
1363            * This seems reasonable, since the first pass will collect the func
1364            * itself and make the ticket garbage, and the second pass will
1365            * collect the ticket itself.
1366            *
1367            * TODO: check this out. maybe ask some lua gurus. */
1368           lua_gc(slist->L, LUA_GCCOLLECT, 0);
1369           lua_gc(slist->L, LUA_GCCOLLECT, 0);
1370           scripts = slist;
1371         }
1372       return 1;
1373     }
1374   return 0;
1375 }
1376
1377 int LuaFinit(void)
1378 {
1379   struct sfile *slist = scripts;
1380   while (slist) {
1381       struct sfile *tmp = slist;
1382       lua_close(slist->L);
1383       slist = slist->next;
1384       free(tmp);
1385   }
1386   scripts = 0;
1387   return 0;
1388 }
1389
1390 static void
1391 push_stringarray(lua_State *L, char **args)
1392 {
1393   int i;
1394   lua_newtable(L);
1395   for (i = 1; args && *args; i++) {
1396     lua_pushinteger(L, i);
1397     lua_pushstring(L, *args++);
1398     lua_settable(L, -3);
1399   }
1400 }
1401
1402 int
1403 LuaPushParams(lua_State *L, const char *params, va_list va)
1404 {
1405   int num = 0;
1406   while (*params)
1407     {
1408       switch (*params)
1409         {
1410         case 's':
1411           lua_pushstring(L, va_arg(va, char *));
1412           break;
1413         case 'S':
1414           push_stringarray(L, va_arg(va, char **));
1415           break;
1416         case 'i':
1417           lua_pushinteger(L, va_arg(va, int));
1418           break;
1419         case 'd':
1420           {
1421             struct display *d = va_arg(va, struct display *);
1422             push_display(L, &d);
1423             break;
1424           }
1425         case 'w':
1426           {
1427             struct win *w = va_arg(va, struct win *);
1428             push_window(L, &w);
1429             break;
1430           }
1431         case 'c':
1432           {
1433             struct canvas *c = va_arg(va, struct canvas *);
1434             push_canvas(L, &c);
1435             break;
1436           }
1437         }
1438       params++;
1439       num++;
1440     }
1441   return num;
1442 }
1443
1444 int LuaCall(const char *func, const char **argv)
1445 {
1446   int argc;
1447   struct sfile *slist = scripts;
1448   lua_State *L = NULL;
1449   while (slist) {
1450       L = slist->L;
1451       lua_getfield(L, LUA_GLOBALSINDEX, func);
1452       if (lua_isnil(L, -1))
1453         {
1454           lua_pop(L, 1);
1455           slist = slist->next;
1456           return 0;
1457         }
1458       else
1459         break;
1460   }
1461
1462   if (!slist) {
1463       if (L) {
1464           lua_pushstring(L, "Could not find the script function\n");
1465           LuaShowErr(L);
1466       }
1467       return 0;
1468   }
1469   StackDump(L, "Before LuaCall\n");
1470
1471   for (argc = 0; *argv; argv++, argc++)
1472     {
1473       lua_pushstring(L, *argv);
1474     }
1475   if (lua_pcall(L, argc, 0, 0) == LUA_ERRRUN)
1476     {
1477       if(lua_isstring(L, -1))
1478         {
1479           StackDump(L, "After LuaCall\n");
1480           LuaShowErr(L);
1481           return 0;
1482         }
1483     }
1484   return 1;
1485 }
1486
1487 /*** Lua callback handler management {{{ */
1488
1489 int
1490 LuaPushHTable(lua_State *L, int screen, const char * t)
1491 {
1492   lua_pushstring(L, t);
1493   lua_rawget(L, screen);
1494   /* FIXME: Do we need to balance the stack here? */
1495   if (lua_isnil(L, -1))
1496     luaL_error(L, "Fatal! Fail to get function registeration table!");
1497   return lua_gettop(L);
1498 }
1499
1500 struct sfile *
1501 LuaGetSFile(lua_State *L)
1502 {
1503   struct sfile *slist;
1504   luaL_getmetatable(L, "screen");
1505   lua_pushstring(L, "_sfile");
1506   lua_rawget(L, -1);
1507   slist = (struct sfile *)lua_touserdata(L, -1);
1508   lua_pop(L, 2);
1509   return slist;
1510 }
1511
1512 void
1513 LuaPushHandler(lua_handler lh)
1514 {
1515   int funcreg;
1516   lua_State *L = lh->L;
1517   if (lh->type == LUA_HANDLER_TYPE_F)
1518     {
1519       luaL_getmetatable(L, "screen");
1520       funcreg = LuaPushHTable(L, lua_gettop(L), "_funcreg");
1521       lua_rawgeti(L, funcreg, lh->u.reference);
1522       lua_replace(L, -3);
1523       lua_pop(L, 1);
1524     }
1525   else
1526     {
1527       lua_getfield(L, LUA_GLOBALSINDEX, lh->u.name);
1528     }
1529 }
1530
1531 int
1532 LuaFuncKey(lua_State *L, int idx, int ref)
1533 {
1534   int key, funcreg, sc;
1535   luaL_getmetatable(L, "screen");
1536   sc = lua_gettop(L);
1537   funcreg = LuaPushHTable(L, sc, "_funcreg");
1538
1539   lua_pushvalue(L, idx);
1540   key = luaL_ref(L, funcreg);
1541   lua_pop(L, 2);
1542   return key;
1543 }
1544
1545 void
1546 LuaHUnRef(lua_State *L, int key)
1547 {
1548   int funcreg, sc;
1549   luaL_getmetatable(L, "screen");
1550   sc = lua_gettop(L);
1551   funcreg = LuaPushHTable(L, sc, "_funcreg");
1552   luaL_unref(L, funcreg, key);
1553 }
1554
1555 lua_handler
1556 LuaCheckHandler(lua_State *L, int idx, int ref)
1557 {
1558   int key;
1559   if (idx < 0)
1560     idx = lua_gettop(L) + 1 - idx;
1561
1562   if (lua_isstring(L, idx))
1563     {
1564       const char * handler;
1565       /* registered with func name.*/
1566       handler = luaL_checkstring(L, idx);
1567       lua_getfield(L, LUA_GLOBALSINDEX, handler);
1568       if (!lua_isfunction(L, -1))
1569         luaL_error(L, "The specified handler %s in param #%d is not a function", handler, idx);
1570       lua_pop(L, 1);
1571       return LuaAllocHandler(L, handler, 0);
1572     }
1573   else if (!lua_isfunction(L, idx))
1574     luaL_error(L, "Handler should be a function or the name of function");
1575
1576   key = LuaFuncKey(L, idx, ref);
1577   return LuaAllocHandler(L, NULL, key);
1578 }
1579
1580 /* }}} **/
1581
1582 static int
1583 LuaDispatch(void *handler, const char *params, va_list va)
1584 {
1585   lua_handler lh = (lua_handler)handler;
1586   int argc, retvalue;
1587   lua_State *L = lh->L;
1588
1589   StackDump(L, "before dispatch");
1590
1591   LuaPushHandler(lh);
1592   if (lua_isnil(L, -1))
1593     {
1594       lua_pop(L, 1);
1595       return 0;
1596     }
1597   argc = LuaPushParams(L, params, va);
1598
1599   if (lua_pcall(L, argc, 1, 0) == LUA_ERRRUN && lua_isstring(L, -1))
1600     {
1601       StackDump(L, "After LuaDispatch\n");
1602       LuaShowErr(L);
1603       return 0;
1604     }
1605   retvalue = lua_tonumber(L, -1);
1606   lua_pop(L, 1);
1607   return retvalue;
1608 }
1609
1610 /*FIXME: what if a func is registered twice or more? */
1611 void
1612 LuaRegAutoUnHook(lua_State *L, lua_handler lh, int ticket)
1613 {
1614   int sc, funcunhook;
1615   luaL_getmetatable(L, "screen");
1616   sc = lua_gettop(L);
1617   funcunhook = LuaPushHTable(L, sc, "_funcunhook");
1618   LuaPushHandler(lh);
1619   lua_pushvalue(L, ticket);
1620   lua_rawset(L, funcunhook);
1621   lua_pop(L, 2);
1622 }
1623
1624 #define SEVNAME_MAX 30
1625 static int
1626 LuaRegEvent(lua_State *L)
1627 {
1628   /* signature: hook(obj, event, handler, priv);
1629    *        or: hook(event, handler, priv)
1630    *   returns: A ticket for later unregister. */
1631   int idx = 1, argc = lua_gettop(L);
1632   unsigned int priv = 31; /* Default privilege */
1633   lua_handler lh;
1634
1635   char *obj = NULL;
1636   const char *objname = "global";
1637
1638   static char evbuf[SEVNAME_MAX];
1639   const char *event;
1640
1641   struct script_event *sev;
1642
1643   StackDump(L, "Before RegEvent\n");
1644
1645   /* Identify the object, if specified */
1646   if (luaL_getmetafield(L, 1, "_objname"))
1647     {
1648       objname = luaL_checkstring(L, -1);
1649       lua_pop(L, 1);
1650       if (!strcmp("screen", objname))
1651         objname = "global";
1652       else
1653         {
1654           obj = get_broker_obj((struct broker **)lua_touserdata(L, 1));
1655           if (!obj)
1656             return luaL_error(L, "Invalid object specified");
1657         }
1658       idx++;
1659     }
1660
1661   event = luaL_checkstring(L, idx++);
1662   snprintf(evbuf, SEVNAME_MAX, "%s_%s", objname, event);
1663
1664   /* Check and get the handler */
1665   lh = LuaCheckHandler(L, idx++, 1);
1666   if (!lh)
1667     luaL_error(L, "Out of memory");
1668
1669   StackDump(L, "In RegEvent\n");
1670
1671   if (idx <= argc)
1672     priv = luaL_checkinteger(L, idx);
1673
1674   sev = object_get_event(obj, evbuf);
1675   if (sev)
1676     {
1677       struct listener *l;
1678       int ticket;
1679       l = (struct listener *)malloc(sizeof(struct listener));
1680       if (!l)
1681         return luaL_error(L, "Out of memory");
1682       l->priv = priv;
1683       l->bd = &lua_binding;
1684       l->handler = (void *)lh;
1685       register_listener(sev, l);
1686       /* Return the ticket for un-register */
1687       push_callback(L, &l);
1688       ticket = lua_gettop(L);
1689
1690       LuaRegAutoUnHook(L, lh, ticket);
1691     }
1692   else
1693     return luaL_error(L, "Invalid event specified: %s for object %s", event, objname);
1694
1695   StackDump(L, "After RegEvent\n");
1696   return 1;
1697 }
1698
1699 /** }}} */
1700
1701 struct binding lua_binding =
1702 {
1703     "lua", /*name*/
1704     0,     /*inited*/
1705     0,     /*registered*/
1706     LuaInit,
1707     LuaFinit,
1708     LuaCall,
1709     LuaSource,
1710     LuaDispatch,
1711     0,     /*b_next*/
1712 };
1713