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