X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=interactive.c;h=c34a0f6eb3c5ff3fd6fcb0e85546a180d21fd880;hp=f9ea3612ee8a1b0e80bef508051ed737b9a0ba05;hb=refs%2Fheads%2Fmaint;hpb=c059f39305eb3629e06a89aa44816e98d29d78a8 diff --git a/interactive.c b/interactive.c index f9ea3612..9f4dec17 100644 --- a/interactive.c +++ b/interactive.c @@ -1,21 +1,15 @@ -/* - * Copyright (C) 2011-2012 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2011 Andre Noll , see file COPYING. */ /** \file interactive.c Readline abstraction for interactive sessions. */ +#include "para.h" + #include -#include -#include #include #include #include -#include #include -#include "para.h" #include "fd.h" #include "buffer_tree.h" #include "list.h" @@ -27,15 +21,37 @@ struct i9e_private { struct i9e_client_info *ici; FILE *stderr_stream; + int num_columns; + int num_key_bindings; char empty_line[1000]; - struct task task; + char key_sequence[32]; + unsigned key_sequence_length; + struct task *task; struct btr_node *stdout_btrn; - bool line_handler_running; + bool last_write_was_status; bool input_eof; bool caught_sigint; + bool caught_sigterm; + Keymap standard_km; + Keymap bare_km; + int fd_flags[2]; }; static struct i9e_private i9e_private, *i9ep = &i9e_private; +/** + * Return the error state of the i9e task. + * + * This is mainly useful for other tasks to tell whether the i9e task is still + * running. + * + * \return A negative return value of zero means the i9e task terminated. Only + * in this case it is safe to call ie9_close(). + */ +int i9e_get_error(void) +{ + return task_status(i9ep->task); +} + static bool is_prefix(const char *partial, const char *full, size_t len) { if (len == 0) @@ -178,11 +194,30 @@ static char **i9e_completer(const char *text, int start, __a_unused int end) */ void i9e_attach_to_stdout(struct btr_node *producer) { - assert(!i9ep->stdout_btrn); + btr_remove_node(&i9ep->stdout_btrn); i9ep->stdout_btrn = btr_new_node(&(struct btr_node_description) EMBRACE(.name = "interactive_stdout", .parent = producer)); + rl_set_keymap(i9ep->bare_km); +} + +static void wipe_bottom_line(void) +{ + fprintf(i9ep->stderr_stream, "\r%s\r", i9ep->empty_line); } +#ifndef RL_FREE_KEYMAP_DECLARED +/** + * Free all storage associated with a keymap. + * + * This function is not declared in the readline headers although the symbol is + * exported and the function is documented in the readline info file. So we + * have to declare it here. + * + * \param keymap The keymap to deallocate. + */ +void rl_free_keymap(Keymap keymap); +#endif + /** * Reset the terminal and save the in-memory command line history. * @@ -192,16 +227,13 @@ void i9e_close(void) { char *hf = i9ep->ici->history_file; - rl_deprep_terminal(); - fprintf(i9ep->stderr_stream, "\n"); + rl_free_keymap(i9ep->bare_km); + rl_callback_handler_remove(); if (hf) write_history(hf); - fclose(i9ep->stderr_stream); -} - -static void wipe_bottom_line(void) -{ - fprintf(i9ep->stderr_stream, "\r%s\r", i9ep->empty_line); + wipe_bottom_line(); + fcntl(i9ep->ici->fds[0], F_SETFL, i9ep->fd_flags[0]); + fcntl(i9ep->ici->fds[1], F_SETFL, i9ep->fd_flags[1]); } static void clear_bottom_line(void) @@ -222,6 +254,7 @@ static void clear_bottom_line(void) rl_redisplay(); wipe_bottom_line(); /* wipe out the prompt */ rl_insert_text(text); + free(text); rl_point = point; } @@ -240,78 +273,112 @@ static bool input_available(void) static void i9e_line_handler(char *line) { int ret; + struct btr_node *dummy; - i9ep->line_handler_running = true; + if (!line) { + i9ep->input_eof = true; + return; + } + if (!*line) + goto free_line; + rl_set_prompt(""); + dummy = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = "dummy line handler")); + i9e_attach_to_stdout(dummy); ret = i9ep->ici->line_handler(line); - i9ep->line_handler_running = false; if (ret < 0) PARA_WARNING_LOG("%s\n", para_strerror(-ret)); - rl_set_prompt(""); - if (line) { - if (!*line) - rl_set_prompt(i9ep->ici->prompt); - else - add_history(line); - free(line); - } else { - rl_set_prompt(""); - i9ep->input_eof = true; - } -} - -static void i9e_input(void) -{ - do { - rl_callback_read_char(); - } while (input_available()); + add_history(line); + btr_remove_node(&dummy); +free_line: + free(line); } -static void i9e_post_select(struct sched *s, struct task *t) +static int i9e_post_select(__a_unused struct sched *s, __a_unused void *context) { int ret; - struct btr_node *btrn = i9ep->stdout_btrn; struct i9e_client_info *ici = i9ep->ici; char *buf; - size_t sz; + size_t sz, consumed = 0; - if (i9ep->input_eof) { - t->error = -E_I9E_EOF; - return; - } - if (!btrn) { - i9ep->caught_sigint = false; - if (FD_ISSET(ici->fds[0], &s->rfds)) - i9e_input(); - return; - } + ret = -E_I9E_EOF; + if (i9ep->input_eof) + goto rm_btrn; + ret = -E_I9E_TERM_RQ; + if (i9ep->caught_sigterm) + goto rm_btrn; + ret = 0; if (i9ep->caught_sigint) goto rm_btrn; + while (input_available()) { + if (i9ep->stdout_btrn) { + while (i9ep->key_sequence_length < sizeof(i9ep->key_sequence) - 1) { + buf = i9ep->key_sequence + i9ep->key_sequence_length; + ret = read(i9ep->ici->fds[0], buf, 1); + if (ret < 0) { + ret = -ERRNO_TO_PARA_ERROR(errno); + goto rm_btrn; + } + if (ret == 0) { + ret = -E_I9E_EOF; + goto rm_btrn; + } + buf[1] = '\0'; + i9ep->key_sequence_length++; + rl_stuff_char((int)(unsigned char)*buf); + rl_callback_read_char(); + if (!input_available()) + break; + } + i9ep->key_sequence_length = 0; + } else + rl_callback_read_char(); + ret = 0; + } + if (!i9ep->stdout_btrn) + goto out; ret = btr_node_status(i9ep->stdout_btrn, 0, BTR_NT_LEAF); - if (ret < 0) + if (ret < 0) { + ret = 0; goto rm_btrn; - sz = btr_next_buffer(btrn, &buf); + } + if (ret == 0) + goto out; +again: + sz = btr_next_buffer(i9ep->stdout_btrn, &buf); if (sz == 0) goto out; + if (i9ep->last_write_was_status) + fprintf(i9ep->stderr_stream, "\n"); + i9ep->last_write_was_status = false; ret = xwrite(ici->fds[1], buf, sz); if (ret < 0) goto rm_btrn; - btr_consume(btrn, ret); + btr_consume(i9ep->stdout_btrn, ret); + consumed += ret; + if (ret == sz && consumed < 10000) + goto again; goto out; rm_btrn: - btr_remove_node(btrn); - btr_free_node(btrn); - i9ep->stdout_btrn = NULL; - rl_set_prompt(i9ep->ici->prompt); - rl_forced_update_display(); + if (i9ep->stdout_btrn) { + wipe_bottom_line(); + btr_remove_node(&i9ep->stdout_btrn); + rl_set_keymap(i9ep->standard_km); + rl_set_prompt(i9ep->ici->prompt); + rl_redisplay(); + } + if (ret < 0) + wipe_bottom_line(); out: - t->error = 0; + i9ep->caught_sigint = false; + return ret; } -static void i9e_pre_select(struct sched *s, __a_unused struct task *t) +static void i9e_pre_select(struct sched *s, __a_unused void *context) { int ret; - if (i9ep->input_eof || i9ep->caught_sigint) { + if (i9ep->input_eof || i9ep->caught_sigint || i9ep->caught_sigterm) { sched_min_delay(s); return; } @@ -340,14 +407,41 @@ static void update_winsize(void) { struct winsize w; int ret = ioctl(i9ep->ici->fds[2], TIOCGWINSZ, (char *)&w); - int num_columns = 80; if (ret >= 0) { assert(w.ws_col < sizeof(i9ep->empty_line)); - num_columns = w.ws_col; + i9ep->num_columns = w.ws_col; + } else + i9ep->num_columns = 80; + + memset(i9ep->empty_line, ' ', i9ep->num_columns); + i9ep->empty_line[i9ep->num_columns] = '\0'; +} + +static int dispatch_key(__a_unused int count, __a_unused int key) +{ + int i, ret; + +again: + if (i9ep->key_sequence_length == 0) + return 0; + for (i = i9ep->num_key_bindings - 1; i >= 0; i--) { + if (strcmp(i9ep->key_sequence, i9ep->ici->bound_keyseqs[i])) + continue; + i9ep->key_sequence[0] = '\0'; + i9ep->key_sequence_length = 0; + ret = i9ep->ici->key_handler(i); + return ret < 0? ret : 0; } - memset(i9ep->empty_line, ' ', num_columns); - i9ep->empty_line[num_columns] = '\0'; + PARA_WARNING_LOG("ignoring key %d\n", i9ep->key_sequence[0]); + /* + * We received an undefined key sequence. Throw away the first byte, + * and try to parse the remainder. + */ + memmove(i9ep->key_sequence, i9ep->key_sequence + 1, + i9ep->key_sequence_length); /* move also terminating zero byte */ + i9ep->key_sequence_length--; + goto again; } /** @@ -359,24 +453,35 @@ static void update_winsize(void) * The caller must allocate and initialize the structure \a ici points to. * * \return Standard. - * \sa \ref register_task(). */ int i9e_open(struct i9e_client_info *ici, struct sched *s) { int ret; + memset(i9ep, 0, sizeof(struct i9e_private)); if (!isatty(ici->fds[0])) return -E_I9E_SETUPTERM; + ret = fcntl(ici->fds[0], F_GETFL); + if (ret < 0) + return -E_I9E_SETUPTERM; + i9ep->fd_flags[0] = ret; + ret = fcntl(ici->fds[1], F_GETFL); + if (ret < 0) + return -E_I9E_SETUPTERM; + i9ep->fd_flags[1] = ret; ret = mark_fd_nonblocking(ici->fds[0]); if (ret < 0) return ret; ret = mark_fd_nonblocking(ici->fds[1]); if (ret < 0) return ret; - i9ep->task.pre_select = i9e_pre_select; - i9ep->task.post_select = i9e_post_select; - sprintf(i9ep->task.status, "i9e"); - register_task(s, &i9ep->task); + i9ep->task = task_register(&(struct task_info) { + .name = "i9e", + .pre_select = i9e_pre_select, + .post_select = i9e_post_select, + .context = i9ep, + }, s); + rl_readline_name = "para_i9e"; rl_basic_word_break_characters = " "; rl_attempted_completion_function = i9e_completer; @@ -384,16 +489,38 @@ int i9e_open(struct i9e_client_info *ici, struct sched *s) i9ep->stderr_stream = fdopen(ici->fds[2], "w"); setvbuf(i9ep->stderr_stream, NULL, _IONBF, 0); + i9ep->standard_km = rl_get_keymap(); + i9ep->bare_km = rl_make_bare_keymap(); + if (ici->bound_keyseqs) { + char *seq; + int i; + /* bind each key sequence to our dispatcher */ + for (i = 0; (seq = ici->bound_keyseqs[i]); i++) { + if (strlen(seq) >= sizeof(i9ep->key_sequence) - 1) { + PARA_WARNING_LOG("ignoring overlong key %s\n", + seq); + continue; + } + if (rl_bind_keyseq_in_map(seq, + dispatch_key, i9ep->bare_km) != 0) + PARA_WARNING_LOG("could not bind #%d: %s\n", i, seq); + } + i9ep->num_key_bindings = i; + } if (ici->history_file) read_history(ici->history_file); update_winsize(); - rl_callback_handler_install(i9ep->ici->prompt, i9e_line_handler); + if (ici->producer) { + rl_callback_handler_install("", i9e_line_handler); + i9e_attach_to_stdout(ici->producer); + } else + rl_callback_handler_install(i9ep->ici->prompt, i9e_line_handler); return 1; } static void reset_line_state(void) { - if (i9ep->line_handler_running) + if (i9ep->stdout_btrn) return; rl_on_new_line(); rl_reset_line_state(); @@ -416,29 +543,65 @@ __printf_2_3 void i9e_log(int ll, const char* fmt,...) if (ll < i9ep->ici->loglevel) return; - if (i9ep->line_handler_running == false) - clear_bottom_line(); + clear_bottom_line(); va_start(argp, fmt); vfprintf(i9ep->stderr_stream, fmt, argp); va_end(argp); reset_line_state(); + i9ep->last_write_was_status = false; +} + +/** + * Print the current status to stderr. + * + * \param buf The text to print. + * \param len The number of bytes in \a buf. + * + * This clears the bottom line, moves to the beginning of the line and prints + * the given text. If the length of this text exceeds the width of the + * terminal, the text is shortened by leaving out a part in the middle. + */ +void ie9_print_status_bar(char *buf, unsigned len) +{ + size_t x = i9ep->num_columns, y = (x - 4) / 2; + + assert(x >= 6); + if (len > x) { + buf[y] = '\0'; + fprintf(i9ep->stderr_stream, "\r%s", buf); + fprintf(i9ep->stderr_stream, " .. "); + fprintf(i9ep->stderr_stream, "%s", buf + len - y); + } else { + char scratch[1000]; + + y = x - len; + scratch[0] = '\r'; + strcpy(scratch + 1, buf); + memset(scratch + 1 + len, ' ', y); + scratch[1 + len + y] = '\r'; + scratch[2 + len + y] = '\0'; + fprintf(i9ep->stderr_stream, "\r%s", scratch); + } + i9ep->last_write_was_status = true; } /** * Tell i9e that the caller received a signal. * * \param sig_num The number of the signal received. - * - * Currently the function only cares about \p SIGINT, but this may change. */ void i9e_signal_dispatch(int sig_num) { + if (sig_num == SIGWINCH) + return update_winsize(); if (sig_num == SIGINT) { fprintf(i9ep->stderr_stream, "\n"); rl_replace_line ("", false /* clear_undo */); reset_line_state(); i9ep->caught_sigint = true; } + if (sig_num == SIGTERM) + i9ep->caught_sigterm = true; } /** @@ -604,17 +767,25 @@ int i9e_print_completions(struct i9e_completer *completers) ci.argc = create_argv(ci.buffer, " ", &ci.argv); ci.word_num = compute_word_num(ci.buffer, " ", ci.point); + /* determine the current word to complete */ end = ci.buffer + ci.point; + + if (*end == ' ') { + if (ci.point == 0 || ci.buffer[ci.point - 1] == ' ') { + ci.word = para_strdup(NULL); + goto create_matches; + } else /* The cursor is positioned right after a word */ + end--; + } for (p = end; p > ci.buffer && *p != ' '; p--) ; /* nothing */ if (*p == ' ') p++; - n = end - p + 1; ci.word = para_malloc(n + 1); strncpy(ci.word, p, n); ci.word[n] = '\0'; - +create_matches: PARA_DEBUG_LOG("line: %s, point: %d (%c), wordnum: %d, word: %s\n", ci.buffer, ci.point, ci.buffer[ci.point], ci.word_num, ci.word); if (ci.word_num == 0)