Commits May 2015

commits@lists.geany.org

1 participants
96 discussions

[geany/geany] ce0fa6: Add a spawn module for Geany
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Tue, 10 Mar 2015 19:24:42 UTC Commit: ce0fa6ffa17befa0969653a0312b38a5429f1d6e https://github.com/geany/geany/commit/ce0fa6ffa17befa0969653a0312b38a5429f1… Log Message: ----------- Add a spawn module for Geany g_spawn_async_with_pipes() under Windows has various drawbacks: - There is no g_shell_parse_argv() for windows. It's not hard to write one, but the command line recreated by mscvrt may be wrong. - GLib converts the argument vector to UNICODE. For non-UTF8 arguments, the result is often "Invalid string in argument vector at %d: %s: Invalid byte sequence in conversion input" (YMMV). Our tools (make, grep, gcc, ...) are "ANSI", so converting to UNICODE and then back only causes problems. - For various reasons, GLib uses an intermediate program to start children (see gspawn-win32.c), with the side effect that the grandchildren output (such as make -> gcc) is not captured. - With non-blocking pipes, the g_io_add_watch() callbacks are never invoked, while with blocking pipes, g_io_channel_read_line() blocks. - Some smaller problems, explained in spawn.c as inline comments. The spawn module tries to fix these problems, and to provide easier APIs, which guarantee that the callbacks will synchronized as expected, and g_io_channel_read_line() will not be required, since even under Unix, it may buffer lines of unlimited length. This initial commit only adds the module source and header files, and includes it in the various build systems. You can see PR 274 for a long discussion about the module. Modified Paths: -------------- src/Makefile.am src/makefile.win32 src/spawn.c src/spawn.h wscript Modified: src/Makefile.am 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -48,6 +48,7 @@ SRCS = \ sciwrappers.c sciwrappers.h \ search.c search.h \ socket.c socket.h \ + spawn.c spawn.h \ stash.c stash.h \ support.h \ symbols.c symbols.h \ Modified: src/makefile.win32 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -65,7 +65,7 @@ OBJS = about.o build.o callbacks.o dialogs.o document.o editor.o encodings.o fil geanyentryaction.o geanymenubuttonaction.o geanyobject.o geanywraplabel.o highlighting.o \ keybindings.o keyfile.o log.o main.o msgwindow.o navqueue.o notebook.o \ plugins.o pluginutils.o prefs.o printing.o project.o sciwrappers.o search.o \ - socket.o stash.o symbols.o templates.o toolbar.o tools.o sidebar.o \ + socket.o spawn.o stash.o symbols.o templates.o toolbar.o tools.o sidebar.o \ ui_utils.o utils.o win32.o .c.o: Modified: src/spawn.c 1247 lines changed, 1247 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,1247 @@ +/* + * spawn.c - this file is part of Geany, a fast and lightweight IDE + * + * Copyright 2013 Dimitar Toshkov Zhekov <dimitar(dot)zhekov(at)gmail(dot)com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +/* An ongoing effort to improve the tool spawning situation under Windows. + * In particular: + * - There is no g_shell_parse_argv() for windows. It's not hard to write one, + * but the command line recreated by mscvrt may be wrong. + * - GLib converts the argument vector to UNICODE. For non-UTF8 arguments, + * the result is often "Invalid string in argument vector at %d: %s: Invalid + * byte sequence in conversion input" (YMMV). Our tools (make, grep, gcc, ...) + * are "ANSI", so converting to UNICODE and then back only causes problems. + * - For various reasons, GLib uses an intermediate program to start children + * (see gspawn-win32.c), the result being that the grandchildren output (such + * as make -> gcc) is not captured. + * - With non-blocking pipes, the g_io_add_watch() callbacks are never invoked, + * while with blocking pipes, g_io_channel_read_line() blocks. + * - Some other problems are explained in separate comments below. + * + * Even under Unix, using g_io_channel_read_line() is not a good idea, since it may + * buffer lines of unlimited length. + * + * This module does not depend on Geany when compiled for testing (-DSPAWN_TEST). + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <errno.h> +#include <string.h> + +#include "spawn.h" + +#ifdef G_OS_WIN32 +# include <fcntl.h> /* _O_RDONLY, _O_WRONLY */ +# include <io.h> /* _open_osfhandle, _close */ +# include <windows.h> +#else /* G_OS_WIN32 */ +# include <signal.h> +#endif /* G_OS_WIN32 */ + +#ifdef SPAWN_TEST +# define _ +#else +# include "support.h" +#endif + +#ifdef G_OS_WIN32 +# define CL_BLANKS " \t" /* possible blank characters in a Windows command line */ +/* Each 4KB under Windows seem to come in 2 portions, so 2K + 2K is more + balanced than 4095 + 1. May be different on the latest Windows/glib? */ +# define DEFAULT_IO_LENGTH 2048 +#else +# define DEFAULT_IO_LENGTH 4096 +#endif + +#define G_IO_FAILURE (G_IO_ERR | G_IO_HUP | G_IO_NVAL) /* always used together */ + + +/** + * Checks whether a command line is valid. + * + * All OS: + * - any leading spaces and tabs are ignored + * - a command consisting solely of spaces and tabs is invalid + * Unix: + * - the standard shell quoting and escaping rules are used, see @c g_shell_parse_argv() + * - as a consequence, an unqouted # at the start of an argument comments to the end of line + * Windows: + * - a quoted program name must be entirely inside the quotes. It's hard to believe, but + * "C:\Foo\Bar".pdf is actually executed as "C:\Foo\Bar.exe", and .pdf is completely + * ignored, not even passed as an argument + * - the standard Windows quoting rules are used: double quote is escaped with slash, and + * any literal slashes before a double quote must be duplicated. + * + * @param command_line the command line to check. + * @param execute whether to check, using @c g_find_program_in_path(), if the program specified + * in the command line exists and is executable. + * @param error return location for error. + * + * @return @c TRUE on success, @c FALSE if an error was set. + **/ +gboolean spawn_check_command(const gchar *command_line, gboolean execute, GError **error) +{ + gchar *program; + +#ifdef G_OS_WIN32 + gboolean open_quote = FALSE; + const gchar *s, *arguments; + + g_return_val_if_fail(command_line != NULL, FALSE); + + while (*command_line && strchr(CL_BLANKS, *command_line)) + command_line++; + + if (!*command_line) + { + /* TL note: from glib */ + g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_EMPTY_STRING, + _("Text was empty (or contained only whitespace)")); + return FALSE; + } + + if (*command_line == '"') + { + command_line++; + /* Windows allows "foo.exe, but we may have extra arguments */ + if ((s = strchr(command_line, '"')) == NULL) + { + /* TL note: from glib */ + g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_BAD_QUOTING, + _("Text ended before matching quote was found for %c." + " (The text was '%s')"), '"', command_line); + return FALSE; + } + + if (!strchr(CL_BLANKS, s[1])) /* strchr() catches s[1] == '\0' */ + { + g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_BAD_QUOTING, + _("A quoted Windows program name must be entirely inside the quotes")); + return FALSE; + } + } + else + { + const gchar *quote = strchr(command_line, '"'); + + /* strchr() catches *s == '\0', and the for body is empty */ + for (s = command_line; !strchr(CL_BLANKS, *s); s++); + + if (quote && quote < s) + { + g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_BAD_QUOTING, + _("A quoted Windows program name must be entirely inside the quotes")); + return FALSE; + } + } + + program = g_strndup(command_line, s - command_line); + arguments = s + (*s == '"'); + + for (s = arguments; *s; s++) + { + if (*s == '"') + { + const char *slash; + + for (slash = s; slash > arguments && slash[-1] == '\\'; slash--); + if ((s - slash) % 2 == 0) + open_quote ^= TRUE; + } + } + + if (open_quote) + { + /* TL note: from glib */ + g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_BAD_QUOTING, + _("Text ended before matching quote was found for %c." + " (The text was '%s')"), '"', command_line); + return FALSE; + } +#else /* G_OS_WIN32 */ + int argc; + char **argv; + + if (!g_shell_parse_argv(command_line, &argc, &argv, error)) + return FALSE; + + /* empty string results in parse error, so argv[0] is not NULL */ + program = g_strdup(argv[0]); + g_strfreev(argv); +#endif /* G_OS_WIN32 */ + + if (execute) + { + gchar *executable = g_find_program_in_path(program); + + if (!executable) + { + g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_FAILED, /* or SPAWN error? */ + _("Program '%s' not found"), program); + g_free(program); + return FALSE; + } + + g_free(executable); + } + + g_free(program); + return TRUE; +} + + +/** + * Kills a process. + * + * @param pid id of the process to kill. + * @param error return location for error. + * + * On Unix, sends a SIGTERM to the process. + * + * On Windows, terminates the process with exit code 255 (used sometimes as "generic" + * error code, or for programs terminated with Ctrl+C / Ctrl+Break). + * + * @return @c TRUE on success, @c FALSE on error. + **/ +gboolean spawn_kill_process(GPid pid, GError **error) +{ +#ifdef G_OS_WIN32 + if (!TerminateProcess(pid, 255)) + { + gchar *message = g_win32_error_message(GetLastError()); + + g_set_error(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, + _("TerminateProcess() failed: %s"), message); + g_free(message); + return FALSE; + } +#else + if (kill(pid, SIGTERM)) + { + g_set_error(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "%s", g_strerror(errno)); + return FALSE; + } +#endif + return TRUE; +} + + +#ifdef G_OS_WIN32 +static gchar *spawn_create_process_with_pipes(char *command_line, const char *working_directory, + void *environment, HANDLE *hprocess, int *stdin_fd, int *stdout_fd, int *stderr_fd) +{ + enum { WRITE_STDIN, READ_STDOUT, READ_STDERR, READ_STDIN, WRITE_STDOUT, WRITE_STDERR }; + STARTUPINFO startup; + PROCESS_INFORMATION process; + HANDLE hpipe[6] = { NULL, NULL, NULL, NULL, NULL, NULL }; + int *fd[3] = { stdin_fd, stdout_fd, stderr_fd }; + const char *failed; /* failed WIN32/CRTL function, if any */ + gchar *message = NULL; /* glib WIN32/CTRL error message */ + gchar *failure = NULL; /* full error text */ + gboolean pipe_io; + int i; + + ZeroMemory(&startup, sizeof startup); + startup.cb = sizeof startup; + pipe_io = stdin_fd || stdout_fd || stderr_fd; + + if (pipe_io) + { + startup.dwFlags |= STARTF_USESTDHANDLES; + + /* not all programs accept mixed NULL and non-NULL hStd*, so we create all */ + for (i = 0; i < 3; i++) + { + static int pindex[3][2] = { { READ_STDIN, WRITE_STDIN }, + { READ_STDOUT, WRITE_STDOUT }, { READ_STDERR, WRITE_STDERR } }; + + if (!CreatePipe(&hpipe[pindex[i][0]], &hpipe[pindex[i][1]], NULL, 0)) + { + hpipe[pindex[i][0]] = hpipe[pindex[i][1]] = NULL; + failed = "CreatePipe"; + goto leave; + } + + if (fd[i]) + { + static int mode[3] = { _O_WRONLY, _O_RDONLY, _O_RDONLY }; + + if ((*fd[i] = _open_osfhandle((intptr_t) hpipe[i], mode[i])) == -1) + { + failed = "_open_osfhandle"; + message = g_strdup(g_strerror(errno)); + goto leave; + } + } + else if (!CloseHandle(hpipe[i])) + { + failed = "CloseHandle"; + goto leave; + } + + if (!SetHandleInformation(hpipe[i + 3], HANDLE_FLAG_INHERIT, + HANDLE_FLAG_INHERIT)) + { + failed = "SetHandleInformation"; + goto leave; + } + } + } + + startup.hStdInput = hpipe[READ_STDIN]; + startup.hStdOutput = hpipe[WRITE_STDOUT]; + startup.hStdError = hpipe[WRITE_STDERR]; + + if (!CreateProcess(NULL, command_line, NULL, NULL, TRUE, pipe_io ? CREATE_NO_WINDOW : 0, + environment, working_directory, &startup, &process)) + { + failed = "CreateProcess"; + /* further errors will not be reported */ + } + else + { + failed = NULL; + CloseHandle(process.hThread); /* we don't need this */ + *hprocess = process.hProcess; + } + +leave: + if (failed) + { + if (!message) + message = g_win32_error_message(GetLastError()); + + failure = g_strdup_printf("%s() failed: %s", failed, message); + g_free(message); + } + + if (pipe_io) + { + for (i = 0; i < 3; i++) + { + if (failed) + { + if (fd[i] && *fd[i] != -1) + _close(*fd[i]); + else if (hpipe[i]) + CloseHandle(hpipe[i]); + } + + if (hpipe[i + 3]) + CloseHandle(hpipe[i + 3]); + } + } + + return failure; +} + + +static void spawn_append_argument(GString *command, const char *text) +{ + const char *s; + + if (command->len) + g_string_append_c(command, ' '); + + for (s = text; *s; s++) + if (*s == '"' || g_ascii_isspace(*s)) /* are all RTL-s standartized? */ + break; + + if (*text && !*s) + g_string_append(command, text); + else + { + g_string_append_c(command, '"'); + + for (s = text; *s; s++) + { + const char *slash; + + for (slash = s; *slash == '\\'; slash++); + + if (slash > s) + { + g_string_append_len(command, s, slash - s); + + if (!*slash || *slash == '"') + { + g_string_append_len(command, s, slash - s); + + if (!*slash) + break; + } + + s = slash; + } + + if (*s == '"') + g_string_append_c(command, '\\'); + + g_string_append_c(command, *s); + } + + g_string_append_c(command, '"'); + } +} + + +static void spawn_close_pid(GPid pid, G_GNUC_UNUSED gint status, G_GNUC_UNUSED gpointer data) +{ + g_spawn_close_pid(pid); +} +#endif /* G_OS_WIN32 */ + + +/** + * Executes a child program asynchronously and setups pipes. + * + * This is the low-level spawning function. Please use @c spawn_with_callbacks() unless + * you need to setup specific event source(s). + * + * A command line or an argument vector must be passed. If both are present, the argument + * vector is appended to the command line. An empty command line is not allowed. + * + * Under Windows, if the child is a console application, and at least one file descriptor is + * specified, the new child console (if any) will be hidden. + * + * If a @a child_pid is passed, it's your responsibility to invoke @c g_spawn_close_pid(). + * + * @param working_directory child's current working directory, or @c NULL. + * @param command_line child program and arguments, or @c NULL. + * @param argv child's argument vector, or @c NULL. + * @param envp child's environment, or @c NULL. + * @param child_pid return location for child process ID, or @c NULL. + * @param stdin_fd return location for file descriptor to write to child's stdin, or @c NULL. + * @param stdout_fd return location for file descriptor to read child's stdout, or @c NULL. + * @param stderr_fd return location for file descriptor to read child's stderr, or @c NULL. + * @param error return location for error. + * + * @return @c TRUE on success, @c FALSE on error. + **/ +gboolean spawn_async_with_pipes(const gchar *working_directory, const gchar *command_line, + gchar **argv, gchar **envp, GPid *child_pid, gint *stdin_fd, gint *stdout_fd, + gint *stderr_fd, GError **error) +{ + g_return_val_if_fail(command_line != NULL || argv != NULL, FALSE); + + if (command_line && !spawn_check_command(command_line, FALSE, error)) + return FALSE; + +#ifdef G_OS_WIN32 + GString *command; + GArray *environment = g_array_new(TRUE, FALSE, sizeof(char)); + GPid pid; + gchar *failure; + + while (command_line && strchr(CL_BLANKS, *command_line)) + command_line++; + + command = g_string_new(command_line); + + while (argv && *argv) + spawn_append_argument(command, *argv++); + +#ifdef SPAWN_TEST + g_message("full spawn command line: %s\n", command->str); +#endif + + while (envp && *envp) + { + g_array_append_vals(environment, *envp, strlen(*envp) + 1); + envp++; + } + + failure = spawn_create_process_with_pipes(command->str, working_directory, + envp ? environment->data : NULL, child_pid ? child_pid : &pid, + stdin_fd, stdout_fd, stderr_fd); + + g_string_free(command, TRUE); + g_array_free(environment, TRUE); + + if (failure) + { + g_set_error(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "%s", failure); + g_free(failure); + return FALSE; + } + else if (!child_pid) + g_child_watch_add(pid, spawn_close_pid, NULL); + + return TRUE; +#else /* G_OS_WIN32 */ + int cl_argc; + char **full_argv; + gboolean spawned; + + if (command_line) + { + int argc = 0; + char **cl_argv; + + if (!g_shell_parse_argv(command_line, &cl_argc, &cl_argv, error)) + return FALSE; + + if (argv) + for (argc = 0; argv[argc]; argc++); + + full_argv = g_renew(gchar *, cl_argv, cl_argc + argc + 1); + memcpy(full_argv + cl_argc, argv, argc * sizeof(gchar *)); + full_argv[cl_argc + argc] = NULL; + } + else + full_argv = argv; + + spawned = g_spawn_async_with_pipes(working_directory, full_argv, envp, + G_SPAWN_SEARCH_PATH | (child_pid ? G_SPAWN_DO_NOT_REAP_CHILD : 0), NULL, NULL, + child_pid, stdin_fd, stdout_fd, stderr_fd, error); + + if (full_argv != argv) + { + full_argv[cl_argc] = NULL; + g_strfreev(full_argv); + } + + return spawned; +#endif /* G_OS_WIN32 */ +} + + +/** + * Executes a child asynchronously. + * + * See @c spawn_async_with_pipes() for a full description; this function simply calls + * @c g_spawn_async_with_pipes() without any pipes. + */ +gboolean spawn_async(const gchar *working_directory, const gchar *command_line, gchar **argv, + gchar **envp, GPid *child_pid, GError **error) +{ + return spawn_async_with_pipes(working_directory, command_line, argv, envp, child_pid, + NULL, NULL, NULL, error); +} + + +/* + * Spawn with callbacks - general event sequence: + * + * - Launch the child. + * - Setup any I/O callbacks and a child watch callback. + * - On sync execution, run a main loop. + * - Wait for the child to terminate. + * - Check for active I/O sources. If any, add a timeout source to watch them, they should + * become inactive real soon now that the child is dead. Otherwise, finalize immediately. + * - In the timeout source: check for active I/O sources and finalize if none. + */ + +typedef struct _SpawnChannelData +{ + GIOChannel *channel; /* NULL if not created / already destroyed */ + union + { + GIOFunc write; + SpawnReadFunc read; + } cb; + gpointer cb_data; + /* stdout/stderr only */ + GString *buffer; /* NULL if recursive */ + GString *line_buffer; /* NULL if char buffered */ + gsize max_length; +} SpawnChannelData; + + +static void spawn_destroy_cb(gpointer data) +{ + SpawnChannelData *sc = (SpawnChannelData *) data; + + g_io_channel_shutdown(sc->channel, FALSE, NULL); + sc->channel = NULL; + + if (sc->buffer) + g_string_free(sc->buffer, TRUE); + + if (sc->line_buffer) + g_string_free(sc->line_buffer, TRUE); +} + + +static gboolean spawn_write_cb(GIOChannel *channel, GIOCondition condition, gpointer data) +{ + SpawnChannelData *sc = (SpawnChannelData *) data; + + if (!sc->cb.write(channel, condition, sc->cb_data)) + return FALSE; + + return !(condition & G_IO_FAILURE); +} + + +static gboolean spawn_read_cb(GIOChannel *channel, GIOCondition condition, gpointer data) +{ + SpawnChannelData *sc = (SpawnChannelData *) data; + GString *line_buffer = sc->line_buffer; + GString *buffer = sc->buffer ? sc->buffer : g_string_sized_new(sc->max_length); + GIOCondition failure = condition & G_IO_FAILURE; + /* + * - Normally, read only once. With IO watches, our data processing must be immediate, + * which may give the child time to emit more data, and a read loop may combine it into + * large stdout and stderr portions. Under Windows, looping blocks. + * - On failure, read in a loop. It won't block now, there will be no more data, and the + * IO watch is not guaranteed to be called again (under Windows this is the last call). + */ + if (condition & (G_IO_IN | G_IO_PRI)) + { + gsize chars_read; + + if (line_buffer) + { + gsize n = line_buffer->len; + + while ((g_io_channel_read_chars(channel, line_buffer->str + n, + DEFAULT_IO_LENGTH, &chars_read, NULL) == G_IO_STATUS_NORMAL)) + { + g_string_set_size(line_buffer, n + chars_read); + + while (n < line_buffer->len) + { + gsize line_len = 0; + + if (n == sc->max_length) + line_len = n; + else if (strchr("\n", line_buffer->str[n])) /* '\n' or '\0' */ + line_len = n + 1; + else if (n < line_buffer->len - 1 && line_buffer->str[n] == '\r') + line_len = n + 1 + (line_buffer->str[n + 1] == '\n'); + + if (!line_len) + n++; + else + { + g_string_append_len(buffer, line_buffer->str, line_len); + g_string_erase(line_buffer, 0, line_len); + /* data only, failures are reported separately below */ + sc->cb.read(buffer, condition & (G_IO_IN | G_IO_PRI), + sc->cb_data); + g_string_truncate(buffer, 0); + n = 0; + } + } + + if (!failure) + break; + } + } + else + { + while (g_io_channel_read_chars(channel, buffer->str, sc->max_length, + &chars_read, NULL) == G_IO_STATUS_NORMAL) + { + g_string_set_size(buffer, chars_read); + /* data only, failures are reported separately below */ + sc->cb.read(buffer, condition & (G_IO_IN | G_IO_PRI), sc->cb_data); + + if (!failure) + break; + } + } + } + + if (failure) /* we must signal the callback */ + { + if (line_buffer && line_buffer->len) /* flush the line buffer */ + { + g_string_append_len(buffer, line_buffer->str, line_buffer->len); + /* all data may be from a previous call */ + if (!(condition & (G_IO_IN | G_IO_PRI))) + condition |= G_IO_IN; + } + else + { + condition &= ~(G_IO_IN | G_IO_PRI); + g_string_truncate(buffer, 0); + } + + sc->cb.read(buffer, condition, sc->cb_data); + } + + if (buffer != sc->buffer) + g_string_free(buffer, TRUE); + + return !failure; +} + + +typedef struct _SpawnWatcherData +{ + SpawnChannelData sc[3]; /* stdin, stdout, stderr */ + GChildWatchFunc exit_cb; + gpointer exit_data; + GPid pid; + gint exit_status; + GMainContext *main_context; /* NULL if async execution */ + GMainLoop *main_loop; /* NULL if async execution */ +} SpawnWatcherData; + + +static void spawn_finalize(SpawnWatcherData *sw) +{ + if (sw->exit_cb) + sw->exit_cb(sw->pid, sw->exit_status, sw->exit_data); + + if (sw->main_loop) + { + g_main_loop_quit(sw->main_loop); + g_main_loop_unref(sw->main_loop); + } + + g_spawn_close_pid(sw->pid); + g_slice_free(SpawnWatcherData, sw); +} + + +static gboolean spawn_timeout_cb(gpointer data) +{ + SpawnWatcherData *sw = (SpawnWatcherData *) data; + int i; + + for (i = 0; i < 3; i++) + if (sw->sc[i].channel) + return TRUE; + + spawn_finalize(sw); + return FALSE; +} + + +static void spawn_watch_cb(GPid pid, gint status, gpointer data) +{ + SpawnWatcherData *sw = (SpawnWatcherData *) data; + int i; + + sw->pid = pid; + sw->exit_status = status; + + for (i = 0; i < 3; i++) + { + if (sw->sc[i].channel) + { + GSource *source = g_timeout_source_new(50); + + g_source_set_callback(source, spawn_timeout_cb, data, NULL); + g_source_attach(source, sw->main_context); + g_source_unref(source); + return; + } + } + + spawn_finalize(sw); +} + + +/** + * Executes a child program and setups callbacks. + * + * A command line or an argument vector must be passed. If both are present, the argument + * vector is appended to the command line. An empty command line is not allowed. + * + * The synchronous execution may not be combined with recursive callbacks. + * + * In line buffered mode, the child input is broken on '\n', "\r\n", '\r', '\0' and max length. + * + * All I/O callbacks are guaranteed to be invoked at least once with @c G_IO_ERR, @c G_IO_HUP + * or @c G_IO_NVAL set (except for a @a stdin_cb which returns @c FALSE before that). For the + * non-recursive callbacks, this is guaranteed to be the last call, and may be used to free any + * resources associated with the callback. + * + * The @a stdin_cb may write to @c channel only once per invocation, only if @c G_IO_OUT is + * set, and only a non-zero number of characters. + * + * @c stdout_cb and @c stderr_cb may modify the received strings in any way, but must not + * free them. + * + * The default max lengths are 24K for line buffered stdout, 8K for line buffered stderr, + * 4K for unbuffered input under Unix, and 2K for unbuffered input under Windows. + * + * @c exit_cb is always invoked last, after all I/O callbacks. + * + * The @a child_pid will be closed automatically, after @a exit_cb is invoked. + * + * @param working_directory child's current working directory, or @c NULL. + * @param command_line child program and arguments, or @c NULL. + * @param argv child's argument vector, or @c NULL. + * @param envp child's environment, or @c NULL. + * @param spawn_flags flags from SpawnFlags. + * @param stdin_cb callback to send data to childs's stdin, or @c NULL. + * @param stdin_data data to pass to @a stdin_cb. + * @param stdout_cb callback to receive child's stdout, or @c NULL. + * @param stdout_data data to pass to @a stdout_cb. + * @param stdout_max_length maximum data length to pass to stdout_cb, @c 0 = default. + * @param stderr_cb callback to receive child's stderr, or @c NULL. + * @param stderr_data data to pass to @a stderr_cb. + * @param stderr_max_length maximum data length to pass to stderr_cb, @c 0 = default. + * @param exit_cb callback to invoke when the child exits, or @c NULL. + * @param exit_data data to pass to @a exit_cb. + * @param child_pid return location for child process ID, or @c NULL. + * @param error return location for error. + * + * @return @c TRUE on success, @c FALSE on error. + **/ +gboolean spawn_with_callbacks(const gchar *working_directory, const gchar *command_line, + gchar **argv, gchar **envp, SpawnFlags spawn_flags, GIOFunc stdin_cb, gpointer stdin_data, + SpawnReadFunc stdout_cb, gpointer stdout_data, gsize stdout_max_length, + SpawnReadFunc stderr_cb, gpointer stderr_data, gsize stderr_max_length, + GChildWatchFunc exit_cb, gpointer exit_data, GPid *child_pid, GError **error) +{ + GPid pid; + int pipe[3] = { -1, -1, -1 }; + + g_return_val_if_fail(!(spawn_flags & SPAWN_RECURSIVE) || !(spawn_flags & SPAWN_SYNC), + FALSE); + + if (spawn_async_with_pipes(working_directory, command_line, argv, envp, &pid, + stdin_cb ? &pipe[0] : NULL, stdout_cb ? &pipe[1] : NULL, + stderr_cb ? &pipe[2] : NULL, error)) + { + SpawnWatcherData *sw = g_slice_new0(SpawnWatcherData); + gpointer cb_data[3] = { stdin_data, stdout_data, stderr_data }; + GSource *source; + int i; + + sw->main_context = spawn_flags & SPAWN_SYNC ? g_main_context_new() : NULL; + + if (child_pid) + *child_pid = pid; + + for (i = 0; i < 3; i++) + { + SpawnChannelData *sc = &sw->sc[i]; + GIOCondition condition; + GSourceFunc callback; + + if (pipe[i] == -1) + continue; + + #ifdef G_OS_WIN32 + sc->channel = g_io_channel_win32_new_fd(pipe[i]); + #else + sc->channel = g_io_channel_unix_new(pipe[i]); + g_io_channel_set_flags(sc->channel, G_IO_FLAG_NONBLOCK, NULL); + #endif + g_io_channel_set_encoding(sc->channel, NULL, NULL); + /* we have our own buffers, and GIO buffering blocks under Windows */ + g_io_channel_set_buffered(sc->channel, FALSE); + sc->cb_data = cb_data[i]; + + if (i == 0) + { + sc->cb.write = stdin_cb; + condition = G_IO_OUT | G_IO_FAILURE; + callback = (GSourceFunc) spawn_write_cb; + } + else + { + gboolean line_buffered = !(spawn_flags & + ((SPAWN_STDOUT_UNBUFFERED >> 1) << i)); + + condition = G_IO_IN | G_IO_PRI | G_IO_FAILURE; + callback = (GSourceFunc) spawn_read_cb; + + if (i == 1) + { + sc->cb.read = stdout_cb; + sc->max_length = stdout_max_length ? stdout_max_length : + line_buffered ? 24576 : DEFAULT_IO_LENGTH; + } + else + { + sc->cb.read = stderr_cb; + sc->max_length = stderr_max_length ? stderr_max_length : + line_buffered ? 8192 : DEFAULT_IO_LENGTH; + } + + if (line_buffered) + { + sc->line_buffer = g_string_sized_new(sc->max_length + + DEFAULT_IO_LENGTH); + } + } + + source = g_io_create_watch(sc->channel, condition); + g_io_channel_unref(sc->channel); + + if (spawn_flags & (SPAWN_STDIN_RECURSIVE << i)) + g_source_set_can_recurse(source, TRUE); + else if (i) /* to avoid new string on each call */ + sc->buffer = g_string_sized_new(sc->max_length); + + g_source_set_callback(source, callback, sc, spawn_destroy_cb); + g_source_attach(source, sw->main_context); + g_source_unref(source); + } + + sw->exit_cb = exit_cb; + sw->exit_data = exit_data; + source = g_child_watch_source_new(pid); + g_source_set_callback(source, (GSourceFunc) spawn_watch_cb, sw, NULL); + g_source_attach(source, sw->main_context); + g_source_unref(source); + + if (spawn_flags & SPAWN_SYNC) + { + sw->main_loop = g_main_loop_new(sw->main_context, FALSE); + g_main_context_unref(sw->main_context); + g_main_loop_run(sw->main_loop); + } + + return TRUE; + } + + return FALSE; +} + + +/** + * Writes (a portion of) the data pointed by @a data->ptr to the @a channel. + * + * If @c G_IO_OUT in @a condition is set, and the @a data->size is > 0, attempts to write + * @a data->ptr (or a portion of it, depending on the size) to the @a channel. On success, + * increases ptr and decreases size with the number of characters written. + * + * This function may converted to @c GIOFunc and passed to @c spawn_with_callbacks() as + * @c stdin_cb, together with a @c SpawnWriteData for @c stdin_data. As with any other + * callback data, make sure that @c stdin_data exists while the child is being executed. + * (For example, on asynchronous execution, you can allocate the data in the heap, and free + * it in your @c spawn_with_callbacks() @c exit_cb callback.) + * + * @return @c TRUE if the remaining size is > 0 and @a condition does not indicate any error, + * @c FALSE otherwise. + */ +gboolean spawn_write_data(GIOChannel *channel, GIOCondition condition, SpawnWriteData *data) +{ + if ((condition & G_IO_OUT) && data->size) + { + gsize chars_written = 0; + + g_io_channel_write_chars(channel, data->ptr, data->size < DEFAULT_IO_LENGTH ? + data->size : DEFAULT_IO_LENGTH, &chars_written, NULL); + + /* "This can be nonzero even if the return value is not G_IO_STATUS_NORMAL." */ + if (chars_written) + { + data->ptr += chars_written; + data->size -= chars_written; + } + } + + return data->size > 0 && !(condition & G_IO_FAILURE); +} + + +static void spawn_append_gstring_cb(GString *string, GIOCondition condition, gpointer data) +{ + if (condition & (G_IO_IN | G_IO_PRI)) + g_string_append_len((GString *) data, string->str, string->len); +} + + +/** + * Convinience @c GChildWatchFunc callback that copies the child exit status into a gint + * pointed by @a exit_status. + **/ +void spawn_get_exit_status_cb(G_GNUC_UNUSED GPid pid, gint status, gpointer exit_status) +{ + *(gint *) exit_status = status; +} + + +/** + * Executes a child synchronously. + * + * A command line or an argument vector must be passed. If both are present, the argument + * vector is appended to the command line. An empty command line is not allowed. + * + * The @a stdin_data is sent to the child with @c spawn_write_data(). + * + * All output from the child, including the nul characters, is stored in @a stdout_data and + * @a stderr_data (if non-NULL). Any existing data in these strings will be erased. + * + * @param working_directory child's current working directory, or @c NULL. + * @param command_line child program and arguments, or @c NULL. + * @param argv child's argument vector, or @c NULL. + * @param envp child's environment, or @c NULL. + * @param stdin_data data to send to childs's stdin, or @c NULL. + * @param stdout_data GString location to receive the child's stdout, or NULL. + * @param stderr_data GString location to receive the child's stderr, or NULL. + * @param exit_status return location for the child exit code, or NULL. + * @param error return location for error. + * + * @return @c TRUE on success, @c FALSE on error. + **/ +gboolean spawn_sync(const gchar *working_directory, const gchar *command_line, gchar **argv, + gchar **envp, SpawnWriteData *stdin_data, GString *stdout_data, GString *stderr_data, + gint *exit_status, GError **error) +{ + g_string_truncate(stdout_data, 0); + g_string_truncate(stderr_data, 0); + + return spawn_with_callbacks(working_directory, command_line, argv, envp, SPAWN_SYNC | + SPAWN_UNBUFFERED, stdin_data ? (GIOFunc) spawn_write_data : NULL, stdin_data, + stdout_data ? spawn_append_gstring_cb : NULL, stdout_data, 0, + stderr_data ? spawn_append_gstring_cb : NULL, stderr_data, 0, + exit_status ? spawn_get_exit_status_cb : NULL, exit_status, NULL, error); +} + + +/* tests, not part of the API */ +#ifdef SPAWN_TEST +#include <stdio.h> +#ifndef WIFEXITED +#include <sys/wait.h> /* WIFEXITED */ +#endif + + +static gboolean read_line(const char *prompt, char *buffer, size_t size) +{ + fputs(prompt, stderr); + *buffer = '\0'; + + if (fgets(buffer, size, stdin)) + { + char *s = strchr(buffer, '\n'); + + if (s) + *s = '\0'; + } + + return *buffer; +} + + +static GString *read_string(const char *prompt) +{ + char buffer[0x1000]; /* larger portions for spawn < file */ + GString *string = g_string_sized_new(sizeof buffer); + + while (read_line(prompt, buffer, sizeof buffer)) + { + if (string->len) + g_string_append_c(string, '\n'); + + g_string_append(string, buffer); + } + + if (!string->len) + { + g_string_free(string, TRUE); + string = NULL; + } + + return string; +} + + +static void print_cb(GString *string, GIOCondition condition, gpointer data) +{ + if (condition & (G_IO_IN | G_IO_PRI)) + { + gsize i; + + printf("%s: ", (const gchar *) data); + /*fputs(string->str, stdout);*/ + for (i = 0; i < string->len; i++) + { + unsigned char c = (unsigned char) string->str[i]; + printf(c >= ' ' && c < 0x80 ? "%c" : "\\x%02x", c); + } + putchar('\n'); + } +} + + +static void print_status(gint status) +{ + fputs("finished, ", stderr); + + if (WIFEXITED(status)) + fprintf(stderr, "exit code %d\n", WEXITSTATUS(status)); + else + fputs("abnormal termination\n", stderr); +} + + +static void exit_cb(GPid pid, gint status, G_GNUC_UNUSED gpointer data) +{ + fprintf(stderr, "process %u ", (guint) pid); + print_status(status); +} + + +static void watch_cb(GPid pid, gint status, gpointer data) +{ + g_spawn_close_pid(pid); + exit_cb(pid, status, NULL); + g_main_loop_quit((GMainLoop *) data); +} + + +int main(int argc, char **argv) +{ + char *test_type; + + if (argc < 2) + { + fputs("usage: spawn <test-type>\n", stderr); + return 1; + } + + test_type = argv[1]; + + if (!strcmp(test_type, "syntax") || !strcmp(test_type, "syntexec")) + { + char command_line[0x100]; + + while (read_line("command line: ", command_line, sizeof command_line)) + { + GError *error = NULL; + + if (spawn_check_command(command_line, argv[1][4] == 'e', &error)) + fputs("valid\n", stderr); + else + { + fprintf(stderr, "error: %s\n", error->message); + g_error_free(error); + } + } + } + else if (!strcmp(test_type, "execute")) + { + char command_line[0x100]; + + while (read_line("command line: ", command_line, sizeof command_line)) + { + char args[4][0x100]; + char envs[4][0x100]; + char *argv[] = { args[0], args[1], args[2], args[3], NULL }; + char *envp[] = { envs[0], envs[1], envs[2], envs[3], NULL }; + int i; + GPid pid; + GError *error = NULL; + + fputs("up to 4 arguments\n", stderr); + for (i = 0; i < 4 && read_line("argument: ", args[i], sizeof args[i]); i++); + argv[i] = NULL; + + fputs("up to 4 variables, or empty line for parent environment\n", stderr); + for (i = 0; i < 4 && read_line("variable: ", envs[i], sizeof envs[i]); i++); + envp[i] = NULL; + + if (spawn_async_with_pipes(NULL, *command_line ? command_line : NULL, argv, + i ? envp : NULL, &pid, NULL, NULL, NULL, &error)) + { + GMainLoop *loop = g_main_loop_new(NULL, TRUE); + + g_child_watch_add(pid, watch_cb, loop); + g_main_loop_run(loop); + g_main_loop_unref(loop); + } + else + { + fprintf(stderr, "error: %s\n", error->message); + g_error_free(error); + } + } + } + else if (!strcmp(test_type, "redirect") || !strcmp(test_type, "redinput")) + { + char command_line[0x100]; + gboolean output = test_type[4] == 'r'; + + while (read_line("command line: ", command_line, sizeof command_line)) + { + GString *stdin_text = read_string("text to send: "); + SpawnWriteData stdin_data; + GError *error = NULL; + + if (stdin_text) + { + stdin_data.ptr = stdin_text->str; + stdin_data.size = stdin_text->len; + } + + if (!spawn_with_callbacks(NULL, command_line, NULL, NULL, SPAWN_SYNC, + stdin_text ? (GIOFunc) spawn_write_data : NULL, &stdin_data, + output ? print_cb : NULL, "stdout", 0, output ? print_cb : NULL, + "stderr", 0, exit_cb, NULL, NULL, &error)) + { + fprintf(stderr, "error: %s\n", error->message); + g_error_free(error); + } + + if (stdin_text) + g_string_free(stdin_text, TRUE); + } + } + else if (!strcmp(test_type, "capture")) + { + char command_line[0x100]; + + while (read_line("command line: ", command_line, sizeof command_line)) + { + GString *stdin_text = read_string("text to send: "); + SpawnWriteData stdin_data = { NULL, 0 }; + GString *stdout_data = g_string_sized_new(0x10000); /* may grow */ + GString *stderr_data = g_string_sized_new(0x1000); /* may grow */ + gint exit_status; + GError *error = NULL; + + if (stdin_text) + { + stdin_data.ptr = stdin_text->str; + stdin_data.size = stdin_text->len; + } + + if (spawn_sync(NULL, command_line, NULL, NULL, &stdin_data, stdout_data, + stderr_data, &exit_status, &error)) + { + printf("stdout: %s\n", stdout_data->str); + printf("stderr: %s\n", stderr_data->str); + print_status(exit_status); + } + else + { + fprintf(stderr, "error: %s\n", error->message); + g_error_free(error); + } + + if (stdin_text) + g_string_free(stdin_text, TRUE); + + g_string_free(stdout_data, TRUE); + g_string_free(stderr_data, TRUE); + } + } + else + { + fprintf(stderr, "spawn: unknown test type '%s'", argv[1]); + return 1; + } + + return 0; +} +#endif /* SPAWN_TEST */ Modified: src/spawn.h 102 lines changed, 102 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,102 @@ +/* + * spawn.h - this file is part of Geany, a fast and lightweight IDE + * + * Copyright 2013 Dimitar Toshkov Zhekov <dimitar(dot)zhekov(at)gmail(dot)com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + + +#ifndef GEANY_SPAWN_H +#define GEANY_SPAWN_H 1 + +#include <glib.h> + +gboolean spawn_check_command(const gchar *command_line, gboolean execute, GError **error); + +gboolean spawn_kill_process(GPid pid, GError **error); + +gboolean spawn_async_with_pipes(const gchar *working_directory, const gchar *command_line, + gchar **argv, gchar **envp, GPid *child_pid, gint *stdin_fd, gint *stdout_fd, + gint *stderr_fd, GError **error); + +gboolean spawn_async(const gchar *working_directory, const gchar *command_line, gchar **argv, + gchar **envp, GPid *child_pid, GError **error); + +/** Flags passed to @c spawn_with_callbacks(), which see. */ +typedef enum +{ + SPAWN_ASYNC = 0x00, /**< Asynchronous execution [default]. */ + SPAWN_SYNC = 0x01, /**< Synchronous execution. */ + /* buffering modes */ + SPAWN_LINE_BUFFERED = 0x00, /**< stdout/stderr are line buffered [default]. */ + SPAWN_STDOUT_UNBUFFERED = 0x02, /**< stdout is not buffered. */ + SPAWN_STDERR_UNBUFFERED = 0x04, /**< stderr is not buffered. */ + SPAWN_UNBUFFERED = 0x06, /**< stdout/stderr are line buffered. */ + /* recursive modes */ + SPAWN_STDIN_RECURSIVE = 0x08, /**< The stdin callback is recursive. */ + SPAWN_STDOUT_RECURSIVE = 0x10, /**< The stdout callback is recursive. */ + SPAWN_STDERR_RECURSIVE = 0x20, /**< The stderr callback is recursive. */ + SPAWN_RECURSIVE = 0x38 /**< All callbacks are recursive. */ +} SpawnFlags; + +/** + * Specifies the type of function passed to @c spawn_with_callbacks() as stdout or stderr + * callback. + * + * In unbuffered mode, the @a string may contain nuls, while in line buffered mode, it may + * contain only a single nul as a line termination character at @a string->len - 1. In all + * cases, the @a string will be terminated with a nul character that is not part of the data + * at @a string->len. + * + * If @c G_IO_IN or @c G_IO_PRI are set, the @a string will contain at least one character. + * + * @param string contains the child data if @c G_IO_IN or @c G_IO_PRI are set. + * @param condition the I/O condition which has been satisfied. + * @param data the passed to @c spawn_with_callbacks() with the callback. + */ +typedef void (*SpawnReadFunc)(GString *string, GIOCondition condition, gpointer data); + +gboolean spawn_with_callbacks(const gchar *working_directory, const gchar *command_line, + gchar **argv, gchar **envp, SpawnFlags spawn_flags, GIOFunc stdin_cb, gpointer stdin_data, + SpawnReadFunc stdout_cb, gpointer stdout_data, gsize stdout_max_length, + SpawnReadFunc stderr_cb, gpointer stderr_data, gsize stderr_max_length, + GChildWatchFunc exit_cb, gpointer exit_data, GPid *child_pid, GError **error); + +/** + * A simple structure used by @c spawn_write_data() to write data to a channel. + * See @c spawn_write_data() for more information. + */ +typedef struct _SpawnWriteData +{ + const gchar *ptr; /**< Pointer to the data. May be NULL if the size is 0. */ + gsize size; /**< Size of the data. */ +} SpawnWriteData; + +gboolean spawn_write_data(GIOChannel *channel, GIOCondition condition, SpawnWriteData *data); + +void spawn_get_exit_status_cb(GPid pid, gint status, gpointer exit_status); + +gboolean spawn_sync(const gchar *working_directory, const gchar *command_line, gchar **argv, + gchar **envp, SpawnWriteData *stdin_data, GString *stdout_data, GString *stderr_data, + gint *exit_status, GError **error); + +#ifdef G_OS_WIN32 +#define WIFEXITED(status) TRUE +#define WEXITSTATUS(status) (status) +#define WIFSIGNALLED(status) FALSE +#endif /* G_OS_WIN32 */ + +#endif /* GEANY_SPAWN_H */ Modified: wscript 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -133,7 +133,7 @@ geany_sources = set([ 'src/highlighting.c', 'src/keybindings.c', 'src/keyfile.c', 'src/log.c', 'src/main.c', 'src/msgwindow.c', 'src/navqueue.c', 'src/notebook.c', 'src/osx.c', 'src/plugins.c', 'src/pluginutils.c', 'src/prefix.c', 'src/prefs.c', 'src/printing.c', 'src/project.c', - 'src/sciwrappers.c', 'src/search.c', 'src/socket.c', 'src/stash.c', + 'src/sciwrappers.c', 'src/search.c', 'src/socket.c', 'src/spawn.c', 'src/stash.c', 'src/symbols.c', 'src/templates.c', 'src/toolbar.c', 'src/tools.c', 'src/sidebar.c', 'src/ui_utils.c', 'src/utils.c']) -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] a3f417: Alter templates.c to use the new spawning module
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Sat, 21 Mar 2015 17:36:14 UTC Commit: a3f4170a4bd503e26208a5eb5dbab93b4761fbfe https://github.com/geany/geany/commit/a3f4170a4bd503e26208a5eb5dbab93b4761f… Log Message: ----------- Alter templates.c to use the new spawning module Modified Paths: -------------- src/templates.c Modified: src/templates.c 44 lines changed, 22 insertions(+), 22 deletions(-) =================================================================== @@ -37,6 +37,7 @@ #include "geany.h" #include "geanymenubuttonaction.h" #include "geanyobject.h" +#include "spawn.h" #include "support.h" #include "toolbar.h" #include "ui_utils.h" @@ -594,33 +595,32 @@ static void templates_replace_default_dates(GString *text) static gchar *run_command(const gchar *command, const gchar *file_name, const gchar *file_type, const gchar *func_name) { + GString *output = g_string_new(NULL); gchar *result = NULL; - gchar **argv; + GError *error = NULL; + gchar **env; - if (g_shell_parse_argv(command, NULL, &argv, NULL)) - { - GError *error = NULL; - gchar **env; + file_name = (file_name != NULL) ? file_name : ""; + file_type = (file_type != NULL) ? file_type : ""; + func_name = (func_name != NULL) ? func_name : ""; - file_name = (file_name != NULL) ? file_name : ""; - file_type = (file_type != NULL) ? file_type : ""; - func_name = (func_name != NULL) ? func_name : ""; + env = utils_copy_environment(NULL, + "GEANY_FILENAME", file_name, + "GEANY_FILETYPE", file_type, + "GEANY_FUNCNAME", func_name, + NULL); - env = utils_copy_environment(NULL, - "GEANY_FILENAME", file_name, - "GEANY_FILETYPE", file_type, - "GEANY_FUNCNAME", func_name, - NULL); - if (! utils_spawn_sync(NULL, argv, env, G_SPAWN_SEARCH_PATH, - NULL, NULL, &result, NULL, NULL, &error)) - { - g_warning("templates_replace_command: %s", error->message); - g_error_free(error); - result = NULL; - } - g_strfreev(argv); - g_strfreev(env); + if (spawn_sync(NULL, command, NULL, env, NULL, output, NULL, NULL, &error)) + { + result = g_string_free(output, FALSE); } + else + { + g_warning("templates_replace_command: %s", error->message); + g_error_free(error); + } + + g_strfreev(env); return result; } -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 353b74: Alter callbacks.c to use the new spawning module
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Sat, 21 Mar 2015 17:45:38 UTC Commit: 353b748cf75b29d3d342757759d220d9f47aa563 https://github.com/geany/geany/commit/353b748cf75b29d3d342757759d220d9f47aa… Log Message: ----------- Alter callbacks.c to use the new spawning module Modified Paths: -------------- src/callbacks.c Modified: src/callbacks.c 3 lines changed, 2 insertions(+), 1 deletions(-) =================================================================== @@ -51,6 +51,7 @@ #include "printing.h" #include "sciwrappers.h" #include "sidebar.h" +#include "spawn.h" #ifdef HAVE_SOCKET # include "socket.h" #endif @@ -1554,7 +1555,7 @@ G_MODULE_EXPORT void on_context_action1_activate(GtkMenuItem *menuitem, gpointer { utils_str_replace_all(&command, "%s", word); - if (! g_spawn_command_line_async(command, &error)) + if (!spawn_async(NULL, command, NULL, NULL, NULL, &error)) { ui_set_statusbar(TRUE, "Context action command failed: %s", error->message); g_error_free(error); -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 74171c: Alter search.c to use the new spawning module
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Thu, 19 Mar 2015 18:03:33 UTC Commit: 74171cca5026e915e68b55f420b986b266ddcf7f https://github.com/geany/geany/commit/74171cca5026e915e68b55f420b986b266ddc… Log Message: ----------- Alter search.c to use the new spawning module Also enabled the Grep tool setting to be used as a command line, instead of an executable name only, and fixed a small bug where the search text displayed in Messages was re-utf8-ed. Modified Paths: -------------- src/search.c Modified: src/search.c 162 lines changed, 61 insertions(+), 101 deletions(-) =================================================================== @@ -37,6 +37,7 @@ #include "msgwindow.h" #include "prefs.h" #include "sciwrappers.h" +#include "spawn.h" #include "stash.h" #include "support.h" #include "toolbar.h" @@ -149,10 +150,10 @@ static struct fif_dlg = {NULL, NULL, NULL, NULL, NULL, NULL, {0, 0}}; -static gboolean search_read_io(GIOChannel *source, GIOCondition condition, gpointer data); -static gboolean search_read_io_stderr(GIOChannel *source, GIOCondition condition, gpointer data); +static void search_read_io(GString *string, GIOCondition condition, gpointer data); +static void search_read_io_stderr(GString *string, GIOCondition condition, gpointer data); -static void search_close_pid(GPid child_pid, gint status, gpointer user_data); +static void search_finished(GPid child_pid, gint status, gpointer user_data); static gchar **search_get_argv(const gchar **argv_prefix, const gchar *dir); @@ -1647,13 +1648,10 @@ static gboolean search_find_in_files(const gchar *utf8_search_text, const gchar *dir, const gchar *opts, const gchar *enc) { - gchar **argv_prefix, **argv, **opts_argv; - gchar *command_grep; + gchar **argv_prefix = g_new(gchar*, 3); + gchar *command_grep, *command_line; + gchar **argv; gchar *search_text = NULL; - gint opts_argv_len, i; - GPid child_pid; - gint stdout_fd; - gint stderr_fd; GError *error = NULL; gboolean ret = FALSE; gssize utf8_text_len; @@ -1662,18 +1660,11 @@ search_find_in_files(const gchar *utf8_search_text, const gchar *dir, const gcha command_grep = g_find_program_in_path(tool_prefs.grep_cmd); if (command_grep == NULL) + command_line = g_strdup_printf("%s %s --", tool_prefs.grep_cmd, opts); + else { - ui_set_statusbar(TRUE, _("Cannot execute grep tool '%s';" - " check the path setting in Preferences."), tool_prefs.grep_cmd); - return FALSE; - } - - if (! g_shell_parse_argv(opts, &opts_argv_len, &opts_argv, &error)) - { - ui_set_statusbar(TRUE, _("Cannot parse extra options: %s"), error->message); - g_error_free(error); + command_line = g_strdup_printf("\"%s\" %s --", command_grep, opts); g_free(command_grep); - return FALSE; } /* convert the search text in the preferred encoding (if the text is not valid UTF-8. assume @@ -1686,74 +1677,58 @@ search_find_in_files(const gchar *utf8_search_text, const gchar *dir, const gcha if (search_text == NULL) search_text = g_strdup(utf8_search_text); - /* set grep command and options */ - argv_prefix = g_new0(gchar*, 1 + opts_argv_len + 3 + 1); /* last +1 for recursive arg */ - - argv_prefix[0] = command_grep; - for (i = 0; i < opts_argv_len; i++) - { - argv_prefix[i + 1] = g_strdup(opts_argv[i]); - } - g_strfreev(opts_argv); - - i++; /* correct for tool_prefs.grep_cmd */ - argv_prefix[i++] = g_strdup("--"); - argv_prefix[i++] = search_text; + argv_prefix[0] = search_text; /* finally add the arguments(files to be searched) */ - if (strstr(argv_prefix[1], "r")) /* recursive option set */ + if (settings.fif_recursive) /* recursive option set */ { /* Use '.' so we get relative paths in the output */ - argv_prefix[i++] = g_strdup("."); - argv_prefix[i++] = NULL; + argv_prefix[1] = g_strdup("."); + argv_prefix[2] = NULL; argv = argv_prefix; } else { - argv_prefix[i++] = NULL; + argv_prefix[1] = NULL; argv = search_get_argv((const gchar**)argv_prefix, dir); g_strfreev(argv_prefix); - } - if (argv == NULL) /* no files */ - { - return FALSE; + if (argv == NULL) /* no files */ + { + g_free(command_line); + return FALSE; + } } gtk_list_store_clear(msgwindow.store_msg); gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_MESSAGE); - if (! g_spawn_async_with_pipes(dir, (gchar**)argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD, - NULL, NULL, &child_pid, - NULL, &stdout_fd, &stderr_fd, &error)) - { - geany_debug("%s: g_spawn_async_with_pipes() failed: %s", G_STRFUNC, error->message); - ui_set_statusbar(TRUE, _("Process failed (%s)"), error->message); - g_error_free(error); - ret = FALSE; + /* we can pass 'enc' without strdup'ing it here because it's a global const string and + * always exits longer than the lifetime of this function */ + if (spawn_with_callbacks(dir, command_line, argv, NULL, 0, NULL, NULL, search_read_io, + (gpointer) enc, 0, search_read_io_stderr, (gpointer) enc, 0, search_finished, NULL, + NULL, &error)) + { + gchar *utf8_command_line = utils_get_utf8_from_locale(command_line); + gchar *utf8_dir = utils_get_utf8_from_locale(dir); + gchar *utf8_str; + + ui_progress_bar_start(_("Searching...")); + msgwin_set_messages_dir(dir); + utf8_str = g_strdup_printf(_("%s %s (in directory: %s)"), + utf8_command_line, utf8_search_text, utf8_dir); + msgwin_msg_add_string(COLOR_BLUE, -1, NULL, utf8_str); + utils_free_pointers(3, utf8_command_line, utf8_dir, utf8_str, NULL); + ret = TRUE; } else { - gchar *str, *utf8_str; - - ui_progress_bar_start(_("Searching...")); - - msgwin_set_messages_dir(dir); - /* we can pass 'enc' without strdup'ing it here because it's a global const string and - * always exits longer than the lifetime of this function */ - utils_set_up_io_channel(stdout_fd, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, - TRUE, search_read_io, (gpointer) enc); - utils_set_up_io_channel(stderr_fd, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, - TRUE, search_read_io_stderr, (gpointer) enc); - g_child_watch_add(child_pid, search_close_pid, NULL); - - str = g_strdup_printf(_("%s %s -- %s (in directory: %s)"), - tool_prefs.grep_cmd, opts, utf8_search_text, dir); - utf8_str = utils_get_utf8_from_locale(str); - msgwin_msg_add_string(COLOR_BLUE, -1, NULL, utf8_str); - utils_free_pointers(2, str, utf8_str, NULL); - ret = TRUE; + geany_debug("%s: spawn_with_callbacks() failed: %s", G_STRFUNC, error->message); + ui_set_statusbar(TRUE, _("Process failed (%s)"), error->message); + g_error_free(error); } + + g_free(command_line); g_strfreev(argv); return ret; } @@ -1836,61 +1811,47 @@ static gchar **search_get_argv(const gchar **argv_prefix, const gchar *dir) } -static gboolean read_fif_io(GIOChannel *source, GIOCondition condition, gchar *enc, gint msg_color) +static void read_fif_io(gchar *msg, GIOCondition condition, gchar *enc, gint msg_color) { if (condition & (G_IO_IN | G_IO_PRI)) { - gchar *msg, *utf8_msg; - GIOStatus st; + gchar *utf8_msg = NULL; - while ((st = g_io_channel_read_line(source, &msg, NULL, NULL, NULL)) != G_IO_STATUS_ERROR && - st != G_IO_STATUS_EOF && msg) + g_strstrip(msg); + /* enc is NULL when encoding is set to UTF-8, so we can skip any conversion */ + if (enc != NULL) { - utf8_msg = NULL; - - g_strstrip(msg); - /* enc is NULL when encoding is set to UTF-8, so we can skip any conversion */ - if (enc != NULL) + if (! g_utf8_validate(msg, -1, NULL)) { - if (! g_utf8_validate(msg, -1, NULL)) - { - utf8_msg = g_convert(msg, -1, "UTF-8", enc, NULL, NULL, NULL); - } - if (utf8_msg == NULL) - utf8_msg = msg; + utf8_msg = g_convert(msg, -1, "UTF-8", enc, NULL, NULL, NULL); } - else + if (utf8_msg == NULL) utf8_msg = msg; + } + else + utf8_msg = msg; - msgwin_msg_add_string(msg_color, -1, NULL, utf8_msg); + msgwin_msg_add_string(msg_color, -1, NULL, utf8_msg); - if (utf8_msg != msg) - g_free(utf8_msg); - g_free(msg); - } - if (st == G_IO_STATUS_ERROR || st == G_IO_STATUS_EOF) - return FALSE; + if (utf8_msg != msg) + g_free(utf8_msg); } - if (condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) - return FALSE; - - return TRUE; } -static gboolean search_read_io(GIOChannel *source, GIOCondition condition, gpointer data) +static void search_read_io(GString *string, GIOCondition condition, gpointer data) { - return read_fif_io(source, condition, data, COLOR_BLACK); + return read_fif_io(string->str, condition, data, COLOR_BLACK); } -static gboolean search_read_io_stderr(GIOChannel *source, GIOCondition condition, gpointer data) +static void search_read_io_stderr(GString *string, GIOCondition condition, gpointer data) { - return read_fif_io(source, condition, data, COLOR_DARK_RED); + return read_fif_io(string->str, condition, data, COLOR_DARK_RED); } -static void search_close_pid(GPid child_pid, gint status, gpointer user_data) +static void search_finished(GPid child_pid, gint status, gpointer user_data) { const gchar *msg = _("Search failed."); #ifdef G_OS_UNIX @@ -1931,7 +1892,6 @@ static void search_close_pid(GPid child_pid, gint status, gpointer user_data) break; } utils_beep(); - g_spawn_close_pid(child_pid); ui_progress_bar_stop(); } -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 05415e: Unify the build command spawning
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Mon, 16 Mar 2015 20:10:30 UTC Commit: 05415e53b63c89e104e93bc729bb8b3344d61525 https://github.com/geany/geany/commit/05415e53b63c89e104e93bc729bb8b3344d61… Log Message: ----------- Unify the build command spawning Also, don't check build_spawn_cmd() cmd argument under Unix, since it may be valid shell command rejected by glib g_shell_parse_argv(). Modified Paths: -------------- src/build.c Modified: src/build.c 21 lines changed, 9 insertions(+), 12 deletions(-) =================================================================== @@ -731,10 +731,7 @@ static gchar *build_replace_placeholder(const GeanyDocument *doc, const gchar *s static void build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *dir) { GError *error = NULL; -#ifdef G_OS_UNIX - /* under Unix, start cmd via sh for compatibility */ gchar *argv[] = { "/bin/sh", "-c", (gchar *) cmd, NULL }; -#endif gchar *working_dir; gchar *utf8_working_dir; gchar *utf8_cmd_string; @@ -761,21 +758,21 @@ static void build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *d g_free(utf8_working_dir); g_free(utf8_cmd_string); +#ifdef G_OS_UNIX + cmd = NULL; /* under Unix, use argv to start cmd via sh for compatibility */ +#else + argv[0] = NULL; /* under Windows, run cmd directly */ +#endif + /* set the build info for the message window */ g_free(build_info.dir); build_info.dir = g_strdup(working_dir); build_info.file_type_id = (doc == NULL) ? GEANY_FILETYPES_NONE : doc->file_type->id; build_info.message_count = 0; -#ifdef G_OS_WIN32 - if (!spawn_with_callbacks(working_dir, cmd, NULL, NULL, 0, NULL, NULL, build_iofunc, -#else - /* cmd is passed via argv, so check it explicitly */ - if (!spawn_check_command(cmd, FALSE, &error) || - !spawn_with_callbacks(working_dir, NULL, argv, NULL, 0, NULL, NULL, build_iofunc, -#endif - GINT_TO_POINTER(0), 0, build_iofunc, GINT_TO_POINTER(1), 0, build_exit_cb, - NULL, &build_info.pid, &error)) + if (!spawn_with_callbacks(working_dir, cmd, argv, NULL, 0, NULL, NULL, build_iofunc, + GINT_TO_POINTER(0), 0, build_iofunc, GINT_TO_POINTER(1), 0, build_exit_cb, NULL, + &build_info.pid, &error)) { geany_debug("build command spawning failed: %s", error->message); ui_set_statusbar(TRUE, _("Process failed (%s)"), error->message); -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] dccd42: Don't check a spawned command line twice under Unix
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Mon, 16 Mar 2015 20:23:28 UTC Commit: dccd421a798d549b935e4dd674fa6a87e4b52ed5 https://github.com/geany/geany/commit/dccd421a798d549b935e4dd674fa6a87e4b52… Log Message: ----------- Don't check a spawned command line twice under Unix Modified Paths: -------------- src/spawn.c Modified: src/spawn.c 13 lines changed, 8 insertions(+), 5 deletions(-) =================================================================== @@ -442,17 +442,20 @@ gboolean spawn_async_with_pipes(const gchar *working_directory, const gchar *com { g_return_val_if_fail(command_line != NULL || argv != NULL, FALSE); - if (command_line && !spawn_check_command(command_line, FALSE, error)) - return FALSE; - #ifdef G_OS_WIN32 GString *command; GArray *environment = g_array_new(TRUE, FALSE, sizeof(char)); GPid pid; gchar *failure; - while (command_line && strchr(CL_BLANKS, *command_line)) - command_line++; + if (command_line) + { + if (!spawn_check_command(command_line, FALSE, error)) + return FALSE; + /* checked command line contains at least 1 non-blank */ + while (strchr(CL_BLANKS, *command_line)) + command_line++; + } command = g_string_new(command_line); -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] faa6cd: Clarify that a spawn stdout/stderr cb may modify the passed string
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Mon, 16 Mar 2015 20:25:54 UTC Commit: faa6cd8614f59b16babbe0e48396659e0a411021 https://github.com/geany/geany/commit/faa6cd8614f59b16babbe0e48396659e0a411… Log Message: ----------- Clarify that a spawn stdout/stderr cb may modify the passed string Modified Paths: -------------- src/spawn.h Modified: src/spawn.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -63,6 +63,8 @@ typedef enum * * If @c G_IO_IN or @c G_IO_PRI are set, the @a string will contain at least one character. * + * The callback function may modify the @a string, but must not free it. + * * @param string contains the child data if @c G_IO_IN or @c G_IO_PRI are set. * @param condition the I/O condition which has been satisfied. * @param data the passed to @c spawn_with_callbacks() with the callback. -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 3b723b: Fix a memory leak when checking a spawn command line
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Thu, 19 Mar 2015 17:03:59 UTC Commit: 3b723b8ce000ce5bd60a5dc41cb3c620bfaba381 https://github.com/geany/geany/commit/3b723b8ce000ce5bd60a5dc41cb3c620bfaba… Log Message: ----------- Fix a memory leak when checking a spawn command line Modified Paths: -------------- src/spawn.c Modified: src/spawn.c 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -174,6 +174,7 @@ gboolean spawn_check_command(const gchar *command_line, gboolean execute, GError g_set_error(error, G_SHELL_ERROR, G_SHELL_ERROR_BAD_QUOTING, _("Text ended before matching quote was found for %c." " (The text was '%s')"), '"', command_line); + g_free(program); return FALSE; } #else /* G_OS_WIN32 */ -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 4a0ea0: Do not reallocate the build output/error text received by spawn
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Thu, 19 Mar 2015 17:08:46 UTC Commit: 4a0ea0ce1f8e0b85fe390d8aa1c7e967a9c92ce7 https://github.com/geany/geany/commit/4a0ea0ce1f8e0b85fe390d8aa1c7e967a9c92… Log Message: ----------- Do not reallocate the build output/error text received by spawn Modified Paths: -------------- src/build.c Modified: src/build.c 11 lines changed, 3 insertions(+), 8 deletions(-) =================================================================== @@ -124,7 +124,7 @@ static void on_build_next_error(GtkWidget *menuitem, gpointer user_data); static void on_build_previous_error(GtkWidget *menuitem, gpointer user_data); static void kill_process(GPid *pid); static void show_build_result_message(gboolean failure); -static void process_build_output_line(const gchar *line, gint color); +static void process_build_output_line(gchar *msg, gint color); static void show_build_commands_dialog(void); static void on_build_menu_item(GtkWidget *w, gpointer user_data); @@ -920,20 +920,16 @@ static void build_run_cmd(GeanyDocument *doc, guint cmdindex) } -static void process_build_output_line(const gchar *str, gint color) +static void process_build_output_line(gchar *msg, gint color) { - gchar *msg, *tmp; + gchar *tmp; gchar *filename; gint line; - msg = g_strdup(str); g_strchomp(msg); if (EMPTY(msg)) - { - g_free(msg); return; - } if (build_parse_make_dir(msg, &tmp)) { @@ -959,7 +955,6 @@ static void process_build_output_line(const gchar *str, gint color) g_free(filename); msgwin_compiler_add_string(color, msg); - g_free(msg); } -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 690cb9: Alter build.c to use the new spawning module
by Dimitar Zhekov 15 May '15

