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