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
  82 static int LuaDispatch(void *handler, const char *params, va_list va);
  83 static int LuaRegEvent(lua_State *L);
  84 static int LuaUnRegEvent(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   union
  98   {
  99     const char *name;
 100     int reference;
 101   } u;
 102   struct listener *listener;
 103 };
 104
 105 typedef struct lua_handler *lua_handler;
 106 void LuaPushHandler(lua_State *L, lua_handler lh);
 107 void LuaHRef(lua_State *L, int key, int reg);
 108 lua_handler LuaCheckHandler(lua_State *L, int idx, int ref);
 109
 110 lua_handler
 111 LuaAllocHandler(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   if (name)
 119     {
 120       lh->type = LUA_HANDLER_TYPE_N;
 121       lh->u.name = name;
 122     }
 123   else
 124     {
 125       lh->type = LUA_HANDLER_TYPE_F;
 126       lh->u.reference = ref;
 127     }
 128
 129   return lh;
 130 }
 131
 132 void
 133 LuaFreeHandler(lua_State *L, struct lua_handler **lh)
 134 {
 135   if ((*lh)->type == LUA_HANDLER_TYPE_N)
 136     Free((*lh)->u.name)
 137   else
 138     {
 139       LuaHRef(L, (*lh)->u.reference, 0);
 140       (*lh)->u.reference = 0;
 141     }
 142   Free(*lh);
 143 }
 144 /** Template {{{ */
 145
 146 #define CHECK_TYPE(name, type) \
 147 static type * \
 148 check_##name(lua_State *L, int index) \
 149 { \
 150   type **var; \
 151   luaL_checktype(L, index, LUA_TUSERDATA); \
 152   var = (type **) luaL_checkudata(L, index, #name); \
 153   if (!var || !*var) \
 154     luaL_typerror(L, index, #name); \
 155   return *var; \
 156 }
 157
 158 #define PUSH_TYPE(name, type) \
 159 static void \
 160 push_##name(lua_State *L, type **t) \
 161 { \
 162   if (!t || !*t) \
 163     lua_pushnil(L); \
 164   else \
 165     { \
 166       type **r; \
 167       r = (type **)lua_newuserdata(L, sizeof(type *)); \
 168       *r = *t; \
 169       luaL_getmetatable(L, #name); \
 170       lua_setmetatable(L,-2); \
 171     } \
 172 }
 173
 174 /* Much of the following template comes from:
 175  *      http://lua-users.org/wiki/BindingWithMembersAndMethods
 176  */
 177
 178 static int get_int (lua_State *L, void *v)
 179 {
 180   lua_pushinteger (L, *(int*)v);
 181   return 1;
 182 }
 183
 184 static int set_int (lua_State *L, void *v)
 185 {
 186   *(int*)v = luaL_checkint(L, 3);
 187   return 0;
 188 }
 189
 190 static int get_number (lua_State *L, void *v)
 191 {
 192   lua_pushnumber(L, *(lua_Number*)v);
 193   return 1;
 194 }
 195
 196 static int set_number (lua_State *L, void *v)
 197 {
 198   *(lua_Number*)v = luaL_checknumber(L, 3);
 199   return 0;
 200 }
 201
 202 static int get_string (lua_State *L, void *v)
 203 {
 204   lua_pushstring(L, (char*)v );
 205   return 1;
 206 }
 207
 208 static int set_string (lua_State *L, void *v)
 209 {
 210   *(const char**)v = luaL_checkstring(L, 3);
 211   return 0;
 212 }
 213
 214 typedef int (*Xet_func) (lua_State *L, void *v);
 215
 216 /* member info for get and set handlers */
 217 struct Xet_reg
 218 {
 219   const char *name;  /* member name */
 220   Xet_func func;     /* get or set function for type of member */
 221   size_t offset;     /* offset of member within the struct */
 222   int (*absolute)(lua_State *);
 223 };
 224
 225 static void Xet_add (lua_State *L, const struct Xet_reg *l)
 226 {
 227   if (!l)
 228     return;
 229   for (; l->name; l++)
 230     {
 231       lua_pushstring(L, l->name);
 232       lua_pushlightuserdata(L, (void*)l);
 233       lua_settable(L, -3);
 234     }
 235 }
 236
 237 static int Xet_call (lua_State *L)
 238 {
 239   /* for get: stack has userdata, index, lightuserdata */
 240   /* for set: stack has userdata, index, value, lightuserdata */
 241   const struct Xet_reg *m = (const struct Xet_reg *)lua_touserdata(L, -1);  /* member info */
 242   lua_pop(L, 1);                               /* drop lightuserdata */
 243   luaL_checktype(L, 1, LUA_TUSERDATA);
 244   if (m->absolute)
 245     return m->absolute(L);
 246   return m->func(L, *(char**)lua_touserdata(L, 1) + m->offset);
 247 }
 248
 249 static int index_handler (lua_State *L)
 250 {
 251   /* stack has userdata, index */
 252   lua_pushvalue(L, 2);                     /* dup index */
 253   lua_rawget(L, lua_upvalueindex(1));      /* lookup member by name */
 254   if (!lua_islightuserdata(L, -1))
 255     {
 256       lua_pop(L, 1);                         /* drop value */
 257       lua_pushvalue(L, 2);                   /* dup index */
 258       lua_gettable(L, lua_upvalueindex(2));  /* else try methods */
 259       if (lua_isnil(L, -1))                  /* invalid member */
 260         luaL_error(L, "cannot get member '%s'", lua_tostring(L, 2));
 261       return 1;
 262     }
 263   return Xet_call(L);                      /* call get function */
 264 }
 265
 266 static int newindex_handler (lua_State *L)
 267 {
 268   /* stack has userdata, index, value */
 269   lua_pushvalue(L, 2);                     /* dup index */
 270   lua_rawget(L, lua_upvalueindex(1));      /* lookup member by name */
 271   if (!lua_islightuserdata(L, -1))         /* invalid member */
 272     luaL_error(L, "cannot set member '%s'", lua_tostring(L, 2));
 273   return Xet_call(L);                      /* call set function */
 274 }
 275
 276 static int
 277 struct_register(lua_State *L, const char *name, const luaL_reg fn_methods[], const luaL_reg meta_methods[],
 278     const struct Xet_reg setters[], const struct Xet_reg getters[])
 279 {
 280   int metatable, methods;
 281
 282   /* create methods table & add it to the table of globals */
 283   luaL_register(L, name, fn_methods);
 284   methods = lua_gettop(L);
 285
 286   /* create metatable & add it to the registry */
 287   luaL_newmetatable(L, name);
 288   luaL_register(L, 0, meta_methods);  /* fill metatable */
 289
 290   /* To identify the type of object */
 291   lua_pushstring(L, "_objname");
 292   lua_pushstring(L, name);
 293   lua_rawset(L, -3);
 294
 295   metatable = lua_gettop(L);
 296
 297   lua_pushliteral(L, "__metatable");
 298   lua_pushvalue(L, methods);    /* dup methods table*/
 299   lua_rawset(L, metatable);     /* hide metatable:
 300                                    metatable.__metatable = methods */
 301
 302   lua_pushliteral(L, "__index");
 303   lua_pushvalue(L, metatable);  /* upvalue index 1 */
 304   Xet_add(L, getters);     /* fill metatable with getters */
 305   lua_pushvalue(L, methods);    /* upvalue index 2 */
 306   lua_pushcclosure(L, index_handler, 2);
 307   lua_rawset(L, metatable);     /* metatable.__index = index_handler */
 308
 309   lua_pushliteral(L, "__newindex");
 310   lua_newtable(L);              /* table for members you can set */
 311   Xet_add(L, setters);     /* fill with setters */
 312   lua_pushcclosure(L, newindex_handler, 1);
 313   lua_rawset(L, metatable);     /* metatable.__newindex = newindex_handler */
 314
 315   /* FIXME: Why do we leave an element on the stack? */
 316   lua_pop(L, 1);                /* drop metatable */
 317   return 1;                     /* return methods on the stack */
 318 }
 319
 320 /** }}} */
 321
 322 /** Callback {{{ */
 323 PUSH_TYPE(callback, struct lua_handler)
 324
 325 CHECK_TYPE(callback, struct lua_handler)
 326
 327 static int
 328 callback_unhook(lua_State *L)
 329 {
 330   struct lua_handler *lh = check_callback(L, 1);
 331   if (!lh->listener)
 332     {
 333       lua_pushboolean(L, 0);
 334       lua_pushstring(L, "Callback already unhooked.");
 335       LuaShowErr(L);
 336     }
 337   else
 338     {
 339       if (lh->type == LUA_HANDLER_TYPE_N)
 340         {
 341           Free(lh->u.name);
 342         }
 343       else
 344         {
 345           LuaHRef(L, lh->u.reference, 0);
 346           lh->u.reference = 0;
 347         }
 348       unregister_listener(lh->listener);
 349       lh->listener = NULL;
 350       lua_pushboolean(L, 1);
 351     }
 352   return 1;
 353 }
 354
 355 static const luaL_reg callback_methods[] = {
 356   {"unhook", callback_unhook},
 357   {0, 0}
 358 };
 359
 360 static const luaL_reg callback_metamethods[] = {
 361   {0, 0}
 362 };
 363
 364 static const struct Xet_reg callback_setters[] = {
 365   {0, 0}
 366 };
 367
 368 static const struct Xet_reg callback_getters[] = {
 369   {0, 0}
 370 };
 371
 372
 373 /** }}} */
 374
 375 /** Window {{{ */
 376
 377 PUSH_TYPE(window, struct win)
 378
 379 CHECK_TYPE(window, struct win)
 380
 381 static int get_window(lua_State *L, void *v)
 382 {
 383   push_window(L, (struct win **)v);
 384   return 1;
 385 }
 386
 387 static int
 388 window_change_title(lua_State *L)
 389 {
 390   struct win *w = check_window(L, 1);
 391   unsigned int len;
 392   const char *title = luaL_checklstring(L, 2, &len);
 393   ChangeAKA(w, (char *)title, len);
 394   return 0;
 395 }
 396
 397 static int
 398 window_get_monitor_status(lua_State *L)
 399 {
 400   struct win *w = check_window(L, 1);
 401   int activity = luaL_checkint(L, 2);
 402   if (activity)
 403     /*monitor*/
 404     lua_pushinteger(L, w->w_monitor != MON_OFF);
 405   else
 406     /*silence*/
 407     lua_pushinteger(L, w->w_silence == SILENCE_ON ? w->w_silencewait: 0);
 408
 409   return 1;
 410 }
 411
 412 static const luaL_reg window_methods[] = {
 413   {"get_monitor_status", window_get_monitor_status},
 414   {"hook", LuaRegEvent},
 415   {0, 0}
 416 };
 417
 418 static int
 419 window_tostring(lua_State *L)
 420 {
 421   char str[128];
 422   struct win *w = check_window(L, 1);
 423   snprintf(str, sizeof(str), "{window #%d: '%s'}", w->w_number, w->w_title);
 424   lua_pushstring(L, str);
 425   return 1;
 426 }
 427
 428 static int
 429 window_equality(lua_State *L)
 430 {
 431   struct win *w1 = check_window(L, 1), *w2 = check_window(L, 2);
 432   lua_pushboolean(L, (w1 == w2 || (w1 && w2 && w1->w_number == w2->w_number)));
 433   return 1;
 434 }
 435
 436 static const luaL_reg window_metamethods[] = {
 437   {"__tostring", window_tostring},
 438   {"__eq", window_equality},
 439   {0, 0}
 440 };
 441
 442 static const struct Xet_reg window_setters[] = {
 443   {"title", 0, 0, window_change_title/*absolute setter*/},
 444   {0, 0}
 445 };
 446
 447 static const struct Xet_reg window_getters[] = {
 448   {"title", get_string, offsetof(struct win, w_title) + 8},
 449   {"number", get_int, offsetof(struct win, w_number)},
 450   {"dir", get_string, offsetof(struct win, w_dir)},
 451   {"tty", get_string, offsetof(struct win, w_tty)},
 452   {"pid", get_int, offsetof(struct win, w_pid)},
 453   {"group", get_window, offsetof(struct win, w_group)},
 454   {"bell", get_int, offsetof(struct win, w_bell)},
 455   {0, 0}
 456 };
 457
 458
 459 /** }}} */
 460
 461 /** AclUser {{{ */
 462
 463 PUSH_TYPE(user, struct acluser)
 464
 465 CHECK_TYPE(user, struct acluser)
 466
 467 static int
 468 get_user(lua_State *L, void *v)
 469 {
 470   push_user(L, (struct acluser **)v);
 471   return 1;
 472 }
 473
 474 static const luaL_reg user_methods[] = {
 475   {0, 0}
 476 };
 477
 478 static int
 479 user_tostring(lua_State *L)
 480 {
 481   char str[128];
 482   struct acluser *u = check_user(L, 1);
 483   snprintf(str, sizeof(str), "{user '%s'}", u->u_name);
 484   lua_pushstring(L, str);
 485   return 1;
 486 }
 487
 488 static const luaL_reg user_metamethods[] = {
 489   {"__tostring", user_tostring},
 490   {0, 0}
 491 };
 492
 493 static const struct Xet_reg user_setters[] = {
 494   {0, 0}
 495 };
 496
 497 static const struct Xet_reg user_getters[] = {
 498   {"name", get_string, offsetof(struct acluser, u_name)},
 499   {"password", get_string, offsetof(struct acluser, u_password)},
 500   {0, 0}
 501 };
 502
 503 /** }}} */
 504
 505 /** Canvas {{{ */
 506
 507 PUSH_TYPE(canvas, struct canvas)
 508
 509 CHECK_TYPE(canvas, struct canvas)
 510
 511 static int
 512 get_canvas(lua_State *L, void *v)
 513 {
 514   push_canvas(L, (struct canvas **)v);
 515   return 1;
 516 }
 517
 518 static int
 519 canvas_select(lua_State *L)
 520 {
 521   struct canvas *c = check_canvas(L, 1);
 522   if (!display || D_forecv == c)
 523     return 0;
 524   SetCanvasWindow(c, Layer2Window(c->c_layer));
 525   D_forecv = c;
 526
 527   /* XXX: the following all is duplicated from process.c:DoAction.
 528    * Should these be in some better place?
 529    */
 530   ResizeCanvas(&D_canvas);
 531   RecreateCanvasChain();
 532   RethinkDisplayViewports();
 533   ResizeLayersToCanvases();     /* redisplays */
 534   fore = D_fore = Layer2Window(D_forecv->c_layer);
 535   flayer = D_forecv->c_layer;
 536 #ifdef RXVT_OSC
 537   if (D_xtermosc[2] || D_xtermosc[3])
 538     {
 539       Activate(-1);
 540       break;
 541     }
 542 #endif
 543   RefreshHStatus();
 544 #ifdef RXVT_OSC
 545   RefreshXtermOSC();
 546 #endif
 547   flayer = D_forecv->c_layer;
 548   CV_CALL(D_forecv, LayRestore();LaySetCursor());
 549   WindowChanged(0, 'F');
 550   return 1;
 551 }
 552
 553 static const luaL_reg canvas_methods[] = {
 554   {"select", canvas_select},
 555   {0, 0}
 556 };
 557
 558 static const luaL_reg canvas_metamethods[] = {
 559   {0, 0}
 560 };
 561
 562 static const struct Xet_reg canvas_setters[] = {
 563   {0, 0}
 564 };
 565
 566 static int
 567 canvas_get_window(lua_State *L)
 568 {
 569   struct canvas *c = check_canvas(L, 1);
 570   struct win *win = Layer2Window(c->c_layer);
 571   if (win)
 572     push_window(L, &win);
 573   else
 574     lua_pushnil(L);
 575   return 1;
 576 }
 577
 578 static const struct Xet_reg canvas_getters[] = {
 579   {"next", get_canvas, offsetof(struct canvas, c_next)},
 580   {"xoff", get_int, offsetof(struct canvas, c_xoff)},
 581   {"yoff", get_int, offsetof(struct canvas, c_yoff)},
 582   {"xs", get_int, offsetof(struct canvas, c_xs)},
 583   {"ys", get_int, offsetof(struct canvas, c_ys)},
 584   {"xe", get_int, offsetof(struct canvas, c_xe)},
 585   {"ye", get_int, offsetof(struct canvas, c_ye)},
 586   {"window", 0, 0, canvas_get_window},
 587   {0, 0}
 588 };
 589
 590 /** }}} */
 591
 592 /** Layout {{{ */
 593
 594 PUSH_TYPE(layout, struct layout)
 595 CHECK_TYPE(layout, struct layout)
 596
 597 static const struct Xet_reg layout_getters[] = {
 598       {0,0}
 599 };
 600
 601 static int
 602 get_layout(lua_State *L, void *v)
 603 {
 604   push_layout(L, (struct layout **)v);
 605   return 1;
 606 }
 607
 608 /** }}} */
 609
 610 /** Display {{{ */
 611
 612 PUSH_TYPE(display, struct display)
 613
 614 CHECK_TYPE(display, struct display)
 615
 616 static int
 617 display_get_canvases(lua_State *L)
 618 {
 619   struct display *d;
 620   struct canvas *iter;
 621   int count;
 622
 623   d = check_display(L, 1);
 624   lua_newtable(L);
 625   for (iter = d->d_cvlist, count = 0; iter; iter = iter->c_next, count++) {
 626     lua_pushinteger(L, count);
 627     push_canvas(L, &iter);
 628     lua_settable(L, -3);
 629   }
 630
 631   return 1;
 632 }
 633
 634 static const luaL_reg display_methods[] = {
 635   {"get_canvases", display_get_canvases},
 636   {0, 0}
 637 };
 638
 639 static int
 640 display_tostring(lua_State *L)
 641 {
 642   char str[128];
 643   struct display *d = check_display(L, 1);
 644   snprintf(str, sizeof(str), "{display: tty = '%s', term = '%s'}", d->d_usertty, d->d_termname);
 645   lua_pushstring(L, str);
 646   return 1;
 647 }
 648
 649 static const luaL_reg display_metamethods[] = {
 650   {"__tostring", display_tostring},
 651   {0, 0}
 652 };
 653
 654 static const struct Xet_reg display_setters[] = {
 655   {0, 0}
 656 };
 657
 658 static const struct Xet_reg display_getters[] = {
 659   {"tty", get_string, offsetof(struct display, d_usertty)},
 660   {"term", get_string, offsetof(struct display, d_termname)},
 661   {"fore", get_window, offsetof(struct display, d_fore)},
 662   {"other", get_window, offsetof(struct display, d_other)},
 663   {"width", get_int, offsetof(struct display, d_width)},
 664   {"height", get_int, offsetof(struct display, d_height)},
 665   {"user", get_user, offsetof(struct display, d_user)},
 666   {"layout", get_layout, offsetof(struct display, d_layout)},
 667   {0, 0}
 668 };
 669
 670 /** }}} */
 671
 672 /** Screen {{{ */
 673
 674 static int
 675 screen_get_windows(lua_State *L)
 676 {
 677   struct win *iter;
 678   int count;
 679
 680   lua_newtable(L);
 681   for (iter = windows, count = 0; iter; iter = iter->w_next, count++) {
 682     lua_pushinteger(L, iter->w_number);
 683     push_window(L, &iter);
 684     lua_settable(L, -3);
 685   }
 686
 687   return 1;
 688 }
 689
 690 static int
 691 screen_get_displays(lua_State *L)
 692 {
 693   struct display *iter;
 694   int count;
 695
 696   lua_newtable(L);
 697   for (iter = displays, count = 0; iter; iter = iter->d_next, count++) {
 698     lua_pushinteger(L, count);
 699     push_display(L, &iter);
 700     lua_settable(L, -3);
 701   }
 702
 703   return 1;
 704 }
 705
 706 static int
 707 screen_get_display(lua_State *L)
 708 {
 709   push_display(L, &display);
 710   return 1;
 711 }
 712
 713 static int
 714 screen_exec_command(lua_State *L)
 715 {
 716   const char *command;
 717   unsigned int len;
 718
 719   command = luaL_checklstring(L, 1, &len);
 720   if (command)
 721     RcLine((char *)command, len);
 722
 723   return 0;
 724 }
 725
 726 static int
 727 screen_append_msg(lua_State *L)
 728 {
 729   const char *msg, *color;
 730   unsigned int len;
 731   msg = luaL_checklstring(L, 1, &len);
 732   if (lua_isnil(L, 2))
 733     color = NULL;
 734   else
 735     color = luaL_checklstring(L, 2, &len);
 736   AppendWinMsgRend(msg, color);
 737   return 0;
 738 }
 739
 740 struct sinput_data
 741 {
 742   lua_State *L;
 743   lua_handler lh;
 744 };
 745
 746 void
 747 script_input_fn(char *buf, int len, char *priv)
 748 {
 749   struct sinput_data *sidata = (struct sinput_data *)priv;
 750   lua_handler lh = sidata->lh;
 751   lua_State *L = sidata->L;
 752
 753   LuaPushHandler(L, lh);
 754   lua_pushstring(L, buf);
 755   if (lua_pcall(L, 1, 0, 0) == LUA_ERRRUN)
 756     {
 757       if(lua_isstring(L, -1))
 758         {
 759           LuaShowErr(L);
 760         }
 761     }
 762   free(sidata);
 763   LuaFreeHandler(L, &lh);
 764 }
 765
 766 static int
 767 screen_input(lua_State *L)
 768 {
 769   char * prompt = NULL;
 770   lua_handler lh;
 771   struct sinput_data *sidata;
 772
 773   prompt = (char *)luaL_checkstring(L, 1);
 774   lh = LuaCheckHandler(L, 2, 1);
 775   sidata = (struct sinput_data *)malloc(sizeof(struct sinput_data));
 776   if (!sidata)
 777     luaL_error(L, "Out of Memory");
 778
 779   sidata->L = L;
 780   sidata->lh = lh;
 781   Input(prompt, 100, INP_COOKED, script_input_fn, (char *)sidata, 0);
 782
 783   return 0;
 784 }
 785
 786 static const luaL_reg screen_methods[] = {
 787   {"windows", screen_get_windows},
 788   {"displays", screen_get_displays},
 789   {"display", screen_get_display},
 790   {"command", screen_exec_command},
 791   {"append_msg", screen_append_msg},
 792   {"hook", LuaRegEvent},
 793   {"input", screen_input},
 794   {0, 0}
 795 };
 796
 797 static const luaL_reg screen_metamethods[] = {
 798   {0, 0}
 799 };
 800
 801 static const struct Xet_reg screen_setters[] = {
 802   {0, 0}
 803 };
 804
 805 static const struct Xet_reg screen_getters[] = {
 806   {0, 0}
 807 };
 808
 809 /** }}} */
 810
 811 /** Public functions {{{ */
 812
 813 /* FIXME: Think about this: will it affect the registered handlers?*/
 814 static lua_State *L;
 815 int LuaInit(void)
 816 {
 817   L = luaL_newstate();
 818
 819   luaL_openlibs(L);
 820
 821 #define REGISTER(X) struct_register(L, #X , X ## _methods, X##_metamethods, X##_setters, X##_getters)
 822
 823   REGISTER(screen);
 824   REGISTER(window);
 825   REGISTER(display);
 826   REGISTER(user);
 827   REGISTER(canvas);
 828   REGISTER(callback);
 829
 830   /* To store handler funcs */
 831   luaL_getmetatable(L, "screen");
 832   /* two kinds of info in this table:
 833    * _funckey[func]->key
 834    * _funckey[key]->refcnt */
 835   lua_pushstring(L, "_funckey");
 836   lua_newtable(L);
 837   lua_rawset(L, -3);
 838   /* two kinds of info in this table:
 839    * _keyfunc[key]->func */
 840   lua_pushstring(L, "_keyfunc");
 841   lua_newtable(L);
 842   lua_rawset(L, -3);
 843   lua_pop(L, 1);
 844
 845   return 0;
 846 }
 847
 848 /* An error message on top of the stack. */
 849 static void
 850 LuaShowErr(lua_State *L)
 851 {
 852   struct display *d = display;
 853   unsigned int len;
 854   const char *message = luaL_checklstring(L, -1, &len);
 855   LMsg(0, "%s", message ? message : "Unknown error");
 856   lua_pop(L, 1);
 857   display = d;
 858 }
 859
 860 struct fn_def
 861 {
 862   void (*push_fn)(lua_State *, void*);
 863   void *value;
 864 };
 865
 866 static int
 867 LuaCallProcess(const char *name, struct fn_def defs[])
 868 {
 869   int argc = 0;
 870
 871   lua_getfield(L, LUA_GLOBALSINDEX, name);
 872   if (lua_isnil(L, -1))
 873     {
 874       lua_pop(L,1);
 875       return 0;
 876     }
 877   for (argc = 0; defs[argc].push_fn; argc++)
 878     defs[argc].push_fn(L, defs[argc].value);
 879   if (lua_pcall(L, argc, 0, 0) == LUA_ERRRUN && lua_isstring(L, -1))
 880     {
 881       LuaShowErr(L);
 882       return 0;
 883     }
 884   return 1;
 885 }
 886
 887 int LuaSource(const char *file, int async)
 888 {
 889   if (!L)
 890     return 0;
 891   struct stat st;
 892   if (stat(file, &st) == -1)
 893     Msg(errno, "Error loading lua script file '%s'", file);
 894   else
 895     {
 896       int len = strlen(file);
 897       if (len < 4 || strncmp(file + len - 4, ".lua", 4) != 0)
 898         return 0;
 899       if (luaL_dofile(L, file) && lua_isstring(L, -1))
 900         {
 901           LuaShowErr(L);
 902         }
 903       return 1;
 904     }
 905   return 0;
 906 }
 907
 908 int LuaFinit(void)
 909 {
 910   if (!L)
 911     return 0;
 912   lua_close(L);
 913   L = (lua_State*)0;
 914   return 0;
 915 }
 916
 917 int
 918 LuaProcessCaption(const char *caption, struct win *win, int len)
 919 {
 920   if (!L)
 921     return 0;
 922   struct fn_def params[] = {
 923     {lua_pushstring, caption},
 924     {push_window, &win},
 925     {lua_pushinteger, len},
 926     {NULL, NULL}
 927   };
 928   return LuaCallProcess("process_caption", params);
 929 }
 930
 931 static void
 932 push_stringarray(lua_State *L, char **args)
 933 {
 934   int i;
 935   lua_newtable(L);
 936   for (i = 1; args && *args; i++) {
 937     lua_pushinteger(L, i);
 938     lua_pushstring(L, *args++);
 939     lua_settable(L, -3);
 940   }
 941 }
 942
 943 int
 944 LuaPushParams(lua_State *L, const char *params, va_list va)
 945 {
 946   int num = 0;
 947   while (*params)
 948     {
 949       switch (*params)
 950         {
 951         case 's':
 952           lua_pushstring(L, va_arg(va, char *));
 953           break;
 954         case 'S':
 955           push_stringarray(L, va_arg(va, char **));
 956           break;
 957         case 'i':
 958           lua_pushinteger(L, va_arg(va, int));
 959           break;
 960         case 'd':
 961           {
 962             struct display *d = va_arg(va, struct display *);
 963             push_display(L, &d);
 964             break;
 965           }
 966         }
 967       params++;
 968       num++;
 969     }
 970   return num;
 971 }
 972
 973 int LuaCall(const char *func, const char **argv)
 974 {
 975   int argc;
 976   if (!L)
 977     return 0;
 978
 979   StackDump(L, "Before LuaCall\n");
 980   lua_getfield(L, LUA_GLOBALSINDEX, func);
 981   if (lua_isnil(L, -1))
 982     {
 983       lua_pop(L, 1);
 984       lua_pushstring(L, "Could not find the script function\n");
 985       LuaShowErr(L);
 986       return 0;
 987     }
 988   for (argc = 0; *argv; argv++, argc++)
 989     {
 990       lua_pushstring(L, *argv);
 991     }
 992   if (lua_pcall(L, argc, 0, 0) == LUA_ERRRUN)
 993     {
 994       if(lua_isstring(L, -1))
 995         {
 996           StackDump(L, "After LuaCall\n");
 997           LuaShowErr(L);
 998           return 0;
 999         }
1000     }
1001   return 1;
1002 }
1003
1004 /*** Lua callback handler management {{{ */
1005
1006 int
1007 LuaPushHTable(lua_State *L, int screen, const char * t)
1008 {
1009   lua_pushstring(L, t);
1010   lua_rawget(L, screen);
1011   /* FIXME: Do we need to balance the stack here? */
1012   if (lua_isnil(L, -1))
1013     luaL_error(L, "Fatal! Fail to get function registeration table!");
1014   return lua_gettop(L);
1015 }
1016
1017 void
1018 LuaPushHandler(lua_State *L, lua_handler lh)
1019 {
1020   int keyfunc;
1021   if (lh->type == LUA_HANDLER_TYPE_F)
1022     {
1023       luaL_getmetatable(L, "screen");
1024       keyfunc = LuaPushHTable(L, lua_gettop(L), "_keyfunc");
1025       lua_rawgeti(L, keyfunc, lh->u.reference);
1026       lua_replace(L, -3);
1027       lua_pop(L, 1);
1028     }
1029   else
1030     {
1031       lua_getfield(L, LUA_GLOBALSINDEX, lh->u.name);
1032     }
1033 }
1034
1035 void
1036 LuaHRef(lua_State *L, int key, int reg)
1037 {
1038   int funckey, keyfunc, cnt, sc, idx;
1039   luaL_getmetatable(L, "screen");
1040   sc = lua_gettop(L);
1041   funckey = LuaPushHTable(L, sc, "_funckey");
1042   keyfunc = LuaPushHTable(L, sc, "_keyfunc");
1043
1044   lua_rawgeti(L, keyfunc, key);
1045   idx = lua_gettop(L);
1046
1047   lua_rawgeti(L, funckey, key);
1048   cnt = lua_tointeger(L, -1);/*cnt = htable[key]*/
1049   if (!reg && cnt <= 1)
1050     {
1051       /*release the last reference*/
1052       luaL_unref(L, funckey, key);
1053       lua_pushvalue(L, idx);
1054       lua_pushnil(L);
1055       lua_settable(L, funckey); /*htable[func]=key*/
1056     }
1057   else
1058     {
1059       lua_pushinteger(L, key);
1060       lua_pushinteger(L, reg? cnt + 1 : cnt - 1);
1061       lua_settable(L, funckey); /*htable[key] = cnt + 1*/
1062     }
1063   lua_pop(L, 5);
1064 }
1065
1066 /* Ref when asked to. Never unref*/
1067 int
1068 LuaFuncKey(lua_State *L, int idx, int ref)
1069 {
1070   int key, funckey, sc;
1071   luaL_getmetatable(L, "screen");
1072   sc = lua_gettop(L);
1073   funckey = LuaPushHTable(L, sc, "_funckey");
1074
1075   lua_pushvalue(L, idx);
1076   lua_gettable(L, funckey);/*funckey[func] ==?*/
1077   if (lua_isnil(L, -1))
1078     {
1079       /* Not found, alloc a new key */
1080       if (!ref)
1081         return LUA_NOREF;
1082
1083       /*funckey[key] = 1*/
1084       lua_pushinteger(L, 1);
1085       key = luaL_ref(L, funckey);
1086
1087       /*funckey[func]=key*/
1088       lua_pushvalue(L, idx);
1089       lua_pushinteger(L, key);
1090       lua_settable(L, funckey);
1091
1092       int keyfunc = LuaPushHTable(L, sc, "_keyfunc");
1093       /*keyfunc[key] = func*/
1094       lua_pushinteger(L, key);
1095       lua_pushvalue(L, idx);
1096       lua_settable(L, keyfunc);
1097
1098       lua_pop(L, 1);
1099     }
1100   else
1101     {
1102       key = lua_tointeger(L, -1);/*key = funckey[func]*/
1103       if (ref)
1104         LuaHRef(L, key, 1);
1105     }
1106
1107   lua_pop(L, 3);
1108   return key;
1109 }
1110
1111 lua_handler
1112 LuaCheckHandler(lua_State *L, int idx, int ref)
1113 {
1114   int key;
1115   if (lua_isstring(L, idx))
1116     {
1117       const char * handler;
1118       /* registered with func name.*/
1119       handler = luaL_checkstring(L, idx);
1120       lua_getfield(L, LUA_GLOBALSINDEX, handler);
1121       if (!lua_isfunction(L, -1))
1122         luaL_error(L, "The specified handler %s in param #%d is not a function", handler, idx);
1123       lua_pop(L, 1);
1124       return LuaAllocHandler(handler, 0);
1125     }
1126   else if (!lua_isfunction(L, idx))
1127     luaL_error(L, "Handler should be a function or the name of function");
1128
1129   key = LuaFuncKey(L, idx, ref);
1130   return LuaAllocHandler(NULL, key);
1131 }
1132
1133 int
1134 LuaHdlrComp(void *h1, void *h2)
1135 {
1136   return (lua_handler)h1 - (lua_handler)h2;
1137 }
1138
1139 /* }}} **/
1140
1141 static int
1142 LuaDispatch(void *handler, const char *params, va_list va)
1143 {
1144   lua_handler lh = (lua_handler)handler;
1145   int argc, retvalue;
1146
1147   StackDump(L, "before dispatch");
1148
1149   LuaPushHandler(L, lh);
1150   if (lua_isnil(L, -1))
1151     {
1152       lua_pop(L, 1);
1153       return 0;
1154     }
1155   argc = LuaPushParams(L, params, va);
1156
1157   if (lua_pcall(L, argc, 1, 0) == LUA_ERRRUN && lua_isstring(L, -1))
1158     {
1159       StackDump(L, "After LuaDispatch\n");
1160       LuaShowErr(L);
1161       return 0;
1162     }
1163   retvalue = lua_tonumber(L, -1);
1164   lua_pop(L, 1);
1165   return retvalue;
1166 }
1167
1168 int LuaForeWindowChanged(void)
1169 {
1170   struct fn_def params[] = {
1171         {push_display, &display},
1172         {push_window, display ? &D_fore : &fore},
1173         {NULL, NULL}
1174   };
1175   if (!L)
1176     return 0;
1177   return LuaCallProcess("fore_changed", params);
1178 }
1179
1180 #define SEVNAME_MAX 30
1181 static int
1182 LuaRegEvent(lua_State *L)
1183 {
1184   /* signature: hook(obj, event, handler, priv);
1185    *        or: hook(event, handler, priv)
1186    *   returns: A ticket for later unregister. */
1187   int idx = 1, argc = lua_gettop(L);
1188   unsigned int priv = 31; /* Default privilege */
1189   lua_handler lh;
1190
1191   char *obj = NULL;
1192   const char *objname = "global";
1193
1194   static char evbuf[SEVNAME_MAX];
1195   const char *event;
1196
1197   struct script_event *sev;
1198
1199   StackDump(L, "Before RegEvent\n");
1200
1201   /* Identify the object, if specified */
1202   if (luaL_getmetafield(L, 1, "_objname"))
1203     {
1204       objname = luaL_checkstring(L, -1);
1205       lua_pop(L, 1);
1206       if (!strcmp("screen", objname))
1207         objname = "global";
1208       else
1209         obj = *(char **)lua_touserdata(L, 1);
1210       idx++;
1211     }
1212
1213   event = luaL_checkstring(L, idx++);
1214   snprintf(evbuf, SEVNAME_MAX, "%s_%s", objname, event);
1215
1216   /* Check and get the handler */
1217   lh = LuaCheckHandler(L, idx++, 1);
1218   if (!lh)
1219     luaL_error(L, "Out of memory");
1220
1221   StackDump(L, "In RegEvent\n");
1222
1223   if (idx <= argc)
1224     priv = luaL_checkinteger(L, idx);
1225
1226   sev = object_get_event(obj, evbuf);
1227   if (sev)
1228     {
1229       struct listener *l;
1230       l = (struct listener *)malloc(sizeof(struct listener));
1231       if (!l)
1232         return luaL_error(L, "Out of memory");
1233       l->priv = priv;
1234       l->bd = &lua_binding;
1235       l->handler = (void *)lh;
1236       if (register_listener(sev, l))
1237         {
1238           free(l);
1239           if (lh->type == LUA_HANDLER_TYPE_N)
1240             return luaL_error(L, "Handler %s has already been registered", lh->u.name);
1241           else
1242             return luaL_error(L, "Handler has already been registered");
1243         }
1244       /* Return the handler for un-register */
1245       /*l->handler = lua_newuserdata(L, sizeof(struct lua_handler));
1246       memcpy(l->handler, &lh, sizeof(struct lua_handler));*/
1247       lh->listener = l;
1248       push_callback(L, (lua_handler *)&l->handler);
1249     }
1250   else
1251     return luaL_error(L, "Invalid event specified: %s for object %s", event, objname);
1252
1253   StackDump(L, "After RegEvent\n");
1254   return 1;
1255 }
1256
1257 static int
1258 LuaUnRegEvent(lua_State *L)
1259 {
1260   /* signature: unhook([obj], ticket)
1261    *   returns: true of success, false otherwise */
1262   int idx = 1;
1263   struct listener *l;
1264
1265   /* If the param is not as expected */
1266   if (!lua_islightuserdata(L, idx))
1267     {
1268       /* Then it should be the userdata to be ignore, but if not ...  */
1269       if (!lua_isuserdata(L, idx))
1270         luaL_checktype(L, idx, LUA_TLIGHTUSERDATA);
1271       idx++;
1272       luaL_checktype(L, idx, LUA_TLIGHTUSERDATA);
1273     }
1274
1275   l = (struct listener*)lua_touserdata(L, idx++);
1276
1277   /* Validate the listener structure */
1278   if (!l || !l->handler)
1279     {
1280       /* invalid */
1281       lua_pushboolean(L,0);
1282     }
1283   else
1284     {
1285       LuaFreeHandler(L, ((lua_handler *)&(l->handler)));
1286       unregister_listener(l);
1287       lua_pushboolean(L, 1);
1288     }
1289
1290   return 1;
1291 }
1292
1293 /** }}} */
1294
1295 struct ScriptFuncs LuaFuncs =
1296 {
1297   LuaForeWindowChanged,
1298   LuaProcessCaption
1299 };
1300
1301 struct binding lua_binding =
1302 {
1303     "lua", /*name*/
1304     0,     /*inited*/
1305     0,     /*registered*/
1306     LuaInit,
1307     LuaFinit,
1308     LuaCall,
1309     LuaSource,
1310     LuaDispatch,
1311     LuaHdlrComp,
1312     0,     /*b_next*/
1313     &LuaFuncs
1314 };
1315