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 int LuaUnRegEvent(lua_State
*L
);
85 static void LuaShowErr(lua_State
*L
);
86 struct binding lua_binding
;
90 LUA_HANDLER_TYPE_N
= 1,
102 struct listener
*listener
;
105 typedef struct lua_handler
*lua_handler
;
106 void LuaPushHandler(lua_State
*L
, lua_handler lh
);
107 void LuaHRef(lua_State
*L
, int key
, int reg
);
108 lua_handler
LuaCheckHandler(lua_State
*L
, int idx
, int ref
);
111 LuaAllocHandler(const char *name
, int ref
)
113 struct lua_handler
*lh
;
114 lh
= (struct lua_handler
*) malloc(sizeof(struct lua_handler
));
120 lh
->type
= LUA_HANDLER_TYPE_N
;
125 lh
->type
= LUA_HANDLER_TYPE_F
;
126 lh
->u
.reference
= ref
;
133 LuaFreeHandler(lua_State
*L
, struct lua_handler
**lh
)
135 if ((*lh
)->type
== LUA_HANDLER_TYPE_N
)
139 LuaHRef(L
, (*lh
)->u
.reference
, 0);
140 (*lh
)->u
.reference
= 0;
146 #define CHECK_TYPE(name, type) \
148 check_##name(lua_State *L, int index) \
151 luaL_checktype(L, index, LUA_TUSERDATA); \
152 var = (type **) luaL_checkudata(L, index, #name); \
154 luaL_typerror(L, index, #name); \
158 #define PUSH_TYPE(name, type) \
160 push_##name(lua_State *L, type **t) \
167 r = (type **)lua_newuserdata(L, sizeof(type *)); \
169 luaL_getmetatable(L, #name); \
170 lua_setmetatable(L,-2); \
174 /* Much of the following template comes from:
175 * http://lua-users.org/wiki/BindingWithMembersAndMethods
178 static int get_int (lua_State
*L
, void *v
)
180 lua_pushinteger (L
, *(int*)v
);
184 static int set_int (lua_State
*L
, void *v
)
186 *(int*)v
= luaL_checkint(L
, 3);
190 static int get_number (lua_State
*L
, void *v
)
192 lua_pushnumber(L
, *(lua_Number
*)v
);
196 static int set_number (lua_State
*L
, void *v
)
198 *(lua_Number
*)v
= luaL_checknumber(L
, 3);
202 static int get_string (lua_State
*L
, void *v
)
204 lua_pushstring(L
, (char*)v
);
208 static int set_string (lua_State
*L
, void *v
)
210 *(const char**)v
= luaL_checkstring(L
, 3);
214 typedef int (*Xet_func
) (lua_State
*L
, void *v
);
216 /* member info for get and set handlers */
219 const char *name
; /* member name */
220 Xet_func func
; /* get or set function for type of member */
221 size_t offset
; /* offset of member within the struct */
222 int (*absolute
)(lua_State
*);
225 static void Xet_add (lua_State
*L
, const struct Xet_reg
*l
)
231 lua_pushstring(L
, l
->name
);
232 lua_pushlightuserdata(L
, (void*)l
);
237 static int Xet_call (lua_State
*L
)
239 /* for get: stack has userdata, index, lightuserdata */
240 /* for set: stack has userdata, index, value, lightuserdata */
241 const struct Xet_reg
*m
= (const struct Xet_reg
*)lua_touserdata(L
, -1); /* member info */
242 lua_pop(L
, 1); /* drop lightuserdata */
243 luaL_checktype(L
, 1, LUA_TUSERDATA
);
245 return m
->absolute(L
);
246 return m
->func(L
, *(char**)lua_touserdata(L
, 1) + m
->offset
);
249 static int index_handler (lua_State
*L
)
251 /* stack has userdata, index */
252 lua_pushvalue(L
, 2); /* dup index */
253 lua_rawget(L
, lua_upvalueindex(1)); /* lookup member by name */
254 if (!lua_islightuserdata(L
, -1))
256 lua_pop(L
, 1); /* drop value */
257 lua_pushvalue(L
, 2); /* dup index */
258 lua_gettable(L
, lua_upvalueindex(2)); /* else try methods */
259 if (lua_isnil(L
, -1)) /* invalid member */
260 luaL_error(L
, "cannot get member '%s'", lua_tostring(L
, 2));
263 return Xet_call(L
); /* call get function */
266 static int newindex_handler (lua_State
*L
)
268 /* stack has userdata, index, value */
269 lua_pushvalue(L
, 2); /* dup index */
270 lua_rawget(L
, lua_upvalueindex(1)); /* lookup member by name */
271 if (!lua_islightuserdata(L
, -1)) /* invalid member */
272 luaL_error(L
, "cannot set member '%s'", lua_tostring(L
, 2));
273 return Xet_call(L
); /* call set function */
277 struct_register(lua_State
*L
, const char *name
, const luaL_reg fn_methods
[], const luaL_reg meta_methods
[],
278 const struct Xet_reg setters
[], const struct Xet_reg getters
[])
280 int metatable
, methods
;
282 /* create methods table & add it to the table of globals */
283 luaL_register(L
, name
, fn_methods
);
284 methods
= lua_gettop(L
);
286 /* create metatable & add it to the registry */
287 luaL_newmetatable(L
, name
);
288 luaL_register(L
, 0, meta_methods
); /* fill metatable */
290 /* To identify the type of object */
291 lua_pushstring(L
, "_objname");
292 lua_pushstring(L
, name
);
295 metatable
= lua_gettop(L
);
297 lua_pushliteral(L
, "__metatable");
298 lua_pushvalue(L
, methods
); /* dup methods table*/
299 lua_rawset(L
, metatable
); /* hide metatable:
300 metatable.__metatable = methods */
302 lua_pushliteral(L
, "__index");
303 lua_pushvalue(L
, metatable
); /* upvalue index 1 */
304 Xet_add(L
, getters
); /* fill metatable with getters */
305 lua_pushvalue(L
, methods
); /* upvalue index 2 */
306 lua_pushcclosure(L
, index_handler
, 2);
307 lua_rawset(L
, metatable
); /* metatable.__index = index_handler */
309 lua_pushliteral(L
, "__newindex");
310 lua_newtable(L
); /* table for members you can set */
311 Xet_add(L
, setters
); /* fill with setters */
312 lua_pushcclosure(L
, newindex_handler
, 1);
313 lua_rawset(L
, metatable
); /* metatable.__newindex = newindex_handler */
315 /* FIXME: Why do we leave an element on the stack? */
316 lua_pop(L
, 1); /* drop metatable */
317 return 1; /* return methods on the stack */
323 PUSH_TYPE(callback
, struct lua_handler
)
325 CHECK_TYPE(callback
, struct lua_handler
)
328 callback_unhook(lua_State
*L
)
330 struct lua_handler
*lh
= check_callback(L
, 1);
333 lua_pushboolean(L
, 0);
334 lua_pushstring(L
, "Callback already unhooked.");
339 if (lh
->type
== LUA_HANDLER_TYPE_N
)
345 LuaHRef(L
, lh
->u
.reference
, 0);
348 unregister_listener(lh
->listener
);
350 lua_pushboolean(L
, 1);
355 static const luaL_reg callback_methods
[] = {
356 {"unhook", callback_unhook
},
360 static const luaL_reg callback_metamethods
[] = {
364 static const struct Xet_reg callback_setters
[] = {
368 static const struct Xet_reg callback_getters
[] = {
377 PUSH_TYPE(window
, struct win
)
379 CHECK_TYPE(window
, struct win
)
381 static int get_window(lua_State
*L
, void *v
)
383 push_window(L
, (struct win
**)v
);
388 window_change_title(lua_State
*L
)
390 struct win
*w
= check_window(L
, 1);
392 const char *title
= luaL_checklstring(L
, 2, &len
);
393 ChangeAKA(w
, (char *)title
, len
);
398 window_get_monitor_status(lua_State
*L
)
400 struct win
*w
= check_window(L
, 1);
401 int activity
= luaL_checkint(L
, 2);
404 lua_pushinteger(L
, w
->w_monitor
!= MON_OFF
);
407 lua_pushinteger(L
, w
->w_silence
== SILENCE_ON
? w
->w_silencewait
: 0);
412 static const luaL_reg window_methods
[] = {
413 {"get_monitor_status", window_get_monitor_status
},
414 {"hook", LuaRegEvent
},
419 window_tostring(lua_State
*L
)
422 struct win
*w
= check_window(L
, 1);
423 snprintf(str
, sizeof(str
), "{window #%d: '%s'}", w
->w_number
, w
->w_title
);
424 lua_pushstring(L
, str
);
429 window_equality(lua_State
*L
)
431 struct win
*w1
= check_window(L
, 1), *w2
= check_window(L
, 2);
432 lua_pushboolean(L
, (w1
== w2
|| (w1
&& w2
&& w1
->w_number
== w2
->w_number
)));
436 static const luaL_reg window_metamethods
[] = {
437 {"__tostring", window_tostring
},
438 {"__eq", window_equality
},
442 static const struct Xet_reg window_setters
[] = {
443 {"title", 0, 0, window_change_title
/*absolute setter*/},
447 static const struct Xet_reg window_getters
[] = {
448 {"title", get_string
, offsetof(struct win
, w_title
) + 8},
449 {"number", get_int
, offsetof(struct win
, w_number
)},
450 {"dir", get_string
, offsetof(struct win
, w_dir
)},
451 {"tty", get_string
, offsetof(struct win
, w_tty
)},
452 {"pid", get_int
, offsetof(struct win
, w_pid
)},
453 {"group", get_window
, offsetof(struct win
, w_group
)},
454 {"bell", get_int
, offsetof(struct win
, w_bell
)},
463 PUSH_TYPE(user
, struct acluser
)
465 CHECK_TYPE(user
, struct acluser
)
468 get_user(lua_State
*L
, void *v
)
470 push_user(L
, (struct acluser
**)v
);
474 static const luaL_reg user_methods
[] = {
479 user_tostring(lua_State
*L
)
482 struct acluser
*u
= check_user(L
, 1);
483 snprintf(str
, sizeof(str
), "{user '%s'}", u
->u_name
);
484 lua_pushstring(L
, str
);
488 static const luaL_reg user_metamethods
[] = {
489 {"__tostring", user_tostring
},
493 static const struct Xet_reg user_setters
[] = {
497 static const struct Xet_reg user_getters
[] = {
498 {"name", get_string
, offsetof(struct acluser
, u_name
)},
499 {"password", get_string
, offsetof(struct acluser
, u_password
)},
507 PUSH_TYPE(canvas
, struct canvas
)
509 CHECK_TYPE(canvas
, struct canvas
)
512 get_canvas(lua_State
*L
, void *v
)
514 push_canvas(L
, (struct canvas
**)v
);
519 canvas_select(lua_State
*L
)
521 struct canvas
*c
= check_canvas(L
, 1);
522 if (!display
|| D_forecv
== c
)
524 SetCanvasWindow(c
, Layer2Window(c
->c_layer
));
527 /* XXX: the following all is duplicated from process.c:DoAction.
528 * Should these be in some better place?
530 ResizeCanvas(&D_canvas
);
531 RecreateCanvasChain();
532 RethinkDisplayViewports();
533 ResizeLayersToCanvases(); /* redisplays */
534 fore
= D_fore
= Layer2Window(D_forecv
->c_layer
);
535 flayer
= D_forecv
->c_layer
;
537 if (D_xtermosc
[2] || D_xtermosc
[3])
547 flayer
= D_forecv
->c_layer
;
548 CV_CALL(D_forecv
, LayRestore();LaySetCursor());
549 WindowChanged(0, 'F');
553 static const luaL_reg canvas_methods
[] = {
554 {"select", canvas_select
},
558 static const luaL_reg canvas_metamethods
[] = {
562 static const struct Xet_reg canvas_setters
[] = {
567 canvas_get_window(lua_State
*L
)
569 struct canvas
*c
= check_canvas(L
, 1);
570 struct win
*win
= Layer2Window(c
->c_layer
);
572 push_window(L
, &win
);
578 static const struct Xet_reg canvas_getters
[] = {
579 {"next", get_canvas
, offsetof(struct canvas
, c_next
)},
580 {"xoff", get_int
, offsetof(struct canvas
, c_xoff
)},
581 {"yoff", get_int
, offsetof(struct canvas
, c_yoff
)},
582 {"xs", get_int
, offsetof(struct canvas
, c_xs
)},
583 {"ys", get_int
, offsetof(struct canvas
, c_ys
)},
584 {"xe", get_int
, offsetof(struct canvas
, c_xe
)},
585 {"ye", get_int
, offsetof(struct canvas
, c_ye
)},
586 {"window", 0, 0, canvas_get_window
},
594 PUSH_TYPE(layout
, struct layout
)
595 CHECK_TYPE(layout
, struct layout
)
597 static const struct Xet_reg layout_getters
[] = {
602 get_layout(lua_State
*L
, void *v
)
604 push_layout(L
, (struct layout
**)v
);
612 PUSH_TYPE(display
, struct display
)
614 CHECK_TYPE(display
, struct display
)
617 display_get_canvases(lua_State
*L
)
623 d
= check_display(L
, 1);
625 for (iter
= d
->d_cvlist
, count
= 0; iter
; iter
= iter
->c_next
, count
++) {
626 lua_pushinteger(L
, count
);
627 push_canvas(L
, &iter
);
634 static const luaL_reg display_methods
[] = {
635 {"get_canvases", display_get_canvases
},
640 display_tostring(lua_State
*L
)
643 struct display
*d
= check_display(L
, 1);
644 snprintf(str
, sizeof(str
), "{display: tty = '%s', term = '%s'}", d
->d_usertty
, d
->d_termname
);
645 lua_pushstring(L
, str
);
649 static const luaL_reg display_metamethods
[] = {
650 {"__tostring", display_tostring
},
654 static const struct Xet_reg display_setters
[] = {
658 static const struct Xet_reg display_getters
[] = {
659 {"tty", get_string
, offsetof(struct display
, d_usertty
)},
660 {"term", get_string
, offsetof(struct display
, d_termname
)},
661 {"fore", get_window
, offsetof(struct display
, d_fore
)},
662 {"other", get_window
, offsetof(struct display
, d_other
)},
663 {"width", get_int
, offsetof(struct display
, d_width
)},
664 {"height", get_int
, offsetof(struct display
, d_height
)},
665 {"user", get_user
, offsetof(struct display
, d_user
)},
666 {"layout", get_layout
, offsetof(struct display
, d_layout
)},
675 screen_get_windows(lua_State
*L
)
681 for (iter
= windows
, count
= 0; iter
; iter
= iter
->w_next
, count
++) {
682 lua_pushinteger(L
, iter
->w_number
);
683 push_window(L
, &iter
);
691 screen_get_displays(lua_State
*L
)
693 struct display
*iter
;
697 for (iter
= displays
, count
= 0; iter
; iter
= iter
->d_next
, count
++) {
698 lua_pushinteger(L
, count
);
699 push_display(L
, &iter
);
707 screen_get_display(lua_State
*L
)
709 push_display(L
, &display
);
714 screen_exec_command(lua_State
*L
)
719 command
= luaL_checklstring(L
, 1, &len
);
721 RcLine((char *)command
, len
);
727 screen_append_msg(lua_State
*L
)
729 const char *msg
, *color
;
731 msg
= luaL_checklstring(L
, 1, &len
);
735 color
= luaL_checklstring(L
, 2, &len
);
736 AppendWinMsgRend(msg
, color
);
747 script_input_fn(char *buf
, int len
, char *priv
)
749 struct sinput_data
*sidata
= (struct sinput_data
*)priv
;
750 lua_handler lh
= sidata
->lh
;
751 lua_State
*L
= sidata
->L
;
753 LuaPushHandler(L
, lh
);
754 lua_pushstring(L
, buf
);
755 if (lua_pcall(L
, 1, 0, 0) == LUA_ERRRUN
)
757 if(lua_isstring(L
, -1))
763 LuaFreeHandler(L
, &lh
);
767 screen_input(lua_State
*L
)
769 char * prompt
= NULL
;
771 struct sinput_data
*sidata
;
773 prompt
= (char *)luaL_checkstring(L
, 1);
774 lh
= LuaCheckHandler(L
, 2, 1);
775 sidata
= (struct sinput_data
*)malloc(sizeof(struct sinput_data
));
777 luaL_error(L
, "Out of Memory");
781 Input(prompt
, 100, INP_COOKED
, script_input_fn
, (char *)sidata
, 0);
786 static const luaL_reg screen_methods
[] = {
787 {"windows", screen_get_windows
},
788 {"displays", screen_get_displays
},
789 {"display", screen_get_display
},
790 {"command", screen_exec_command
},
791 {"append_msg", screen_append_msg
},
792 {"hook", LuaRegEvent
},
793 {"input", screen_input
},
797 static const luaL_reg screen_metamethods
[] = {
801 static const struct Xet_reg screen_setters
[] = {
805 static const struct Xet_reg screen_getters
[] = {
811 /** Public functions {{{ */
813 /* FIXME: Think about this: will it affect the registered handlers?*/
821 #define REGISTER(X) struct_register(L, #X , X ## _methods, X##_metamethods, X##_setters, X##_getters)
830 /* To store handler funcs */
831 luaL_getmetatable(L
, "screen");
832 /* two kinds of info in this table:
833 * _funckey[func]->key
834 * _funckey[key]->refcnt */
835 lua_pushstring(L
, "_funckey");
838 /* two kinds of info in this table:
839 * _keyfunc[key]->func */
840 lua_pushstring(L
, "_keyfunc");
848 /* An error message on top of the stack. */
850 LuaShowErr(lua_State
*L
)
852 struct display
*d
= display
;
854 const char *message
= luaL_checklstring(L
, -1, &len
);
855 LMsg(0, "%s", message
? message
: "Unknown error");
862 void (*push_fn
)(lua_State
*, void*);
867 LuaCallProcess(const char *name
, struct fn_def defs
[])
871 lua_getfield(L
, LUA_GLOBALSINDEX
, name
);
872 if (lua_isnil(L
, -1))
877 for (argc
= 0; defs
[argc
].push_fn
; argc
++)
878 defs
[argc
].push_fn(L
, defs
[argc
].value
);
879 if (lua_pcall(L
, argc
, 0, 0) == LUA_ERRRUN
&& lua_isstring(L
, -1))
887 int LuaSource(const char *file
, int async
)
892 if (stat(file
, &st
) == -1)
893 Msg(errno
, "Error loading lua script file '%s'", file
);
896 int len
= strlen(file
);
897 if (len
< 4 || strncmp(file
+ len
- 4, ".lua", 4) != 0)
899 if (luaL_dofile(L
, file
) && lua_isstring(L
, -1))
918 LuaProcessCaption(const char *caption
, struct win
*win
, int len
)
922 struct fn_def params
[] = {
923 {lua_pushstring
, caption
},
925 {lua_pushinteger
, len
},
928 return LuaCallProcess("process_caption", params
);
932 push_stringarray(lua_State
*L
, char **args
)
936 for (i
= 1; args
&& *args
; i
++) {
937 lua_pushinteger(L
, i
);
938 lua_pushstring(L
, *args
++);
944 LuaPushParams(lua_State
*L
, const char *params
, va_list va
)
952 lua_pushstring(L
, va_arg(va
, char *));
955 push_stringarray(L
, va_arg(va
, char **));
958 lua_pushinteger(L
, va_arg(va
, int));
962 struct display
*d
= va_arg(va
, struct display
*);
973 int LuaCall(const char *func
, const char **argv
)
979 StackDump(L
, "Before LuaCall\n");
980 lua_getfield(L
, LUA_GLOBALSINDEX
, func
);
981 if (lua_isnil(L
, -1))
984 lua_pushstring(L
, "Could not find the script function\n");
988 for (argc
= 0; *argv
; argv
++, argc
++)
990 lua_pushstring(L
, *argv
);
992 if (lua_pcall(L
, argc
, 0, 0) == LUA_ERRRUN
)
994 if(lua_isstring(L
, -1))
996 StackDump(L
, "After LuaCall\n");
1004 /*** Lua callback handler management {{{ */
1007 LuaPushHTable(lua_State
*L
, int screen
, const char * t
)
1009 lua_pushstring(L
, t
);
1010 lua_rawget(L
, screen
);
1011 /* FIXME: Do we need to balance the stack here? */
1012 if (lua_isnil(L
, -1))
1013 luaL_error(L
, "Fatal! Fail to get function registeration table!");
1014 return lua_gettop(L
);
1018 LuaPushHandler(lua_State
*L
, lua_handler lh
)
1021 if (lh
->type
== LUA_HANDLER_TYPE_F
)
1023 luaL_getmetatable(L
, "screen");
1024 keyfunc
= LuaPushHTable(L
, lua_gettop(L
), "_keyfunc");
1025 lua_rawgeti(L
, keyfunc
, lh
->u
.reference
);
1031 lua_getfield(L
, LUA_GLOBALSINDEX
, lh
->u
.name
);
1036 LuaHRef(lua_State
*L
, int key
, int reg
)
1038 int funckey
, keyfunc
, cnt
, sc
, idx
;
1039 luaL_getmetatable(L
, "screen");
1041 funckey
= LuaPushHTable(L
, sc
, "_funckey");
1042 keyfunc
= LuaPushHTable(L
, sc
, "_keyfunc");
1044 lua_rawgeti(L
, keyfunc
, key
);
1045 idx
= lua_gettop(L
);
1047 lua_rawgeti(L
, funckey
, key
);
1048 cnt
= lua_tointeger(L
, -1);/*cnt = htable[key]*/
1049 if (!reg
&& cnt
<= 1)
1051 /*release the last reference*/
1052 luaL_unref(L
, funckey
, key
);
1053 lua_pushvalue(L
, idx
);
1055 lua_settable(L
, funckey
); /*htable[func]=key*/
1059 lua_pushinteger(L
, key
);
1060 lua_pushinteger(L
, reg
? cnt
+ 1 : cnt
- 1);
1061 lua_settable(L
, funckey
); /*htable[key] = cnt + 1*/
1066 /* Ref when asked to. Never unref*/
1068 LuaFuncKey(lua_State
*L
, int idx
, int ref
)
1070 int key
, funckey
, sc
;
1071 luaL_getmetatable(L
, "screen");
1073 funckey
= LuaPushHTable(L
, sc
, "_funckey");
1075 lua_pushvalue(L
, idx
);
1076 lua_gettable(L
, funckey
);/*funckey[func] ==?*/
1077 if (lua_isnil(L
, -1))
1079 /* Not found, alloc a new key */
1083 /*funckey[key] = 1*/
1084 lua_pushinteger(L
, 1);
1085 key
= luaL_ref(L
, funckey
);
1087 /*funckey[func]=key*/
1088 lua_pushvalue(L
, idx
);
1089 lua_pushinteger(L
, key
);
1090 lua_settable(L
, funckey
);
1092 int keyfunc
= LuaPushHTable(L
, sc
, "_keyfunc");
1093 /*keyfunc[key] = func*/
1094 lua_pushinteger(L
, key
);
1095 lua_pushvalue(L
, idx
);
1096 lua_settable(L
, keyfunc
);
1102 key
= lua_tointeger(L
, -1);/*key = funckey[func]*/
1112 LuaCheckHandler(lua_State
*L
, int idx
, int ref
)
1115 if (lua_isstring(L
, idx
))
1117 const char * handler
;
1118 /* registered with func name.*/
1119 handler
= luaL_checkstring(L
, idx
);
1120 lua_getfield(L
, LUA_GLOBALSINDEX
, handler
);
1121 if (!lua_isfunction(L
, -1))
1122 luaL_error(L
, "The specified handler %s in param #%d is not a function", handler
, idx
);
1124 return LuaAllocHandler(handler
, 0);
1126 else if (!lua_isfunction(L
, idx
))
1127 luaL_error(L
, "Handler should be a function or the name of function");
1129 key
= LuaFuncKey(L
, idx
, ref
);
1130 return LuaAllocHandler(NULL
, key
);
1134 LuaHdlrComp(void *h1
, void *h2
)
1136 return (lua_handler
)h1
- (lua_handler
)h2
;
1142 LuaDispatch(void *handler
, const char *params
, va_list va
)
1144 lua_handler lh
= (lua_handler
)handler
;
1147 StackDump(L
, "before dispatch");
1149 LuaPushHandler(L
, lh
);
1150 if (lua_isnil(L
, -1))
1155 argc
= LuaPushParams(L
, params
, va
);
1157 if (lua_pcall(L
, argc
, 1, 0) == LUA_ERRRUN
&& lua_isstring(L
, -1))
1159 StackDump(L
, "After LuaDispatch\n");
1163 retvalue
= lua_tonumber(L
, -1);
1168 int LuaForeWindowChanged(void)
1170 struct fn_def params
[] = {
1171 {push_display
, &display
},
1172 {push_window
, display
? &D_fore
: &fore
},
1177 return LuaCallProcess("fore_changed", params
);
1180 #define SEVNAME_MAX 30
1182 LuaRegEvent(lua_State
*L
)
1184 /* signature: hook(obj, event, handler, priv);
1185 * or: hook(event, handler, priv)
1186 * returns: A ticket for later unregister. */
1187 int idx
= 1, argc
= lua_gettop(L
);
1188 unsigned int priv
= 31; /* Default privilege */
1192 const char *objname
= "global";
1194 static char evbuf
[SEVNAME_MAX
];
1197 struct script_event
*sev
;
1199 StackDump(L
, "Before RegEvent\n");
1201 /* Identify the object, if specified */
1202 if (luaL_getmetafield(L
, 1, "_objname"))
1204 objname
= luaL_checkstring(L
, -1);
1206 if (!strcmp("screen", objname
))
1209 obj
= *(char **)lua_touserdata(L
, 1);
1213 event
= luaL_checkstring(L
, idx
++);
1214 snprintf(evbuf
, SEVNAME_MAX
, "%s_%s", objname
, event
);
1216 /* Check and get the handler */
1217 lh
= LuaCheckHandler(L
, idx
++, 1);
1219 luaL_error(L
, "Out of memory");
1221 StackDump(L
, "In RegEvent\n");
1224 priv
= luaL_checkinteger(L
, idx
);
1226 sev
= object_get_event(obj
, evbuf
);
1230 l
= (struct listener
*)malloc(sizeof(struct listener
));
1232 return luaL_error(L
, "Out of memory");
1234 l
->bd
= &lua_binding
;
1235 l
->handler
= (void *)lh
;
1236 if (register_listener(sev
, l
))
1239 if (lh
->type
== LUA_HANDLER_TYPE_N
)
1240 return luaL_error(L
, "Handler %s has already been registered", lh
->u
.name
);
1242 return luaL_error(L
, "Handler has already been registered");
1244 /* Return the handler for un-register */
1245 /*l->handler = lua_newuserdata(L, sizeof(struct lua_handler));
1246 memcpy(l->handler, &lh, sizeof(struct lua_handler));*/
1248 push_callback(L
, (lua_handler
*)&l
->handler
);
1251 return luaL_error(L
, "Invalid event specified: %s for object %s", event
, objname
);
1253 StackDump(L
, "After RegEvent\n");
1258 LuaUnRegEvent(lua_State
*L
)
1260 /* signature: unhook([obj], ticket)
1261 * returns: true of success, false otherwise */
1265 /* If the param is not as expected */
1266 if (!lua_islightuserdata(L
, idx
))
1268 /* Then it should be the userdata to be ignore, but if not ... */
1269 if (!lua_isuserdata(L
, idx
))
1270 luaL_checktype(L
, idx
, LUA_TLIGHTUSERDATA
);
1272 luaL_checktype(L
, idx
, LUA_TLIGHTUSERDATA
);
1275 l
= (struct listener
*)lua_touserdata(L
, idx
++);
1277 /* Validate the listener structure */
1278 if (!l
|| !l
->handler
)
1281 lua_pushboolean(L
,0);
1285 LuaFreeHandler(L
, ((lua_handler
*)&(l
->handler
)));
1286 unregister_listener(l
);
1287 lua_pushboolean(L
, 1);
1295 struct ScriptFuncs LuaFuncs
=
1297 LuaForeWindowChanged
,
1301 struct binding lua_binding
=