--- /dev/null
+
+/*] Copyright (c) 2011, Charles McGarvey [*******************************
+**] All rights reserved.
+*
+* vi:ts=4 sw=4 tw=75
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+**************************************************************************/
+
+#define LUA_DIALOG_NAME "dialog"
+#define LUA_DIALOG_VERSION "1.0"
+
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define LUA_LIB
+#include "lua.h"
+#include "lauxlib.h"
+
+
+#ifdef NDEBUG
+#define printarray(A)
+#else
+#include <stdio.h>
+static void printarray(const char* argv[])
+{
+ printf("%s", argv[0]);
+ int i; for (i = 1; argv[i]; ++i) printf(" %s", argv[i]);
+}
+#endif
+
+
+/**
+ * Fork and execute a command with arguments and optionally get a file
+ * descriptor connected to one of the child's own file descriptors. The
+ * process id of the child is returned, or -1 on error. If fd is not NULL,
+ * a pipe will be created and connected to *fd. If *fd is 0, then *fd will
+ * be set to a write file descriptor connected to the child's standard
+ * input. If *fd is not 0, then *fd will be set to a read file descriptor
+ * set connected to the specified file descriptor of the child. In either
+ * case, the caller has the responsibility to close fd when it is no longer
+ * needed.
+ */
+static pid_t myexec(const char* command, char* const argv[], int* fd)
+{
+ int parentFd = -1;
+ int p[2];
+ pid_t child;
+
+ if (fd)
+ {
+ if (pipe(p) != 0) return -1;
+ parentFd = (*fd == 0);
+ }
+ if (!(child = fork()))
+ {
+ if (fd)
+ {
+ close(p[parentFd]);
+ if (dup2(p[!parentFd], *fd) == -1) _exit(127);
+ }
+ execv(command, argv);
+ _exit(127);
+ }
+ if (child == -1)
+ {
+ if (parentFd != -1)
+ {
+ close(p[0]); close(p[1]);
+ }
+ return -1;
+ }
+ if (parentFd != -1)
+ {
+ close(p[!parentFd]);
+ *fd = p[parentFd];
+ }
+ return child;
+}
+
+/**
+ * Wait on a child process. Returns the exit status of the process if the
+ * child terminates normally, or -1 on error or abnormal child termination.
+ */
+static int mywait(pid_t pid)
+{
+ int status;
+ if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) return -1;
+ return WEXITSTATUS(status);
+}
+
+
+/**
+ * Read from a file descriptor until EOF and push contents to the top of
+ * the Lua stack. Closes the file descriptor afterward.
+ */
+static void pushstream(lua_State* L, int fd)
+{
+ luaL_Buffer B;
+ luaL_buffinit(L, &B);
+
+ char buffer[BUFSIZ];
+ ssize_t bytes;
+ while ((bytes = read(fd, buffer, sizeof(buffer))))
+ {
+ if (bytes == -1) break;
+ luaL_addlstring(&B, buffer, bytes);
+ }
+
+ close(fd);
+ luaL_pushresult(&B);
+}
+
+/**
+ * Write some arbitrary bytes to a file descriptor, appending a newline.
+ */
+static void writelstring(int fd, const char* str, size_t len)
+{
+ ssize_t bytes;
+ while ((bytes = write(fd, str, len)))
+ {
+ if (bytes == -1) break;
+ str += bytes;
+ len -= bytes;
+ }
+ bytes = write(fd, "\n", 1);
+}
+
+/**
+ * Write a NULL-terminate string to a file descriptor. Uses writelstring.
+ */
+static void writestring(int fd, const char* str)
+{
+ writelstring(fd, str, strlen(str));
+}
+
+/**
+ * Write a Lua value, that is able to be converted to a string, to a file
+ * descriptor.
+ */
+static void tostream(lua_State* L, int index, int fd)
+{
+ size_t len = 0;
+ const char* buffer = lua_tolstring(L, index, &len);
+ writelstring(fd, buffer, len);
+}
+
+
+/**
+ * Add one or more strings to the end of a NULL-terminated array of
+ * strings. The parameter list itself should also be terminated with a
+ * NULL. The terminating NULL of the array of strings will be moved back
+ * as needed. It is the responsibility of the caller to assert there is
+ * enough room in the array so that an overflow doesn't occur. Strings are
+ * not duplicated as they are added to the array.
+ */
+static void addstrings(const char* argv[], ...)
+{
+ va_list ap;
+ int i; for (i = 0; argv[i]; ++i);
+ va_start(ap, argv);
+ const char* arg = va_arg(ap, const char*);
+ while (arg)
+ {
+ argv[i++] = arg;
+ arg = va_arg(ap, const char*);
+ }
+ va_end(ap);
+ argv[i] = NULL;
+}
+
+/**
+ * Search an array of strings for a particular string, returning the index
+ * where the first equivalent string is found or -1 if it wasn't found.
+ */
+static int searchstrings(const char* argv[], const char* str)
+{
+ int i; for (i = 0; argv[i]; ++i) if (strcmp(argv[i], str) == 0) return i;
+ return -1;
+}
+
+
+/**
+ * Add the command and backtitle to the argument list from the Lua state.
+ */
+static void addcommand(lua_State* L, const char* argv[])
+{
+ lua_getglobal(L, LUA_DIALOG_NAME);
+ lua_getfield(L, -1, "command");
+ lua_getfield(L, -2, "title");
+ addstrings(argv, lua_tostring(L, -2), NULL);
+ if (lua_isstring(L, -1))
+ {
+ addstrings(argv, "--backtitle", lua_tostring(L, -1), NULL);
+ }
+ lua_pop(L, 3);
+}
+
+/**
+ * Add the height and width to the argument list from the Lua state.
+ */
+static int addsize(lua_State* L, const char* argv[], int extra, int n)
+{
+ int m = n;
+ lua_getglobal(L, LUA_DIALOG_NAME);
+ if (lua_isnumber(L, m)) lua_pushvalue(L, m++);
+ else lua_getfield(L, -1, "height");
+ if (lua_isnumber(L, m)) lua_pushvalue(L, m++);
+ else lua_getfield(L, -2, "width");
+ addstrings(argv, lua_tostring(L, -2), lua_tostring(L, -1), NULL);
+ if (extra) addstrings(argv, lua_tostring(L, -2), NULL);
+ lua_pop(L, 3);
+ return m - n;
+}
+
+/**
+ * Add the dialog title to the argument list from the Lua state. The title
+ * should be at index 1 on the stack, and an error is thrown if it is not
+ * found.
+ */
+static void addtitle(lua_State* L, const char* argv[])
+{
+ addstrings(argv, "--title", luaL_checkstring(L, 1), NULL);
+}
+
+/**
+ * Add the caption to the argument list from the Lua state. The caption
+ * should be at index 2 on the stack, and an error is thrown if it is not
+ * found.
+ */
+static void addcaption(lua_State* L, const char* argv[])
+{
+ addstrings(argv, luaL_optstring(L, 2, ""), NULL);
+}
+
+/**
+ * Get the string found at a certain index on the Lua stack, returned in
+ * the text argument. Returns whether the text was set.
+ */
+static int getstring(lua_State* L, const char* argv[], int n, const char** text)
+{
+ if (lua_type(L, n) != LUA_TSTRING) return 0;
+ *text = lua_tostring(L, n);
+ return 1;
+}
+
+/**
+ * Add extra arguments to the argument list from the Lua state. The extra
+ * arguments exist in a table where the key is a flag and its value (if it
+ * is a string) is added as a flag option.
+ */
+static int addextra(lua_State* L, const char* argv[], int n)
+{
+ if (!lua_istable(L, n)) return 0;
+ lua_pushnil(L);
+ while (lua_next(L, n))
+ {
+ addstrings(argv, lua_tostring(L, -2), NULL);
+ if (lua_isstring(L, -1)) addstrings(argv, lua_tostring(L, -1), NULL);
+ lua_pop(L, 1);
+ }
+ return 1;
+}
+
+/**
+ * Add the default item to the argument list from the Lua stack for a menu
+ * command. Returns whether or not the arguments were found and added. If
+ * the value on the stack is nil, no arguments are added to the list, but
+ * the return value is still 1.
+ */
+static int addselected(lua_State* L, const char* argv[], int n)
+{
+ if (lua_isnil(L, n)) return 1;
+ if (!lua_isstring(L, n)) return 0;
+ addstrings(argv, "--default-item", lua_tostring(L, n), NULL);
+ return 1;
+}
+
+/**
+ * Add menu items to the argument list from the Lua stack. They should
+ * exist in a table at index 3 of a menu command. Each item should be a
+ * table itself with two or three strings, depending on whether --item-help
+ * exists in the argument list.
+ */
+static void addmenuitems(lua_State* L, const char* argv[])
+{
+ int fields = 2;
+ if (searchstrings(argv, "--item-help") != -1) fields = 3;
+
+ if (!lua_istable(L, 3)) luaL_argerror(L, 3, "menu items");
+ int i; for (i = 1;; ++i)
+ {
+ lua_pushinteger(L, i);
+ lua_gettable(L, 3);
+ if (lua_isnil(L, -1))
+ {
+ lua_pop(L, 1);
+ break;
+ }
+ else if (lua_istable(L, -1))
+ {
+ int subtable = lua_gettop(L);
+ lua_pushnil(L);
+ int j; for (j = 0; j < fields; ++j)
+ {
+ if (!lua_next(L, subtable)) luaL_argerror(L, 3, "not enough fields");
+ addstrings(argv, lua_tostring(L, -1), NULL);
+ lua_pop(L, 1);
+ }
+ lua_pop(L, 1);
+ }
+ else
+ {
+ if (fields == 2) addstrings(argv, "", "", NULL);
+ else addstrings(argv, "", "", "", NULL);
+ }
+ lua_pop(L, 1);
+ }
+}
+
+/**
+ * Fill out the argument list from the Lua state according to the standard
+ * 3 or 4 argument dialog command format.
+ */
+static void addargs(lua_State* L, const char* command, int nargs, const char* argv[])
+{
+ assert((nargs == 3 || nargs == 4) && "nargs should be 3 or 4");
+
+ addcommand(L, argv);
+ addtitle(L, argv);
+ const char* text = NULL;
+ int n = 3;
+ if (nargs == 4) n += getstring(L, argv, n, &text);
+ n += addextra(L, argv, n);
+ addstrings(argv, command, NULL);
+ addcaption(L, argv);
+ addsize(L, argv, 0, n);
+ if (text) addstrings(argv, text, NULL);
+}
+
+
+/**
+ * Close a gauge dialog if one is running. If a gauge is in progress, the
+ * status code will be pushed onto the stack and 1 is returned; otherwise,
+ * 0 is returned.
+ */
+static void closegauge(lua_State* L)
+{
+ lua_getfield(L, LUA_REGISTRYINDEX, "dialog_gauge_pid");
+ lua_getfield(L, LUA_REGISTRYINDEX, "dialog_gauge_fd");
+ if (!lua_isnumber(L, -2) || !lua_isnumber(L, -1))
+ {
+ lua_pop(L, 2);
+ return;
+ }
+ pid_t pid = lua_tointeger(L, -2);
+ int fd = lua_tointeger(L, -1);
+ lua_pop(L, 2);
+
+ lua_pushnil(L);
+ lua_setfield(L, LUA_REGISTRYINDEX, "dialog_gauge_pid");
+ lua_pushnil(L);
+ lua_setfield(L, LUA_REGISTRYINDEX, "dialog_gauge_fd");
+
+ close(fd);
+ int code = mywait(pid);
+ if (code == -1) luaL_error(L, "dialog killed abnormally");
+}
+
+/**
+ * Updates the progress of a gauge dialog. Takes a number argument in the
+ * range of 0-100 or 0.0-1.0 as the progress. Optionally takes a string as
+ * the second argument which causes the caption to change. The last call
+ * to this function should be with no arguments to end the gauge dialog.
+ * Returns nothing except the last call which returns the status code of
+ * the dialog which should always be OK.
+ */
+static int updategauge(lua_State* L)
+{
+ if (!lua_isnumber(L, 1))
+ {
+ closegauge(L);
+ return 0;
+ }
+
+ lua_getfield(L, LUA_REGISTRYINDEX, "dialog_gauge_fd");
+ if (!lua_isnumber(L, -1)) return 0;
+ int fd = lua_tointeger(L, -1);
+
+ lua_Number percent = lua_tonumber(L, 1);
+ if (0.0 <= percent && percent <= 1.0) percent *= 100.0;
+ lua_pushinteger(L, (lua_Integer)percent);
+ lua_replace(L, 1);
+ if (lua_isstring(L, 2))
+ {
+ writestring(fd, "XXX");
+ tostream(L, 1, fd);
+ tostream(L, 2, fd);
+ writestring(fd, "XXX");
+ }
+ else
+ {
+ tostream(L, 1, fd);
+ }
+ return 0;
+}
+
+/**
+ * Display a gauge dialog. Required arguments are dialog title and
+ * caption. Optional arguments include a table of extra flags. Returns a
+ * new function which can be used to update the progress.
+ */
+static int dialog_gauge(lua_State* L)
+{
+ const char* argv[40] = {NULL};
+ closegauge(L);
+ addargs(L, "--gauge", 3, argv);
+
+ int fd = 0;
+ pid_t pid = myexec(argv[0], (char* const*)argv, &fd);
+ if (pid == -1) luaL_error(L, "dialog failed to execute");
+ lua_pushinteger(L, pid);
+ lua_setfield(L, LUA_REGISTRYINDEX, "dialog_gauge_pid");
+ lua_pushinteger(L, fd);
+ lua_setfield(L, LUA_REGISTRYINDEX, "dialog_gauge_fd");
+ lua_pushcfunction(L, updategauge);
+ return 1;
+}
+/**
+ * Display a menu dialog. Required arguments are dialog title, caption,
+ * and table of menu items. Optional arguments are selected item and table
+ * of extra flags.
+ */
+static int dialog_menu(lua_State* L)
+{
+ const char* argv[1024] = {NULL};
+ closegauge(L);
+
+ addcommand(L, argv);
+ addtitle(L, argv);
+ int n = 4;
+ n += addselected(L, argv, n);
+ n += addextra(L, argv, n);
+ addstrings(argv, "--menu", NULL);
+ addcaption(L, argv);
+ addsize(L, argv, 1, n);
+ addmenuitems(L, argv);
+
+ printarray(argv);
+
+ int fd = 2;
+ pid_t pid = myexec(argv[0], (char* const*)argv, &fd);
+ if (pid == -1) luaL_error(L, "dialog failed to execute");
+ int code = mywait(pid);
+ if (code == -1) luaL_error(L, "dialog killed abnormally");
+ lua_pushinteger(L, code);
+ pushstream(L, fd);
+ return 2;
+}
+
+/**
+ * Display a message dialog. Required arguments are dialog title and
+ * caption. Optional arguments include a table of extra flags.
+ */
+static int dialog_msgbox(lua_State* L)
+{
+ const char* argv[40] = {NULL};
+ closegauge(L);
+ addargs(L, "--msgbox", 3, argv);
+
+ pid_t pid = myexec(argv[0], (char* const*)argv, NULL);
+ if (pid == -1) luaL_error(L, "dialog failed to execute");
+ int code = mywait(pid);
+ if (code == -1) luaL_error(L, "dialog killed abnormally");
+ lua_pushinteger(L, code);
+ return 1;
+}
+
+/**
+ * Display an input dialog. Required arguments are dialog title and
+ * caption. Optional arguments are the default text and a table of extra
+ * flags.
+ */
+static int dialog_inputbox(lua_State* L)
+{
+ const char* argv[40] = {NULL};
+ closegauge(L);
+ addargs(L, "--inputbox", 4, argv);
+
+ int fd = 2;
+ pid_t pid = myexec(argv[0], (char* const*)argv, &fd);
+ if (pid == -1) luaL_error(L, "dialog failed to execute");
+ int code = mywait(pid);
+ if (code == -1) luaL_error(L, "dialog killed abnormally");
+ lua_pushinteger(L, code);
+ pushstream(L, fd);
+ return 2;
+}
+
+/**
+ * Display a yes/no dialog. Required arguments are dialog title and
+ * caption. Optional arguments include a table of extra flags.
+ */
+static int dialog_yesno(lua_State* L)
+{
+ const char* argv[40] = {NULL};
+ closegauge(L);
+ addargs(L, "--yesno", 3, argv);
+
+ pid_t pid = myexec(argv[0], (char* const*)argv, NULL);
+ if (pid == -1) luaL_error(L, "dialog failed to execute");
+ int code = mywait(pid);
+ if (code == -1) luaL_error(L, "dialog killed abnormally");
+ lua_pushinteger(L, code);
+ return 1;
+}
+
+
+/**
+ * Register the module functions and find a dialog command in the path.
+ */
+LUALIB_API int luaopen_dialog(lua_State* L)
+{
+ const struct luaL_Reg dialog_funcs[] = {
+ {"gauge", dialog_gauge},
+ {"inputbox", dialog_inputbox},
+ {"menu", dialog_menu},
+ {"msgbox", dialog_msgbox},
+ {"yesno", dialog_yesno},
+ {NULL, NULL}
+ };
+ luaL_register(L, LUA_DIALOG_NAME, dialog_funcs);
+
+ const char* names[] = {getenv("DIALOG"), "dialog", "cdialog"};
+ int i; for (i = 0; i < 3; ++i)
+ {
+ if (names[i])
+ {
+ char* path = strdup(getenv("PATH"));
+ char* token; char** paths = &path;
+ while ((token = strsep(paths, ":")))
+ {
+ luaL_Buffer B;
+ luaL_buffinit(L, &B);
+ luaL_addstring(&B, token);
+ luaL_addstring(&B, "/");
+ luaL_addstring(&B, names[i]);
+ luaL_pushresult(&B);
+ if (access(lua_tostring(L, -1), X_OK) == 0)
+ {
+ lua_setfield(L, -2, "command");
+ goto break2;
+ }
+ lua_pop(L, 1);
+ }
+ free(path);
+ }
+ }
+ luaL_error(L, "cannot find dialog executable in the path; set DIALOG");
+
+break2:
+
+ lua_pushinteger(L, 0);
+ lua_setfield(L, -2, "height");
+ lua_pushinteger(L, 0);
+ lua_setfield(L, -2, "width");
+
+ return 1;
+}
+
projects / chaz / yoink / blobdiff