15 May '15

Branch: refs/heads/master Author: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Committer: Dimitar Zhekov <dimitar.zhekov(a)gmail.com> Date: Sat, 14 Mar 2015 19:36:05 UTC Commit: 690cb922be902f023881d455ae0c0a87d1c62170 https://github.com/geany/geany/commit/690cb922be902f023881d455ae0c0a87d1c62… Log Message: ----------- Alter build.c to use the new spawning module The wrong and misleading "Failed to change the working directory" is changed to a generic "Invalid working directory". Under Windows, the build commands are run directly as command lines, while under Unix, /bin/sh is used - for compatibility, and because that's probably what a *nix user expects. The run script is always run as a command line, since it contains it's own shell, and because that lets us specify %c under Windows. In fact, %c (or "%c") should probably be the default, since CreateProcess() runs batch files with the default shell, instead of some our value. Also changed build_spawn_cmd() and build_run_cmd() to void, since their return values are not used anywhere. Modified Paths: -------------- src/build.c Modified: src/build.c 279 lines changed, 45 insertions(+), 234 deletions(-) =================================================================== @@ -44,6 +44,7 @@ #include "prefs.h" #include "projectprivate.h" #include "sciwrappers.h" +#include "spawn.h" #include "support.h" #include "toolbar.h" #include "ui_utils.h" @@ -60,20 +61,8 @@ #include <errno.h> #include <glib/gstdio.h> -#ifdef G_OS_UNIX -# include <sys/types.h> -# include <sys/wait.h> -# include <signal.h> -#else -# include <windows.h> -#endif -/* g_spawn_async_with_pipes doesn't work on Windows */ -#ifdef G_OS_WIN32 -#define SYNC_SPAWN -#endif - /* Number of editor indicators to draw - limited as this can affect performance */ #define GEANY_BUILD_ERR_HIGHLIGHT_MAX 50 @@ -124,12 +113,10 @@ widgets; static guint build_groups_count[GEANY_GBG_COUNT] = { 3, 4, 2 }; static guint build_items_count = 9; -#ifndef SYNC_SPAWN -static void build_exit_cb(GPid child_pid, gint status, gpointer user_data); -static gboolean build_iofunc(GIOChannel *ioc, GIOCondition cond, gpointer data); -#endif +static void build_exit_cb(GPid pid, gint status, gpointer user_data); +static void build_iofunc(GString *string, GIOCondition condition, gpointer data); static gchar *build_create_shellscript(const gchar *working_dir, const gchar *cmd, gboolean autoclose, GError **error); -static GPid build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *dir); +static void build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *dir); static void set_stop_button(gboolean stop); static void run_exit_cb(GPid child_pid, gint status, gpointer user_data); static void on_set_build_commands_activate(GtkWidget *w, gpointer u); @@ -673,47 +660,6 @@ static void clear_all_errors(void) } -#ifdef SYNC_SPAWN -static void parse_build_output(const gchar **output, gint status) -{ - guint x, i, len; - gchar *line, **lines; - - for (x = 0; x < 2; x++) - { - if (!EMPTY(output[x])) - { - lines = g_strsplit_set(output[x], "\r\n", -1); - len = g_strv_length(lines); - - for (i = 0; i < len; i++) - { - if (!EMPTY(lines[i])) - { - line = lines[i]; - while (*line != '\0') - { /* replace any control characters in the output */ - if (*line < 32) - *line = 32; - line++; - } - process_build_output_line(lines[i], COLOR_BLACK); - } - } - g_strfreev(lines); - } - } - - show_build_result_message(status != 0); - utils_beep(); - - build_info.pid = 0; - /* enable build items again */ - build_menu_update(NULL); -} -#endif - - /* Replaces occurences of %e and %p with the appropriate filenames and * %l with current line number. %d and %p replacements should be in UTF8 */ static gchar *build_replace_placeholder(const GeanyDocument *doc, const gchar *src) @@ -782,43 +728,29 @@ static gchar *build_replace_placeholder(const GeanyDocument *doc, const gchar *s /* dir is the UTF-8 working directory to run cmd in. It can be NULL to use the * idx document directory */ -static GPid build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *dir) +static void build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *dir) { GError *error = NULL; - gchar **argv; +#ifdef G_OS_UNIX + /* under Unix, start cmd via sh for compatibility */ + gchar *argv[] = { "/bin/sh", "-c", (gchar *) cmd, NULL }; +#endif gchar *working_dir; gchar *utf8_working_dir; gchar *utf8_cmd_string; -#ifdef SYNC_SPAWN - gchar *output[2]; - gint status; -#else - gint stdout_fd; - gint stderr_fd; -#endif - g_return_val_if_fail(doc == NULL || doc->is_valid, (GPid) -1); + g_return_if_fail(doc == NULL || doc->is_valid); - if (!((doc != NULL && !EMPTY(doc->file_name)) || !EMPTY(dir))) + if ((doc == NULL || EMPTY(doc->file_name)) && EMPTY(dir)) { geany_debug("Failed to run command with no working directory"); ui_set_statusbar(TRUE, _("Process failed, no working directory")); - return (GPid) 1; + return; } clear_all_errors(); SETPTR(current_dir_entered, NULL); -#ifdef G_OS_WIN32 - argv = g_strsplit(cmd, " ", 0); -#else - argv = g_new0(gchar *, 4); - argv[0] = g_strdup("/bin/sh"); - argv[1] = g_strdup("-c"); - argv[2] = g_strdup(cmd); - argv[3] = NULL; -#endif - utf8_cmd_string = utils_get_utf8_from_locale(cmd); utf8_working_dir = !EMPTY(dir) ? g_strdup(dir) : g_path_get_dirname(doc->file_name); working_dir = utils_get_locale_from_utf8(utf8_working_dir); @@ -835,47 +767,22 @@ static GPid build_spawn_cmd(GeanyDocument *doc, const gchar *cmd, const gchar *d build_info.file_type_id = (doc == NULL) ? GEANY_FILETYPES_NONE : doc->file_type->id; build_info.message_count = 0; -#ifdef SYNC_SPAWN - if (! utils_spawn_sync(working_dir, argv, NULL, G_SPAWN_SEARCH_PATH, - NULL, NULL, &output[0], &output[1], &status, &error)) +#ifdef G_OS_WIN32 + if (!spawn_with_callbacks(working_dir, cmd, NULL, NULL, 0, NULL, NULL, build_iofunc, #else - if (! g_spawn_async_with_pipes(working_dir, argv, NULL, - G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, - &(build_info.pid), NULL, &stdout_fd, &stderr_fd, &error)) + /* cmd is passed via argv, so check it explicitly */ + if (!spawn_check_command(cmd, FALSE, &error) || + !spawn_with_callbacks(working_dir, NULL, argv, NULL, 0, NULL, NULL, build_iofunc, #endif + GINT_TO_POINTER(0), 0, build_iofunc, GINT_TO_POINTER(1), 0, build_exit_cb, + NULL, &build_info.pid, &error)) { geany_debug("build command spawning failed: %s", error->message); ui_set_statusbar(TRUE, _("Process failed (%s)"), error->message); - g_strfreev(argv); g_error_free(error); - g_free(working_dir); - error = NULL; - return (GPid) 0; - } - -#ifdef SYNC_SPAWN - parse_build_output((const gchar**) output, status); - g_free(output[0]); - g_free(output[1]); -#else - if (build_info.pid != 0) - { - g_child_watch_add(build_info.pid, (GChildWatchFunc) build_exit_cb, NULL); - build_menu_update(doc); - ui_progress_bar_start(NULL); } - /* use GIOChannels to monitor stdout and stderr */ - utils_set_up_io_channel(stdout_fd, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, - TRUE, build_iofunc, GINT_TO_POINTER(0)); - utils_set_up_io_channel(stderr_fd, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, - TRUE, build_iofunc, GINT_TO_POINTER(1)); -#endif - - g_strfreev(argv); g_free(working_dir); - - return build_info.pid; } @@ -901,13 +808,10 @@ static gchar *prepare_run_cmd(GeanyDocument *doc, gchar **working_dir, guint cmd working_dir_utf8 = build_replace_placeholder(doc, cmd_working_dir); *working_dir = utils_get_locale_from_utf8(working_dir_utf8); - /* only test whether working dir exists, don't change it or else Windows support will break - * (gspawn-win32-helper.exe is used by GLib and must be in $PATH which means current working - * dir where geany.exe was started from, so we can't change it) */ if (EMPTY(*working_dir) || ! g_file_test(*working_dir, G_FILE_TEST_EXISTS) || ! g_file_test(*working_dir, G_FILE_TEST_IS_DIR)) { - ui_set_statusbar(TRUE, _("Failed to change the working directory to \"%s\""), + ui_set_statusbar(TRUE, _("Invalid working directory \"%s\""), !EMPTY(working_dir_utf8) ? working_dir_utf8 : "<NULL>" ); utils_free_pointers(3, cmd_string_utf8, working_dir_utf8, *working_dir, NULL); return NULL; @@ -943,18 +847,17 @@ static gchar *prepare_run_cmd(GeanyDocument *doc, gchar **working_dir, guint cmd } -static GPid build_run_cmd(GeanyDocument *doc, guint cmdindex) +static void build_run_cmd(GeanyDocument *doc, guint cmdindex) { gchar *working_dir; gchar *run_cmd = NULL; - GError *error = NULL; if (! DOC_VALID(doc) || doc->file_name == NULL) - return (GPid) 0; + return; run_cmd = prepare_run_cmd(doc, &working_dir, cmdindex); if (run_cmd == NULL) - return (GPid) 0; + return; run_info[cmdindex].file_type_id = doc->file_type->id; @@ -988,79 +891,35 @@ static GPid build_run_cmd(GeanyDocument *doc, guint cmdindex) msgwin_show_hide(TRUE); run_info[cmdindex].pid = 1; - g_free(vte_cmd); } else #endif { - gchar *locale_term_cmd = NULL; - gint argv_len, i; - gchar **argv = NULL; - gchar *script_path = NULL; + gchar *locale_term_cmd = utils_get_locale_from_utf8(tool_prefs.term_cmd); + GError *error = NULL; - /* get the terminal path */ - locale_term_cmd = utils_get_locale_from_utf8(tool_prefs.term_cmd); - /* split the term_cmd, so arguments will work too */ - if (!g_shell_parse_argv(locale_term_cmd, &argv_len, &argv, NULL)) - { - ui_set_statusbar(TRUE, - _("Could not parse terminal command \"%s\" " - "(check Terminal tool setting in Preferences)"), tool_prefs.term_cmd); - run_info[cmdindex].pid = (GPid) 1; - g_unlink(run_cmd); - goto free_strings; - } + utils_str_replace_all(&locale_term_cmd, "%c", run_cmd); - /* check that terminal exists (to prevent misleading error messages) */ - if (argv[0] != NULL) + if (spawn_async(working_dir, locale_term_cmd, NULL, NULL, &(run_info[cmdindex].pid), + &error)) { - gchar *tmp = argv[0]; - /* g_find_program_in_path checks whether tmp exists and is executable */ - argv[0] = g_find_program_in_path(tmp); - g_free(tmp); - } - if (argv[0] == NULL) - { - ui_set_statusbar(TRUE, - _("Could not find terminal \"%s\" " - "(check path for Terminal tool setting in Preferences)"), tool_prefs.term_cmd); - run_info[cmdindex].pid = (GPid) 1; - g_unlink(run_cmd); - goto free_strings; - } - - for (i = 0; i < argv_len; i++) - { - utils_str_replace_all(&(argv[i]), "%c", run_cmd); + g_child_watch_add(run_info[cmdindex].pid, (GChildWatchFunc) run_exit_cb, + (gpointer) &(run_info[cmdindex])); + build_menu_update(doc); } - - if (! g_spawn_async(working_dir, argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD, - NULL, NULL, &(run_info[cmdindex].pid), &error)) + else { - geany_debug("g_spawn_async() failed: %s", error->message); + geany_debug("spawn_async() failed: %s", error->message); ui_set_statusbar(TRUE, _("Process failed (%s)"), error->message); g_error_free(error); g_unlink(run_cmd); - error = NULL; run_info[cmdindex].pid = (GPid) 0; } - - if (run_info[cmdindex].pid != 0) - { - g_child_watch_add(run_info[cmdindex].pid, (GChildWatchFunc) run_exit_cb, - (gpointer)&(run_info[cmdindex])); - build_menu_update(doc); - } - free_strings: - g_strfreev(argv); - g_free(locale_term_cmd); - g_free(script_path); } g_free(working_dir); g_free(run_cmd); - return run_info[cmdindex].pid; } @@ -1071,7 +930,6 @@ static void process_build_output_line(const gchar *str, gint color) gint line; msg = g_strdup(str); - g_strchomp(msg); if (EMPTY(msg)) @@ -1108,29 +966,14 @@ static void process_build_output_line(const gchar *str, gint color) } -#ifndef SYNC_SPAWN -static gboolean build_iofunc(GIOChannel *ioc, GIOCondition cond, gpointer data) +static void build_iofunc(GString *string, GIOCondition condition, gpointer data) { - if (cond & (G_IO_IN | G_IO_PRI)) + if (condition & (G_IO_IN | G_IO_PRI)) { - gchar *msg; - GIOStatus st; - - while ((st = g_io_channel_read_line(ioc, &msg, NULL, NULL, NULL)) == G_IO_STATUS_NORMAL && msg) - { - gint color = (GPOINTER_TO_INT(data)) ? COLOR_DARK_RED : COLOR_BLACK; - - process_build_output_line(msg, color); - g_free(msg); - } - if (st == G_IO_STATUS_ERROR || st == G_IO_STATUS_EOF) return FALSE; + process_build_output_line(string->str, + (GPOINTER_TO_INT(data)) ? COLOR_DARK_RED : COLOR_BLACK); } - if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) - return FALSE; - - return TRUE; } -#endif gboolean build_parse_make_dir(const gchar *string, gchar **prefix) @@ -1203,40 +1046,16 @@ static void show_build_result_message(gboolean failure) } -#ifndef SYNC_SPAWN static void build_exit_cb(GPid child_pid, gint status, gpointer user_data) { - gboolean failure = FALSE; - -#ifdef G_OS_WIN32 - failure = status; -#else - if (WIFEXITED(status)) - { - if (WEXITSTATUS(status) != EXIT_SUCCESS) - failure = TRUE; - } - else if (WIFSIGNALED(status)) - { - /* the terminating signal: WTERMSIG (status)); */ - failure = TRUE; - } - else - { /* any other failure occured */ - failure = TRUE; - } -#endif - show_build_result_message(failure); - + show_build_result_message(!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS); utils_beep(); - g_spawn_close_pid(child_pid); build_info.pid = 0; /* enable build items again */ build_menu_update(NULL); ui_progress_bar_stop(); } -#endif static void run_exit_cb(GPid child_pid, gint status, gpointer user_data) @@ -1788,26 +1607,18 @@ static void on_toolbutton_make_activate(GtkWidget *menuitem, gpointer user_data) static void kill_process(GPid *pid) { - gint result; - -#ifdef G_OS_WIN32 - g_return_if_fail(*pid != NULL); - result = TerminateProcess(*pid, 0); - /* TerminateProcess() returns TRUE on success, for the check below we have to convert - * it to FALSE (and vice versa) */ - result = ! result; -#else - g_return_if_fail(*pid > 1); - result = kill(*pid, SIGTERM); -#endif + GError *error = NULL; - if (result != 0) - ui_set_statusbar(TRUE, _("Process could not be stopped (%s)."), g_strerror(errno)); - else + if (spawn_kill_process(*pid, &error)) { *pid = 0; build_menu_update(NULL); } + else + { + ui_set_statusbar(TRUE, _("Process could not be stopped (%s)."), error->message); + g_error_free(error); + } } -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

← Newer
1
2
3
4
5
6
7
8
9
10
Older →

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

Commits May 2015