1 /* Lua scripting support
3 * Copyright (c) 2008 Sadrul Habib Chowdhury (sadrul@users.sf.net)
5 * Sadrul Habib Chowdhury (sadrul@users.sf.net)
6 * Rui Guo (firemeteor.guo@gmail.com)
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)
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.
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
23 ****************************************************************
25 #include <sys/types.h>
42 static int StackDump(lua_State
*L
, const char *message
)
44 FILE *f
= fopen("/tmp/debug/stack", "ab");
45 int i
= lua_gettop(L
);
47 fprintf(f
, "%s", message
);
50 int t
= lua_type(L
, i
);
54 fprintf(f
, "String: %s\n", lua_tostring(L
, i
));
58 fprintf(f
, "Boolean: %s\n", lua_toboolean(L
, i
) ? "true" : "false");
62 fprintf(f
, "Number: %g\n", lua_tonumber(L
, i
));
66 fprintf(f
, "Type: %s\n", lua_typename(L
, t
));
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
);
82 static int LuaDispatch(void *handler
, const char *params
, va_list va
);
83 static int LuaRegEvent(lua_State
*L
);
84 static void LuaShowErr(lua_State
*L
);
85 struct binding lua_binding
;
89 LUA_HANDLER_TYPE_N
= 1,
103 typedef struct lua_handler
*lua_handler
;
104 void LuaPushHandler(lua_State
*L
, lua_handler lh
);
105 void LuaHUnRef(lua_State
*L
, int key
);
106 lua_handler
LuaCheckHandler(lua_State
*L
, int idx
, int ref
);
109 LuaAllocHandler(const char *name
, int ref
)
111 struct lua_handler
*lh
;
112 lh
= (struct lua_handler
*) malloc(sizeof(struct lua_handler
));
118 lh
->type
= LUA_HANDLER_TYPE_N
;
119 lh
->u
.name
= SaveStr(name
);
123 lh
->type
= LUA_HANDLER_TYPE_F
;
124 lh
->u
.reference
= ref
;
131 LuaFreeHandler(lua_State
*L
, struct lua_handler
**lh
)
133 if ((*lh
)->type
== LUA_HANDLER_TYPE_N
)
137 LuaHUnRef(L
, (*lh
)->u
.reference
);
138 (*lh
)->u
.reference
= 0;
144 #define CHECK_TYPE(name, type) \
146 check_##name(lua_State *L, int index) \
149 luaL_checktype(L, index, LUA_TUSERDATA); \
150 var = (type **) luaL_checkudata(L, index, #name); \
152 luaL_typerror(L, index, #name); \
156 #define PUSH_TYPE(name, type) \
158 push_##name(lua_State *L, type **t) \
165 r = (type **)lua_newuserdata(L, sizeof(type *)); \
167 luaL_getmetatable(L, #name); \
168 lua_setmetatable(L,-2); \
172 /* Much of the following template comes from:
173 * http://lua-users.org/wiki/BindingWithMembersAndMethods
176 static int get_int (lua_State
*L
, void *v
)
178 lua_pushinteger (L
, *(int*)v
);
182 static int set_int (lua_State
*L
, void *v
)
184 *(int*)v
= luaL_checkint(L
, 3);
188 static int get_number (lua_State
*L
, void *v
)
190 lua_pushnumber(L
, *(lua_Number
*)v
);
194 static int set_number (lua_State
*L
, void *v
)
196 *(lua_Number
*)v
= luaL_checknumber(L
, 3);
200 static int get_string (lua_State
*L
, void *v
)
202 lua_pushstring(L
, (char*)v
);
206 static int set_string (lua_State
*L
, void *v
)
208 *(const char**)v
= luaL_checkstring(L
, 3);
212 typedef int (*Xet_func
) (lua_State
*L
, void *v
);
214 /* member info for get and set handlers */
217 const char *name
; /* member name */
218 Xet_func func
; /* get or set function for type of member */
219 size_t offset
; /* offset of member within the struct */
220 int (*absolute
)(lua_State
*);
223 static void Xet_add (lua_State
*L
, const struct Xet_reg
*l
)
229 lua_pushstring(L
, l
->name
);
230 lua_pushlightuserdata(L
, (void*)l
);
235 static int Xet_call (lua_State
*L
)
237 /* for get: stack has userdata, index, lightuserdata */
238 /* for set: stack has userdata, index, value, lightuserdata */
239 const struct Xet_reg
*m
= (const struct Xet_reg
*)lua_touserdata(L
, -1); /* member info */
240 lua_pop(L
, 1); /* drop lightuserdata */
241 luaL_checktype(L
, 1, LUA_TUSERDATA
);
243 return m
->absolute(L
);
244 return m
->func(L
, *(char**)lua_touserdata(L
, 1) + m
->offset
);
247 static int index_handler (lua_State
*L
)
249 /* stack has userdata, index */
250 lua_pushvalue(L
, 2); /* dup index */
251 lua_rawget(L
, lua_upvalueindex(1)); /* lookup member by name */
252 if (!lua_islightuserdata(L
, -1))
254 lua_pop(L
, 1); /* drop value */
255 lua_pushvalue(L
, 2); /* dup index */
256 lua_gettable(L
, lua_upvalueindex(2)); /* else try methods */
257 if (lua_isnil(L
, -1)) /* invalid member */
258 luaL_error(L
, "cannot get member '%s'", lua_tostring(L
, 2));
261 return Xet_call(L
); /* call get function */
264 static int newindex_handler (lua_State
*L
)
266 /* stack has userdata, index, value */
267 lua_pushvalue(L
, 2); /* dup index */
268 lua_rawget(L
, lua_upvalueindex(1)); /* lookup member by name */
269 if (!lua_islightuserdata(L
, -1)) /* invalid member */
270 luaL_error(L
, "cannot set member '%s'", lua_tostring(L
, 2));
271 return Xet_call(L
); /* call set function */
275 struct_register(lua_State
*L
, const char *name
, const luaL_reg fn_methods
[], const luaL_reg meta_methods
[],
276 const struct Xet_reg setters
[], const struct Xet_reg getters
[])
278 int metatable
, methods
;
280 /* create methods table & add it to the table of globals */
281 luaL_register(L
, name
, fn_methods
);
282 methods
= lua_gettop(L
);
284 /* create metatable & add it to the registry */
285 luaL_newmetatable(L
, name
);
286 luaL_register(L
, 0, meta_methods
); /* fill metatable */
288 /* To identify the type of object */
289 lua_pushstring(L
, "_objname");
290 lua_pushstring(L
, name
);
293 metatable
= lua_gettop(L
);
295 lua_pushliteral(L
, "__metatable");
296 lua_pushvalue(L
, methods
); /* dup methods table*/
297 lua_rawset(L
, metatable
); /* hide metatable:
298 metatable.__metatable = methods */
300 lua_pushliteral(L
, "__index");
301 lua_pushvalue(L
, metatable
); /* upvalue index 1 */
302 Xet_add(L
, getters
); /* fill metatable with getters */
303 lua_pushvalue(L
, methods
); /* upvalue index 2 */
304 lua_pushcclosure(L
, index_handler
, 2);
305 lua_rawset(L
, metatable
); /* metatable.__index = index_handler */
307 lua_pushliteral(L
, "__newindex");
308 lua_newtable(L
); /* table for members you can set */
309 Xet_add(L
, setters
); /* fill with setters */
310 lua_pushcclosure(L
, newindex_handler
, 1);
311 lua_rawset(L
, metatable
); /* metatable.__newindex = newindex_handler */
313 /* FIXME: Why do we leave an element on the stack? */
314 lua_pop(L
, 1); /* drop metatable */
315 return 1; /* return methods on the stack */
321 PUSH_TYPE(callback
, struct listener
)
324 internal_unhook(lua_State
*L
, int warn
)
326 /*Emulate check_callback() */
327 struct listener
**ppl
;
328 luaL_checktype(L
, 1, LUA_TUSERDATA
);
329 ppl
= (struct listener
**) luaL_checkudata(L
, 1, "callback");
332 luaL_typerror(L
, 1, "callback");
338 lua_pushboolean(L
, 0);
339 lua_pushstring(L
, "Callback already unhooked.");
345 LuaFreeHandler(L
, (lua_handler
*)&(*ppl
)->handler
);
346 unregister_listener(*ppl
);
349 lua_pushboolean(L
, 1);
354 callback_unhook(lua_State
*L
)
356 return internal_unhook(L
, 1);
359 static const luaL_reg callback_methods
[] = {
360 {"unhook", callback_unhook
},
365 callback_collect(lua_State
*L
)
367 return internal_unhook(L
, 0);
370 static const luaL_reg callback_metamethods
[] = {
371 {"__gc", callback_collect
},
375 static const struct Xet_reg callback_setters
[] = {
379 static const struct Xet_reg callback_getters
[] = {
388 PUSH_TYPE(window
, struct win
)
390 CHECK_TYPE(window
, struct win
)
392 static int get_window(lua_State
*L
, void *v
)
394 push_window(L
, (struct win
**)v
);
399 window_change_title(lua_State
*L
)
401 struct win
*w
= check_window(L
, 1);
403 const char *title
= luaL_checklstring(L
, 3, &len
);
404 ChangeAKA(w
, (char *)title
, len
);
409 window_change_number(lua_State
*L
)
411 struct win
*w
= check_window(L
, 1);
412 int newnum
= luaL_checkint(L
, 3);
413 ChangeWinNum(w
->w_number
, newnum
);
418 window_get_monitor_status(lua_State
*L
)
420 struct win
*w
= check_window(L
, 1);
421 int activity
= luaL_checkint(L
, 2);
424 lua_pushinteger(L
, w
->w_monitor
!= MON_OFF
);
427 lua_pushinteger(L
, w
->w_silence
== SILENCE_ON
? w
->w_silencewait
: 0);
433 window_stuff(lua_State
*L
)
436 struct layer
*oldflayer
= flayer
;
437 struct win
*w
= check_window(L
, 1);
438 const char *str
= luaL_checklstring(L
, 2, &len
);
440 flayer
= &w
->w_layer
;
442 LayProcess((char **)&str
, (int *) &len
);
447 static const luaL_reg window_methods
[] = {
448 {"get_monitor_status", window_get_monitor_status
},
449 {"stuff", window_stuff
},
450 {"hook", LuaRegEvent
},
455 window_tostring(lua_State
*L
)
458 struct win
*w
= check_window(L
, 1);
459 snprintf(str
, sizeof(str
), "{window #%d: '%s'}", w
->w_number
, w
->w_title
);
460 lua_pushstring(L
, str
);
465 window_equality(lua_State
*L
)
467 struct win
*w1
= check_window(L
, 1), *w2
= check_window(L
, 2);
468 lua_pushboolean(L
, (w1
== w2
|| (w1
&& w2
&& w1
->w_number
== w2
->w_number
)));
472 static const luaL_reg window_metamethods
[] = {
473 {"__tostring", window_tostring
},
474 {"__eq", window_equality
},
478 static const struct Xet_reg window_setters
[] = {
479 {"title", 0, 0, window_change_title
/*absolute setter*/},
480 {"number", 0, 0, window_change_number
/*absolute setter*/},
484 static const struct Xet_reg window_getters
[] = {
485 {"title", get_string
, offsetof(struct win
, w_title
) + 8},
486 {"number", get_int
, offsetof(struct win
, w_number
)},
487 {"dir", get_string
, offsetof(struct win
, w_dir
)},
488 {"tty", get_string
, offsetof(struct win
, w_tty
)},
489 {"pid", get_int
, offsetof(struct win
, w_pid
)},
490 {"group", get_window
, offsetof(struct win
, w_group
)},
491 {"bell", get_int
, offsetof(struct win
, w_bell
)},
500 PUSH_TYPE(user
, struct acluser
)
502 CHECK_TYPE(user
, struct acluser
)
505 get_user(lua_State
*L
, void *v
)
507 push_user(L
, (struct acluser
**)v
);
511 static const luaL_reg user_methods
[] = {
516 user_tostring(lua_State
*L
)
519 struct acluser
*u
= check_user(L
, 1);
520 snprintf(str
, sizeof(str
), "{user '%s'}", u
->u_name
);
521 lua_pushstring(L
, str
);
525 static const luaL_reg user_metamethods
[] = {
526 {"__tostring", user_tostring
},
530 static const struct Xet_reg user_setters
[] = {
534 static const struct Xet_reg user_getters
[] = {
535 {"name", get_string
, offsetof(struct acluser
, u_name
)},
536 {"password", get_string
, offsetof(struct acluser
, u_password
)},
544 PUSH_TYPE(canvas
, struct canvas
)
546 CHECK_TYPE(canvas
, struct canvas
)
549 get_canvas(lua_State
*L
, void *v
)
551 push_canvas(L
, (struct canvas
**)v
);
556 canvas_select(lua_State
*L
)
558 struct canvas
*c
= check_canvas(L
, 1);
559 if (!display
|| D_forecv
== c
)
561 /* FIXME: why do we need this? */
562 SetCanvasWindow(c
, Layer2Window(c
->c_layer
));
568 static const luaL_reg canvas_methods
[] = {
569 {"select", canvas_select
},
573 static const luaL_reg canvas_metamethods
[] = {
577 static const struct Xet_reg canvas_setters
[] = {
582 canvas_get_window(lua_State
*L
)
584 struct canvas
*c
= check_canvas(L
, 1);
585 struct win
*win
= Layer2Window(c
->c_layer
);
587 push_window(L
, &win
);
593 static const struct Xet_reg canvas_getters
[] = {
594 {"next", get_canvas
, offsetof(struct canvas
, c_next
)},
595 {"xoff", get_int
, offsetof(struct canvas
, c_xoff
)},
596 {"yoff", get_int
, offsetof(struct canvas
, c_yoff
)},
597 {"xs", get_int
, offsetof(struct canvas
, c_xs
)},
598 {"ys", get_int
, offsetof(struct canvas
, c_ys
)},
599 {"xe", get_int
, offsetof(struct canvas
, c_xe
)},
600 {"ye", get_int
, offsetof(struct canvas
, c_ye
)},
601 {"window", 0, 0, canvas_get_window
},
609 PUSH_TYPE(layout
, struct layout
)
610 CHECK_TYPE(layout
, struct layout
)
612 static const struct Xet_reg layout_getters
[] = {
617 get_layout(lua_State
*L
, void *v
)
619 push_layout(L
, (struct layout
**)v
);
627 PUSH_TYPE(display
, struct display
)
629 CHECK_TYPE(display
, struct display
)
632 display_get_canvases(lua_State
*L
)
638 d
= check_display(L
, 1);
640 for (iter
= d
->d_cvlist
, count
= 0; iter
; iter
= iter
->c_next
, count
++) {
641 lua_pushinteger(L
, count
);
642 push_canvas(L
, &iter
);
649 static const luaL_reg display_methods
[] = {
650 {"get_canvases", display_get_canvases
},
655 display_tostring(lua_State
*L
)
658 struct display
*d
= check_display(L
, 1);
659 snprintf(str
, sizeof(str
), "{display: tty = '%s', term = '%s'}", d
->d_usertty
, d
->d_termname
);
660 lua_pushstring(L
, str
);
664 static const luaL_reg display_metamethods
[] = {
665 {"__tostring", display_tostring
},
669 static const struct Xet_reg display_setters
[] = {
673 static const struct Xet_reg display_getters
[] = {
674 {"tty", get_string
, offsetof(struct display
, d_usertty
)},
675 {"term", get_string
, offsetof(struct display
, d_termname
)},
676 {"fore", get_window
, offsetof(struct display
, d_fore
)},
677 {"other", get_window
, offsetof(struct display
, d_other
)},
678 {"width", get_int
, offsetof(struct display
, d_width
)},
679 {"height", get_int
, offsetof(struct display
, d_height
)},
680 {"user", get_user
, offsetof(struct display
, d_user
)},
681 {"layout", get_layout
, offsetof(struct display
, d_layout
)},
690 screen_get_windows(lua_State
*L
)
696 for (iter
= windows
, count
= 0; iter
; iter
= iter
->w_next
, count
++) {
697 lua_pushinteger(L
, iter
->w_number
);
698 push_window(L
, &iter
);
706 screen_get_displays(lua_State
*L
)
708 struct display
*iter
;
712 for (iter
= displays
, count
= 0; iter
; iter
= iter
->d_next
, count
++) {
713 lua_pushinteger(L
, count
);
714 push_display(L
, &iter
);
722 screen_get_display(lua_State
*L
)
724 push_display(L
, &display
);
729 screen_exec_command(lua_State
*L
)
734 command
= luaL_checklstring(L
, 1, &len
);
736 RcLine((char *)command
, len
);
742 screen_append_msg(lua_State
*L
)
744 const char *msg
, *color
;
746 msg
= luaL_checklstring(L
, 1, &len
);
750 color
= luaL_checklstring(L
, 2, &len
);
751 AppendWinMsgRend(msg
, color
);
762 script_input_fn(char *buf
, int len
, char *priv
)
764 struct sinput_data
*sidata
= (struct sinput_data
*)priv
;
765 lua_handler lh
= sidata
->lh
;
766 lua_State
*L
= sidata
->L
;
768 LuaPushHandler(L
, lh
);
769 lua_pushstring(L
, buf
);
770 if (lua_pcall(L
, 1, 0, 0) == LUA_ERRRUN
)
772 if(lua_isstring(L
, -1))
778 LuaFreeHandler(L
, &lh
);
782 screen_input(lua_State
*L
)
786 const char * prompt
= NULL
, *prefill
= NULL
;
788 struct sinput_data
*sidata
;
790 prompt
= luaL_checkstring(L
, 1);
791 lh
= LuaCheckHandler(L
, 2, 1);
793 luaL_error(L
, "Out of Memory");
795 if (lua_gettop(L
) >= 3)
796 prefill
= luaL_checkstring(L
, 3);
799 sidata
= (struct sinput_data
*)malloc(sizeof(struct sinput_data
));
803 luaL_error(L
, "Out of Memory");
808 Input((char *)prompt
, 100, INP_COOKED
, script_input_fn
, (char *)sidata
, 0);
812 for (; *prefill
; prefill
++)
814 if ((*(unsigned char *)prefill
& 0x7f) < 0x20 || *prefill
== 0x7f)
816 ss
= (char *)prefill
;
823 static const luaL_reg screen_methods
[] = {
824 {"windows", screen_get_windows
},
825 {"displays", screen_get_displays
},
826 {"display", screen_get_display
},
827 {"command", screen_exec_command
},
828 {"append_msg", screen_append_msg
},
829 {"hook", LuaRegEvent
},
830 {"input", screen_input
},
834 static const luaL_reg screen_metamethods
[] = {
838 static const struct Xet_reg screen_setters
[] = {
842 static const struct Xet_reg screen_getters
[] = {
848 /** Public functions {{{ */
850 /* FIXME: This code only tracks one unhook ticket for a lua func.
851 * So it does not work if one func is registered more than one times. */
853 prepare_weak_table(lua_State
*L
, const char *name
, const char *mode
)
855 luaL_getmetatable(L
, "screen");
857 lua_pushstring(L
, name
);
860 /* prepare a metatable to indicate weak table */
862 lua_pushstring(L
, "__mode");
863 lua_pushstring(L
, mode
);
865 /* Mark weak table */
866 lua_setmetatable(L
, -2);
878 #define REGISTER(X) struct_register(L, #X , X ## _methods, X##_metamethods, X##_setters, X##_getters)
887 /* To store handler funcs */
889 /*_two kinds of information are mantained:
892 * The 'func' part of the tables are weak. That means the registered funcs
893 * will be collected once the func is no longer available (e.g. overwritten
894 * by a new instance of the script)
896 * To make this process happens faster, GC is forced at the end of each
898 * TODO: What if some events are triggered within the sourcing
901 prepare_weak_table(L
, "_funcreg", "v");
903 /* funcunhook[func]->listener
904 * The listener is the unhook ticket of the hook. which should be collected
905 * once the func is collected. The gc metamethod will be triggered
907 prepare_weak_table(L
, "_funcunhook", "k");
912 /* An error message on top of the stack. */
914 LuaShowErr(lua_State
*L
)
916 struct display
*d
= display
;
918 const char *message
= luaL_checklstring(L
, -1, &len
);
919 LMsg(0, "%s", message
? message
: "Unknown error");
926 void (*push_fn
)(lua_State
*, void*);
931 LuaCallProcess(const char *name
, struct fn_def defs
[])
935 lua_getfield(L
, LUA_GLOBALSINDEX
, name
);
936 if (lua_isnil(L
, -1))
941 for (argc
= 0; defs
[argc
].push_fn
; argc
++)
942 defs
[argc
].push_fn(L
, defs
[argc
].value
);
943 if (lua_pcall(L
, argc
, 0, 0) == LUA_ERRRUN
&& lua_isstring(L
, -1))
951 /* FIXME: Think about this: will it affect the registered handlers?*/
952 int LuaSource(const char *file
, int async
)
957 if (stat(file
, &st
) == -1)
958 Msg(errno
, "Error loading lua script file '%s'", file
);
961 int len
= strlen(file
);
962 if (len
< 4 || strncmp(file
+ len
- 4, ".lua", 4) != 0)
964 if (luaL_dofile(L
, file
) && lua_isstring(L
, -1))
971 /* It seems that I need two GC passes to really collect the unhook
972 * ticket, after changing the reference to ticket in the
973 * 'funcunhook' table from weak to strong. This should not be
974 * harmful, but how can I make sure that two passes is enough?
977 * This seems reasonable, since the first pass will collect the func
978 * itself and make the ticket garbage, and the second pass will
979 * collect the ticket itself.
981 * TODO: check this out. maybe ask some lua gurus. */
982 lua_gc(L
, LUA_GCCOLLECT
, 0);
983 lua_gc(L
, LUA_GCCOLLECT
, 0);
1000 LuaProcessCaption(const char *caption
, struct win
*win
, int len
)
1004 struct fn_def params
[] = {
1005 {lua_pushstring
, caption
},
1006 {push_window
, &win
},
1007 {lua_pushinteger
, len
},
1010 return LuaCallProcess("process_caption", params
);
1014 push_stringarray(lua_State
*L
, char **args
)
1018 for (i
= 1; args
&& *args
; i
++) {
1019 lua_pushinteger(L
, i
);
1020 lua_pushstring(L
, *args
++);
1021 lua_settable(L
, -3);
1026 LuaPushParams(lua_State
*L
, const char *params
, va_list va
)
1034 lua_pushstring(L
, va_arg(va
, char *));
1037 push_stringarray(L
, va_arg(va
, char **));
1040 lua_pushinteger(L
, va_arg(va
, int));
1044 struct display
*d
= va_arg(va
, struct display
*);
1045 push_display(L
, &d
);
1050 struct win
*w
= va_arg(va
, struct win
*);
1061 int LuaCall(const char *func
, const char **argv
)
1067 StackDump(L
, "Before LuaCall\n");
1068 lua_getfield(L
, LUA_GLOBALSINDEX
, func
);
1069 if (lua_isnil(L
, -1))
1072 lua_pushstring(L
, "Could not find the script function\n");
1076 for (argc
= 0; *argv
; argv
++, argc
++)
1078 lua_pushstring(L
, *argv
);
1080 if (lua_pcall(L
, argc
, 0, 0) == LUA_ERRRUN
)
1082 if(lua_isstring(L
, -1))
1084 StackDump(L
, "After LuaCall\n");
1092 /*** Lua callback handler management {{{ */
1095 LuaPushHTable(lua_State
*L
, int screen
, const char * t
)
1097 lua_pushstring(L
, t
);
1098 lua_rawget(L
, screen
);
1099 /* FIXME: Do we need to balance the stack here? */
1100 if (lua_isnil(L
, -1))
1101 luaL_error(L
, "Fatal! Fail to get function registeration table!");
1102 return lua_gettop(L
);
1106 LuaPushHandler(lua_State
*L
, lua_handler lh
)
1109 if (lh
->type
== LUA_HANDLER_TYPE_F
)
1111 luaL_getmetatable(L
, "screen");
1112 funcreg
= LuaPushHTable(L
, lua_gettop(L
), "_funcreg");
1113 lua_rawgeti(L
, funcreg
, lh
->u
.reference
);
1119 lua_getfield(L
, LUA_GLOBALSINDEX
, lh
->u
.name
);
1124 LuaFuncKey(lua_State
*L
, int idx
, int ref
)
1126 int key
, funcreg
, sc
;
1127 luaL_getmetatable(L
, "screen");
1129 funcreg
= LuaPushHTable(L
, sc
, "_funcreg");
1131 lua_pushvalue(L
, idx
);
1132 key
= luaL_ref(L
, funcreg
);
1138 LuaHUnRef(lua_State
*L
, int key
)
1141 luaL_getmetatable(L
, "screen");
1143 funcreg
= LuaPushHTable(L
, sc
, "_funcreg");
1144 luaL_unref(L
, funcreg
, key
);
1148 LuaCheckHandler(lua_State
*L
, int idx
, int ref
)
1152 idx
= lua_gettop(L
) + 1 - idx
;
1154 if (lua_isstring(L
, idx
))
1156 const char * handler
;
1157 /* registered with func name.*/
1158 handler
= luaL_checkstring(L
, idx
);
1159 lua_getfield(L
, LUA_GLOBALSINDEX
, handler
);
1160 if (!lua_isfunction(L
, -1))
1161 luaL_error(L
, "The specified handler %s in param #%d is not a function", handler
, idx
);
1163 return LuaAllocHandler(handler
, 0);
1165 else if (!lua_isfunction(L
, idx
))
1166 luaL_error(L
, "Handler should be a function or the name of function");
1168 key
= LuaFuncKey(L
, idx
, ref
);
1169 return LuaAllocHandler(NULL
, key
);
1175 LuaDispatch(void *handler
, const char *params
, va_list va
)
1177 lua_handler lh
= (lua_handler
)handler
;
1180 StackDump(L
, "before dispatch");
1182 LuaPushHandler(L
, lh
);
1183 if (lua_isnil(L
, -1))
1188 argc
= LuaPushParams(L
, params
, va
);
1190 if (lua_pcall(L
, argc
, 1, 0) == LUA_ERRRUN
&& lua_isstring(L
, -1))
1192 StackDump(L
, "After LuaDispatch\n");
1196 retvalue
= lua_tonumber(L
, -1);
1201 /*FIXME: what if a func is registered twice or more? */
1203 LuaRegAutoUnHook(lua_State
*L
, lua_handler lh
, int ticket
)
1206 luaL_getmetatable(L
, "screen");
1208 funcunhook
= LuaPushHTable(L
, sc
, "_funcunhook");
1209 LuaPushHandler(L
, lh
);
1210 lua_pushvalue(L
, ticket
);
1211 lua_rawset(L
, funcunhook
);
1215 #define SEVNAME_MAX 30
1217 LuaRegEvent(lua_State
*L
)
1219 /* signature: hook(obj, event, handler, priv);
1220 * or: hook(event, handler, priv)
1221 * returns: A ticket for later unregister. */
1222 int idx
= 1, argc
= lua_gettop(L
);
1223 unsigned int priv
= 31; /* Default privilege */
1227 const char *objname
= "global";
1229 static char evbuf
[SEVNAME_MAX
];
1232 struct script_event
*sev
;
1234 StackDump(L
, "Before RegEvent\n");
1236 /* Identify the object, if specified */
1237 if (luaL_getmetafield(L
, 1, "_objname"))
1239 objname
= luaL_checkstring(L
, -1);
1241 if (!strcmp("screen", objname
))
1244 obj
= *(char **)lua_touserdata(L
, 1);
1248 event
= luaL_checkstring(L
, idx
++);
1249 snprintf(evbuf
, SEVNAME_MAX
, "%s_%s", objname
, event
);
1251 /* Check and get the handler */
1252 lh
= LuaCheckHandler(L
, idx
++, 1);
1254 luaL_error(L
, "Out of memory");
1256 StackDump(L
, "In RegEvent\n");
1259 priv
= luaL_checkinteger(L
, idx
);
1261 sev
= object_get_event(obj
, evbuf
);
1266 l
= (struct listener
*)malloc(sizeof(struct listener
));
1268 return luaL_error(L
, "Out of memory");
1270 l
->bd
= &lua_binding
;
1271 l
->handler
= (void *)lh
;
1272 register_listener(sev
, l
);
1273 /* Return the ticket for un-register */
1274 push_callback(L
, &l
);
1275 ticket
= lua_gettop(L
);
1277 LuaRegAutoUnHook(L
, lh
, ticket
);
1280 return luaL_error(L
, "Invalid event specified: %s for object %s", event
, objname
);
1282 StackDump(L
, "After RegEvent\n");
1288 struct ScriptFuncs LuaFuncs
=
1293 struct binding lua_binding
=