src/lua.c

   1 /* Lua scripting support
   2  *
   3  * Copyright (c) 2008 Sadrul Habib Chowdhury (sadrul@users.sf.net)
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program (see the file COPYING); if not, write to the
  17  * Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  19  *
  20  ****************************************************************
  21  */
  22 #include <sys/types.h>
  23 #include "config.h"
  24 #include "screen.h"
  25 #include <sys/stat.h>
  26 #include <unistd.h>
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31
  32 #include "extern.h"
  33 #include "logfile.h"
  34
  35 #include <lua.h>
  36 #include <lauxlib.h>
  37 #include <lualib.h>
  38
  39 extern struct win *windows, *fore;
  40 extern struct display *displays, *display;
  41 extern struct LayFuncs WinLf;
  42 extern struct layer *flayer;
  43
  44 /** Template {{{ */
  45
  46 #define CHECK_TYPE(name, type) \
  47 static type * \
  48 check_##name(lua_State *L, int index) \
  49 { \
  50   type **var; \
  51   luaL_checktype(L, index, LUA_TUSERDATA); \
  52   var = (type **) luaL_checkudata(L, index, #name); \
  53   if (!var || !*var) \
  54     luaL_typerror(L, index, #name); \
  55   return *var; \
  56 }
  57
  58 #define PUSH_TYPE(name, type) \
  59 static void \
  60 push_##name(lua_State *L, type **t) \
  61 { \
  62   if (!t || !*t) \
  63     lua_pushnil(L); \
  64   else \
  65     { \
  66       type **r; \
  67       r = (type **)lua_newuserdata(L, sizeof(type *)); \
  68       *r = *t; \
  69       luaL_getmetatable(L, #name); \
  70       lua_setmetatable(L,-2); \
  71     } \
  72 }
  73
  74 /* Much of the following template comes from:
  75  *      http://lua-users.org/wiki/BindingWithMembersAndMethods
  76  */
  77
  78 static int get_int (lua_State *L, void *v)
  79 {
  80   lua_pushinteger (L, *(int*)v);
  81   return 1;
  82 }
  83
  84 static int set_int (lua_State *L, void *v)
  85 {
  86   *(int*)v = luaL_checkint(L, 3);
  87   return 0;
  88 }
  89
  90 static int get_number (lua_State *L, void *v)
  91 {
  92   lua_pushnumber(L, *(lua_Number*)v);
  93   return 1;
  94 }
  95
  96 static int set_number (lua_State *L, void *v)
  97 {
  98   *(lua_Number*)v = luaL_checknumber(L, 3);
  99   return 0;
 100 }
 101
 102 static int get_string (lua_State *L, void *v)
 103 {
 104   lua_pushstring(L, (char*)v );
 105   return 1;
 106 }
 107
 108 static int set_string (lua_State *L, void *v)
 109 {
 110   *(const char**)v = luaL_checkstring(L, 3);
 111   return 0;
 112 }
 113
 114 typedef int (*Xet_func) (lua_State *L, void *v);
 115
 116 /* member info for get and set handlers */
 117 struct Xet_reg
 118 {
 119   const char *name;  /* member name */
 120   Xet_func func;     /* get or set function for type of member */
 121   size_t offset;     /* offset of member within the struct */
 122   int (*absolute)(lua_State *);
 123 };
 124
 125 static void Xet_add (lua_State *L, const struct Xet_reg *l)
 126 {
 127   if (!l)
 128     return;
 129   for (; l->name; l++)
 130     {
 131       lua_pushstring(L, l->name);
 132       lua_pushlightuserdata(L, (void*)l);
 133       lua_settable(L, -3);
 134     }
 135 }
 136
 137 static int Xet_call (lua_State *L)
 138 {
 139   /* for get: stack has userdata, index, lightuserdata */
 140   /* for set: stack has userdata, index, value, lightuserdata */
 141   const struct Xet_reg *m = (const struct Xet_reg *)lua_touserdata(L, -1);  /* member info */
 142   lua_pop(L, 1);                               /* drop lightuserdata */
 143   luaL_checktype(L, 1, LUA_TUSERDATA);
 144   if (m->absolute)
 145     return m->absolute(L);
 146   return m->func(L, *(char**)lua_touserdata(L, 1) + m->offset);
 147 }
 148
 149 static int index_handler (lua_State *L)
 150 {
 151   /* stack has userdata, index */
 152   lua_pushvalue(L, 2);                     /* dup index */
 153   lua_rawget(L, lua_upvalueindex(1));      /* lookup member by name */
 154   if (!lua_islightuserdata(L, -1))
 155     {
 156       lua_pop(L, 1);                         /* drop value */
 157       lua_pushvalue(L, 2);                   /* dup index */
 158       lua_gettable(L, lua_upvalueindex(2));  /* else try methods */
 159       if (lua_isnil(L, -1))                  /* invalid member */
 160         luaL_error(L, "cannot get member '%s'", lua_tostring(L, 2));
 161       return 1;
 162     }
 163   return Xet_call(L);                      /* call get function */
 164 }
 165
 166 static int newindex_handler (lua_State *L)
 167 {
 168   /* stack has userdata, index, value */
 169   lua_pushvalue(L, 2);                     /* dup index */
 170   lua_rawget(L, lua_upvalueindex(1));      /* lookup member by name */
 171   if (!lua_islightuserdata(L, -1))         /* invalid member */
 172     luaL_error(L, "cannot set member '%s'", lua_tostring(L, 2));
 173   return Xet_call(L);                      /* call set function */
 174 }
 175
 176 static int
 177 struct_register(lua_State *L, const char *name, const luaL_reg fn_methods[], const luaL_reg meta_methods[],
 178     const struct Xet_reg setters[], const struct Xet_reg getters[])
 179 {
 180   int metatable, methods;
 181
 182   /* create methods table & add it to the table of globals */
 183   luaL_register(L, name, fn_methods);
 184   methods = lua_gettop(L);
 185
 186   /* create metatable & add it to the registry */
 187   luaL_newmetatable(L, name);
 188   luaL_register(L, 0, meta_methods);  /* fill metatable */
 189   metatable = lua_gettop(L);
 190
 191   lua_pushliteral(L, "__metatable");
 192   lua_pushvalue(L, methods);    /* dup methods table*/
 193   lua_rawset(L, metatable);     /* hide metatable:
 194                                    metatable.__metatable = methods */
 195
 196   lua_pushliteral(L, "__index");
 197   lua_pushvalue(L, metatable);  /* upvalue index 1 */
 198   Xet_add(L, getters);     /* fill metatable with getters */
 199   lua_pushvalue(L, methods);    /* upvalue index 2 */
 200   lua_pushcclosure(L, index_handler, 2);
 201   lua_rawset(L, metatable);     /* metatable.__index = index_handler */
 202
 203   lua_pushliteral(L, "__newindex");
 204   lua_newtable(L);              /* table for members you can set */
 205   Xet_add(L, setters);     /* fill with setters */
 206   lua_pushcclosure(L, newindex_handler, 1);
 207   lua_rawset(L, metatable);     /* metatable.__newindex = newindex_handler */
 208
 209   lua_pop(L, 1);                /* drop metatable */
 210   return 1;                     /* return methods on the stack */
 211 }
 212
 213 /** }}} */
 214
 215 /** Window {{{ */
 216
 217 PUSH_TYPE(window, struct win)
 218
 219 CHECK_TYPE(window, struct win)
 220
 221 static int get_window(lua_State *L, void *v)
 222 {
 223   push_window(L, (struct win **)v);
 224   return 1;
 225 }
 226
 227 static int
 228 window_change_title(lua_State *L)
 229 {
 230   struct win *w = check_window(L, 1);
 231   unsigned int len;
 232   const char *title = luaL_checklstring(L, 2, &len);
 233   ChangeAKA(w, (char *)title, len);
 234   return 0;
 235 }
 236
 237 static int
 238 window_get_monitor_status(lua_State *L)
 239 {
 240   struct win *w = check_window(L, 1);
 241   int activity = luaL_checkint(L, 2);
 242   if (activity)
 243     /*monitor*/
 244     lua_pushinteger(L, w->w_monitor != MON_OFF);
 245   else
 246     /*silence*/
 247     lua_pushinteger(L, w->w_silence == SILENCE_ON ? w->w_silencewait: 0);
 248
 249   return 1;
 250 }
 251
 252 static const luaL_reg window_methods[] = {
 253   {"get_monitor_status", window_get_monitor_status},
 254   {0, 0}
 255 };
 256
 257 static int
 258 window_tostring(lua_State *L)
 259 {
 260   char str[128];
 261   struct win *w = check_window(L, 1);
 262   snprintf(str, sizeof(str), "{window #%d: '%s'}", w->w_number, w->w_title);
 263   lua_pushstring(L, str);
 264   return 1;
 265 }
 266
 267 static int
 268 window_equality(lua_State *L)
 269 {
 270   struct win *w1 = check_window(L, 1), *w2 = check_window(L, 2);
 271   lua_pushboolean(L, (w1 == w2 || (w1 && w2 && w1->w_number == w2->w_number)));
 272   return 1;
 273 }
 274
 275 static const luaL_reg window_metamethods[] = {
 276   {"__tostring", window_tostring},
 277   {"__eq", window_equality},
 278   {0, 0}
 279 };
 280
 281 static const struct Xet_reg window_setters[] = {
 282   {"title", 0, 0, window_change_title/*absolute setter*/},
 283   {0, 0}
 284 };
 285
 286 static const struct Xet_reg window_getters[] = {
 287   {"title", get_string, offsetof(struct win, w_title) + 8},
 288   {"number", get_int, offsetof(struct win, w_number)},
 289   {"dir", get_string, offsetof(struct win, w_dir)},
 290   {"tty", get_string, offsetof(struct win, w_tty)},
 291   {"pid", get_int, offsetof(struct win, w_pid)},
 292   {"group", get_window, offsetof(struct win, w_group)},
 293   {"bell", get_int, offsetof(struct win, w_bell)},
 294   {0, 0}
 295 };
 296
 297
 298 /** }}} */
 299
 300 /** AclUser {{{ */
 301
 302 PUSH_TYPE(user, struct acluser)
 303
 304 CHECK_TYPE(user, struct acluser)
 305
 306 static int
 307 get_user(lua_State *L, void *v)
 308 {
 309   push_user(L, (struct acluser **)v);
 310   return 1;
 311 }
 312
 313 static const luaL_reg user_methods[] = {
 314   {0, 0}
 315 };
 316
 317 static int
 318 user_tostring(lua_State *L)
 319 {
 320   char str[128];
 321   struct acluser *u = check_user(L, 1);
 322   snprintf(str, sizeof(str), "{user '%s'}", u->u_name);
 323   lua_pushstring(L, str);
 324   return 1;
 325 }
 326
 327 static const luaL_reg user_metamethods[] = {
 328   {"__tostring", user_tostring},
 329   {0, 0}
 330 };
 331
 332 static const struct Xet_reg user_setters[] = {
 333   {0, 0}
 334 };
 335
 336 static const struct Xet_reg user_getters[] = {
 337   {"name", get_string, offsetof(struct acluser, u_name)},
 338   {"password", get_string, offsetof(struct acluser, u_password)},
 339   {0, 0}
 340 };
 341
 342 /** }}} */
 343
 344 /** Canvas {{{ */
 345
 346 PUSH_TYPE(canvas, struct canvas)
 347
 348 CHECK_TYPE(canvas, struct canvas)
 349
 350 static int
 351 get_canvas(lua_State *L, void *v)
 352 {
 353   push_canvas(L, (struct canvas **)v);
 354   return 1;
 355 }
 356
 357 static int
 358 canvas_select(lua_State *L)
 359 {
 360   struct canvas *c = check_canvas(L, 1);
 361   if (!display || D_forecv == c)
 362     return 0;
 363   SetCanvasWindow(c, Layer2Window(c->c_layer));
 364   D_forecv = c;
 365
 366   /* XXX: the following all is duplicated from process.c:DoAction.
 367    * Should these be in some better place?
 368    */
 369   ResizeCanvas(&D_canvas);
 370   RecreateCanvasChain();
 371   RethinkDisplayViewports();
 372   ResizeLayersToCanvases();     /* redisplays */
 373   fore = D_fore = Layer2Window(D_forecv->c_layer);
 374   flayer = D_forecv->c_layer;
 375 #ifdef RXVT_OSC
 376   if (D_xtermosc[2] || D_xtermosc[3])
 377     {
 378       Activate(-1);
 379       break;
 380     }
 381 #endif
 382   RefreshHStatus();
 383 #ifdef RXVT_OSC
 384   RefreshXtermOSC();
 385 #endif
 386   flayer = D_forecv->c_layer;
 387   CV_CALL(D_forecv, LayRestore();LaySetCursor());
 388   WindowChanged(0, 'F');
 389   return 1;
 390 }
 391
 392 static const luaL_reg canvas_methods[] = {
 393   {"select", canvas_select},
 394   {0, 0}
 395 };
 396
 397 static const luaL_reg canvas_metamethods[] = {
 398   {0, 0}
 399 };
 400
 401 static const struct Xet_reg canvas_setters[] = {
 402   {0, 0}
 403 };
 404
 405 static int
 406 canvas_get_window(lua_State *L)
 407 {
 408   struct canvas *c = check_canvas(L, 1);
 409   struct win *win = Layer2Window(c->c_layer);
 410   if (win)
 411     push_window(L, &win);
 412   else
 413     lua_pushnil(L);
 414   return 1;
 415 }
 416
 417 static const struct Xet_reg canvas_getters[] = {
 418   {"next", get_canvas, offsetof(struct canvas, c_next)},
 419   {"xoff", get_int, offsetof(struct canvas, c_xoff)},
 420   {"yoff", get_int, offsetof(struct canvas, c_yoff)},
 421   {"xs", get_int, offsetof(struct canvas, c_xs)},
 422   {"ys", get_int, offsetof(struct canvas, c_ys)},
 423   {"xe", get_int, offsetof(struct canvas, c_xe)},
 424   {"ye", get_int, offsetof(struct canvas, c_ye)},
 425   {"window", 0, 0, canvas_get_window},
 426   {0, 0}
 427 };
 428
 429 /** }}} */
 430
 431 /** Layout {{{ */
 432
 433 PUSH_TYPE(layout, struct layout)
 434 CHECK_TYPE(layout, struct layout)
 435
 436 static const struct Xet_reg layout_getters[] = {
 437       {0,0}
 438 };
 439
 440 static int
 441 get_layout(lua_State *L, void *v)
 442 {
 443   push_layout(L, (struct layout **)v);
 444   return 1;
 445 }
 446
 447 /** }}} */
 448
 449 /** Display {{{ */
 450
 451 PUSH_TYPE(display, struct display)
 452
 453 CHECK_TYPE(display, struct display)
 454
 455 static int
 456 display_get_canvases(lua_State *L)
 457 {
 458   struct display *d;
 459   struct canvas *iter;
 460   int count;
 461
 462   d = check_display(L, 1);
 463   lua_newtable(L);
 464   for (iter = d->d_cvlist, count = 0; iter; iter = iter->c_next, count++) {
 465     lua_pushinteger(L, count);
 466     push_canvas(L, &iter);
 467     lua_settable(L, -3);
 468   }
 469
 470   return 1;
 471 }
 472
 473 static const luaL_reg display_methods[] = {
 474   {"get_canvases", display_get_canvases},
 475   {0, 0}
 476 };
 477
 478 static int
 479 display_tostring(lua_State *L)
 480 {
 481   char str[128];
 482   struct display *d = check_display(L, 1);
 483   snprintf(str, sizeof(str), "{display: tty = '%s', term = '%s'}", d->d_usertty, d->d_termname);
 484   lua_pushstring(L, str);
 485   return 1;
 486 }
 487
 488 static const luaL_reg display_metamethods[] = {
 489   {"__tostring", display_tostring},
 490   {0, 0}
 491 };
 492
 493 static const struct Xet_reg display_setters[] = {
 494   {0, 0}
 495 };
 496
 497 static const struct Xet_reg display_getters[] = {
 498   {"tty", get_string, offsetof(struct display, d_usertty)},
 499   {"term", get_string, offsetof(struct display, d_termname)},
 500   {"fore", get_window, offsetof(struct display, d_fore)},
 501   {"other", get_window, offsetof(struct display, d_other)},
 502   {"width", get_int, offsetof(struct display, d_width)},
 503   {"height", get_int, offsetof(struct display, d_height)},
 504   {"user", get_user, offsetof(struct display, d_user)},
 505   {"layout", get_layout, offsetof(struct display, d_layout)},
 506   {0, 0}
 507 };
 508
 509 /** }}} */
 510
 511 /** Screen {{{ */
 512
 513 static int
 514 screen_get_windows(lua_State *L)
 515 {
 516   struct win *iter;
 517   int count;
 518
 519   lua_newtable(L);
 520   for (iter = windows, count = 0; iter; iter = iter->w_next, count++) {
 521     lua_pushinteger(L, iter->w_number);
 522     push_window(L, &iter);
 523     lua_settable(L, -3);
 524   }
 525
 526   return 1;
 527 }
 528
 529 static int
 530 screen_get_displays(lua_State *L)
 531 {
 532   struct display *iter;
 533   int count;
 534
 535   lua_newtable(L);
 536   for (iter = displays, count = 0; iter; iter = iter->d_next, count++) {
 537     lua_pushinteger(L, count);
 538     push_display(L, &iter);
 539     lua_settable(L, -3);
 540   }
 541
 542   return 1;
 543 }
 544
 545 static int
 546 screen_get_display(lua_State *L)
 547 {
 548   push_display(L, &display);
 549   return 1;
 550 }
 551
 552 static int
 553 screen_exec_command(lua_State *L)
 554 {
 555   const char *command;
 556   unsigned int len;
 557
 558   command = luaL_checklstring(L, 1, &len);
 559   if (command)
 560     RcLine(command, len);
 561
 562   return 0;
 563 }
 564
 565 static int
 566 screen_append_msg(lua_State *L)
 567 {
 568   const char *msg, *color;
 569   int len;
 570   msg = luaL_checklstring(L, 1, &len);
 571   if (lua_isnil(L, 2))
 572     color = NULL;
 573   else
 574     color = luaL_checklstring(L, 2, &len);
 575   AppendWinMsgRend(msg, color);
 576   return 0;
 577 }
 578
 579 static const luaL_reg screen_methods[] = {
 580   {"windows", screen_get_windows},
 581   {"displays", screen_get_displays},
 582   {"display", screen_get_display},
 583   {"command", screen_exec_command},
 584   {"append_msg", screen_append_msg},
 585   {0, 0}
 586 };
 587
 588 static const luaL_reg screen_metamethods[] = {
 589   {0, 0}
 590 };
 591
 592 static const struct Xet_reg screen_setters[] = {
 593   {0, 0}
 594 };
 595
 596 static const struct Xet_reg screen_getters[] = {
 597   {0, 0}
 598 };
 599
 600 /** }}} */
 601
 602 /** Public functions {{{ */
 603 static lua_State *L;
 604 int LuaInit(void)
 605 {
 606   L = luaL_newstate();
 607
 608   luaL_openlibs(L);
 609
 610 #define REGISTER(X) struct_register(L, #X , X ## _methods, X##_metamethods, X##_setters, X##_getters)
 611
 612   REGISTER(screen);
 613   REGISTER(window);
 614   REGISTER(display);
 615   REGISTER(user);
 616   REGISTER(canvas);
 617
 618   return 0;
 619 }
 620
 621 struct fn_def
 622 {
 623   void (*push_fn)(lua_State *, void*);
 624   void *value;
 625 };
 626
 627 static int
 628 LuaCallProcess(const char *name, struct fn_def defs[])
 629 {
 630   int argc = 0;
 631
 632   lua_settop(L, 0);
 633   lua_getfield(L, LUA_GLOBALSINDEX, name);
 634   if (lua_isnil(L, -1))
 635     return 0;
 636   for (argc = 0; defs[argc].push_fn; argc++)
 637     defs[argc].push_fn(L, defs[argc].value);
 638   if (lua_pcall(L, argc, 0, 0) == LUA_ERRRUN && lua_isstring(L, -1))
 639     {
 640       struct display *d = display;
 641       unsigned int len;
 642       char *message = luaL_checklstring(L, -1, &len);
 643       LMsg(1, "%s", message ? message : "Unknown error");
 644       lua_pop(L, 1);
 645       display = d;
 646       return 0;
 647     }
 648   return 1;
 649 }
 650
 651 int LuaForeWindowChanged(void)
 652 {
 653   if (!L)
 654     return 0;
 655   lua_getfield(L, LUA_GLOBALSINDEX, "fore_changed");
 656   if (lua_isnil(L, -1))
 657     return 0;
 658   push_display(L, &display);
 659   push_window(L, display ? &D_fore : &fore);
 660   if (lua_pcall(L, 2, 0, 0) == LUA_ERRRUN)
 661     {
 662       if(lua_isstring(L, -1))
 663         {
 664           unsigned int len;
 665           char *message = luaL_checklstring(L, -1, &len);
 666           LMsg(1, "%s", message ? message : "Unknown error");
 667           lua_pop(L, 1);
 668         }
 669     }
 670   return 0;
 671 }
 672
 673 int LuaSource(const char *file, int async)
 674 {
 675   if (!L)
 676     return 0;
 677   struct stat st;
 678   if (stat(file, &st) == -1)
 679     Msg(errno, "Error loading lua script file '%s'", file);
 680   else
 681     {
 682       int len = strlen(file);
 683       if (len < 4 || strncmp(file + len - 4, ".lua", 4) != 0)
 684         return 0;
 685       luaL_dofile(L, file);
 686       return 1;
 687     }
 688   return 0;
 689 }
 690
 691 int LuaFinit(void)
 692 {
 693   if (!L)
 694     return 0;
 695   lua_close(L);
 696   L = (lua_State*)0;
 697   return 0;
 698 }
 699
 700 int LuaCall(char **argv)
 701 {
 702   int argc;
 703   if (!L)
 704     return 0;
 705
 706   lua_getfield(L, LUA_GLOBALSINDEX, *argv);
 707   for (argc = 0, argv++; *argv; argv++, argc++)
 708     {
 709       lua_pushstring(L, *argv);
 710     }
 711   if (lua_pcall(L, argc, 0, 0) == LUA_ERRRUN)
 712     {
 713       if(lua_isstring(L, -1))
 714         {
 715           unsigned int len;
 716           char *message = luaL_checklstring(L, -1, &len);
 717           LMsg(1, "%s", message ? message : "Unknown error");
 718           lua_pop(L, 1);
 719           return 0;
 720         }
 721     }
 722   return 1;
 723 }
 724
 725 int
 726 LuaProcessCaption(const char *caption, struct win *win, int len)
 727 {
 728   if (!L)
 729     return 0;
 730   struct fn_def params[] = {
 731     {lua_pushstring, caption},
 732     {push_window, &win},
 733     {lua_pushinteger, len},
 734     {NULL, NULL}
 735   };
 736   return LuaCallProcess("process_caption", params);
 737 }
 738
 739 static void
 740 push_stringarray(lua_State *L, void *data)
 741 {
 742   char **args = (char **)data;
 743   int i;
 744   lua_newtable(L);
 745   for (i = 1; args && *args; i++) {
 746     lua_pushinteger(L, i);
 747     lua_pushstring(L, *args++);
 748     lua_settable(L, -3);
 749   }
 750 }
 751
 752 int
 753 LuaCommandExecuted(const char *command, const char **args, int argc)
 754 {
 755   if (!L)
 756     return 0;
 757   struct fn_def params[] = {
 758       {lua_pushstring, command},
 759       {push_stringarray, args},
 760       {NULL, NULL}
 761   };
 762   return LuaCallProcess("command_executed", params);
 763 }
 764
 765 /** }}} */
 766
 767 struct ScriptFuncs LuaFuncs =
 768 {
 769   LuaInit,
 770   LuaFinit,
 771   LuaForeWindowChanged,
 772   LuaSource,
 773   LuaProcessCaption,
 774   LuaCommandExecuted
 775 };
 776
 777 struct binding lua_binding =
 778 {
 779     "lua", /*name*/
 780     0,     /*inited*/
 781     0,     /*registered*/
 782     LuaInit,
 783     LuaFinit,
 784     LuaSource,
 785     0,     /*b_next*/
 786     &LuaFuncs
 787 };
 788