Misc fix
[screen-lua.git] / src / lua.c
blobc7346538cfefd8bfd93c4bdd2b4db6a83a51edb4
1 /* Lua scripting support
3 * Copyright (c) 2008 Sadrul Habib Chowdhury (sadrul@users.sf.net)
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.
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.
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
20 ****************************************************************
22 #include <sys/types.h>
23 #include "config.h"
24 #include "screen.h"
25 #include <sys/stat.h>
26 #include <unistd.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <stdlib.h>
32 #include "extern.h"
33 #include "logfile.h"
35 #include <lua.h>
36 #include <lauxlib.h>
37 #include <lualib.h>
39 extern struct win *windows, *fore;
40 extern struct display *displays, *display;
41 extern struct LayFuncs WinLf;
42 extern struct layer *flayer;
44 /** Template {{{ */
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; \
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 } \
74 /* Much of the following template comes from:
75 * http://lua-users.org/wiki/BindingWithMembersAndMethods
78 static int get_int (lua_State *L, void *v)
80 lua_pushinteger (L, *(int*)v);
81 return 1;
84 static int set_int (lua_State *L, void *v)
86 *(int*)v = luaL_checkint(L, 3);
87 return 0;
90 static int get_number (lua_State *L, void *v)
92 lua_pushnumber(L, *(lua_Number*)v);
93 return 1;
96 static int set_number (lua_State *L, void *v)
98 *(lua_Number*)v = luaL_checknumber(L, 3);
99 return 0;
102 static int get_string (lua_State *L, void *v)
104 lua_pushstring(L, (char*)v );
105 return 1;
108 static int set_string (lua_State *L, void *v)
110 *(const char**)v = luaL_checkstring(L, 3);
111 return 0;
114 typedef int (*Xet_func) (lua_State *L, void *v);
116 /* member info for get and set handlers */
117 struct Xet_reg
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 *);
125 static void Xet_add (lua_State *L, const struct Xet_reg *l)
127 if (!l)
128 return;
129 for (; l->name; l++)
131 lua_pushstring(L, l->name);
132 lua_pushlightuserdata(L, (void*)l);
133 lua_settable(L, -3);
137 static int Xet_call (lua_State *L)
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);
149 static int index_handler (lua_State *L)
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))
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;
163 return Xet_call(L); /* call get function */
166 static int newindex_handler (lua_State *L)
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 */
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[])
180 int metatable, methods;
182 /* create methods table & add it to the table of globals */
183 luaL_register(L, name, fn_methods);
184 methods = lua_gettop(L);
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);
191 lua_pushliteral(L, "__metatable");
192 lua_pushvalue(L, methods); /* dup methods table*/
193 lua_rawset(L, metatable); /* hide metatable:
194 metatable.__metatable = methods */
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 */
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 */
209 lua_pop(L, 1); /* drop metatable */
210 return 1; /* return methods on the stack */
213 /** }}} */
215 /** Window {{{ */
217 PUSH_TYPE(window, struct win)
219 CHECK_TYPE(window, struct win)
221 static int get_window(lua_State *L, void *v)
223 push_window(L, (struct win **)v);
224 return 1;
227 static int
228 window_change_title(lua_State *L)
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;
237 static int
238 window_get_monitor_status(lua_State *L)
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);
249 return 1;
252 static const luaL_reg window_methods[] = {
253 {"get_monitor_status", window_get_monitor_status},
254 {0, 0}
257 static int
258 window_tostring(lua_State *L)
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;
267 static int
268 window_equality(lua_State *L)
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;
275 static const luaL_reg window_metamethods[] = {
276 {"__tostring", window_tostring},
277 {"__eq", window_equality},
278 {0, 0}
281 static const struct Xet_reg window_setters[] = {
282 {"title", 0, 0, window_change_title/*absolute setter*/},
283 {0, 0}
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}
298 /** }}} */
300 /** AclUser {{{ */
302 PUSH_TYPE(user, struct acluser)
304 CHECK_TYPE(user, struct acluser)
306 static int
307 get_user(lua_State *L, void *v)
309 push_user(L, (struct acluser **)v);
310 return 1;
313 static const luaL_reg user_methods[] = {
314 {0, 0}
317 static int
318 user_tostring(lua_State *L)
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;
327 static const luaL_reg user_metamethods[] = {
328 {"__tostring", user_tostring},
329 {0, 0}
332 static const struct Xet_reg user_setters[] = {
333 {0, 0}
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}
342 /** }}} */
344 /** Canvas {{{ */
346 PUSH_TYPE(canvas, struct canvas)
348 CHECK_TYPE(canvas, struct canvas)
350 static int
351 get_canvas(lua_State *L, void *v)
353 push_canvas(L, (struct canvas **)v);
354 return 1;
357 static int
358 canvas_select(lua_State *L)
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;
366 /* XXX: the following all is duplicated from process.c:DoAction.
367 * Should these be in some better place?
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])
378 Activate(-1);
379 break;
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;
392 static const luaL_reg canvas_methods[] = {
393 {"select", canvas_select},
394 {0, 0}
397 static const luaL_reg canvas_metamethods[] = {
398 {0, 0}
401 static const struct Xet_reg canvas_setters[] = {
402 {0, 0}
405 static int
406 canvas_get_window(lua_State *L)
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;
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}
429 /** }}} */
431 /** Layout {{{ */
433 PUSH_TYPE(layout, struct layout)
434 CHECK_TYPE(layout, struct layout)
436 static const struct Xet_reg layout_getters[] = {
437 {0,0}
440 static int
441 get_layout(lua_State *L, void *v)
443 push_layout(L, (struct layout **)v);
444 return 1;
447 /** }}} */
449 /** Display {{{ */
451 PUSH_TYPE(display, struct display)
453 CHECK_TYPE(display, struct display)
455 static int
456 display_get_canvases(lua_State *L)
458 struct display *d;
459 struct canvas *iter;
460 int count;
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);
470 return 1;
473 static const luaL_reg display_methods[] = {
474 {"get_canvases", display_get_canvases},
475 {0, 0}
478 static int
479 display_tostring(lua_State *L)
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;
488 static const luaL_reg display_metamethods[] = {
489 {"__tostring", display_tostring},
490 {0, 0}
493 static const struct Xet_reg display_setters[] = {
494 {0, 0}
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}
509 /** }}} */
511 /** Screen {{{ */
513 static int
514 screen_get_windows(lua_State *L)
516 struct win *iter;
517 int count;
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);
526 return 1;
529 static int
530 screen_get_displays(lua_State *L)
532 struct display *iter;
533 int count;
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);
542 return 1;
545 static int
546 screen_get_display(lua_State *L)
548 push_display(L, &display);
549 return 1;
552 static int
553 screen_exec_command(lua_State *L)
555 const char *command;
556 unsigned int len;
558 command = luaL_checklstring(L, 1, &len);
559 if (command)
560 RcLine((char *)command, len);
562 return 0;
565 static int
566 screen_append_msg(lua_State *L)
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;
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}
588 static const luaL_reg screen_metamethods[] = {
589 {0, 0}
592 static const struct Xet_reg screen_setters[] = {
593 {0, 0}
596 static const struct Xet_reg screen_getters[] = {
597 {0, 0}
600 /** }}} */
602 /** Public functions {{{ */
603 static lua_State *L;
604 int LuaInit(void)
606 L = luaL_newstate();
608 luaL_openlibs(L);
610 #define REGISTER(X) struct_register(L, #X , X ## _methods, X##_metamethods, X##_setters, X##_getters)
612 REGISTER(screen);
613 REGISTER(window);
614 REGISTER(display);
615 REGISTER(user);
616 REGISTER(canvas);
618 return 0;
621 struct fn_def
623 void (*push_fn)(lua_State *, void*);
624 void *value;
627 static int
628 LuaCallProcess(const char *name, struct fn_def defs[])
630 int argc = 0;
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))
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;
648 return 1;
651 int LuaForeWindowChanged(void)
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)
662 if(lua_isstring(L, -1))
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);
670 return 0;
673 int LuaSource(const char *file, int async)
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
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;
688 return 0;
691 int LuaFinit(void)
693 if (!L)
694 return 0;
695 lua_close(L);
696 L = (lua_State*)0;
697 return 0;
700 int LuaCall(char **argv)
702 int argc;
703 if (!L)
704 return 0;
706 lua_getfield(L, LUA_GLOBALSINDEX, *argv);
707 for (argc = 0, argv++; *argv; argv++, argc++)
709 lua_pushstring(L, *argv);
711 if (lua_pcall(L, argc, 0, 0) == LUA_ERRRUN)
713 if(lua_isstring(L, -1))
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;
722 return 1;
726 LuaProcessCaption(const char *caption, struct win *win, int len)
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}
736 return LuaCallProcess("process_caption", params);
739 static void
740 push_stringarray(lua_State *L, void *data)
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);
753 LuaCommandExecuted(const char *command, const char **args, int argc)
755 if (!L)
756 return 0;
757 struct fn_def params[] = {
758 {lua_pushstring, command},
759 {push_stringarray, args},
760 {NULL, NULL}
762 return LuaCallProcess("command_executed", params);
765 /** }}} */
767 struct ScriptFuncs LuaFuncs =
769 LuaForeWindowChanged,
770 LuaProcessCaption,
771 LuaCommandExecuted
774 struct binding lua_binding =
776 "lua", /*name*/
777 0, /*inited*/
778 0, /*registered*/
779 LuaInit,
780 LuaFinit,
781 LuaSource,
782 0, /*b_next*/
783 &LuaFuncs