Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/lib/libedit/readline.c,v rcsdiff: /ftp/cvs/cvsroot/src/lib/libedit/readline.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.10 retrieving revision 1.58 diff -u -p -r1.10 -r1.58 --- src/lib/libedit/readline.c 2000/03/10 13:06:43 1.10 +++ src/lib/libedit/readline.c 2005/07/14 15:00:58 1.58 @@ -1,4 +1,4 @@ -/* $NetBSD: readline.c,v 1.10 2000/03/10 13:06:43 jdolecek Exp $ */ +/* $NetBSD: readline.c,v 1.58 2005/07/14 15:00:58 christos Exp $ */ /*- * Copyright (c) 1997 The NetBSD Foundation, Inc. @@ -36,9 +36,9 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include +#include "config.h" #if !defined(lint) && !defined(SCCSID) -__RCSID("$NetBSD: readline.c,v 1.10 2000/03/10 13:06:43 jdolecek Exp $"); +__RCSID("$NetBSD: readline.c,v 1.58 2005/07/14 15:00:58 christos Exp $"); #endif /* not lint && not SCCSID */ #include @@ -51,76 +51,138 @@ __RCSID("$NetBSD: readline.c,v 1.10 2000 #include #include #include -#include "histedit.h" -#include "readline.h" -#include "sys.h" +#include +#include +#ifdef HAVE_VIS_H +#include +#else +#include "np/vis.h" +#endif +#ifdef HAVE_ALLOCA_H +#include +#endif #include "el.h" +#include "fcns.h" /* for EL_NUM_FCNS */ +#include "histedit.h" +#include "readline/readline.h" +#include "filecomplete.h" /* for rl_complete() */ #define TAB '\r' /* see comment at the #ifdef for sense of this */ -#define GDB_411_HACK +/* #define GDB_411_HACK */ /* readline compatibility stuff - look at readline sources/documentation */ /* to see what these variables mean */ -const char *rl_library_version = "EditLine wrapper"; -char *rl_readline_name = ""; -FILE *rl_instream = NULL; -FILE *rl_outstream = NULL; -int rl_point = 0; -int rl_end = 0; -char *rl_line_buffer = NULL; - -int history_base = 1; /* probably never subject to change */ -int history_length = 0; -int max_input_history = 0; -char history_expansion_char = '!'; -char history_subst_char = '^'; -char *history_no_expand_chars = " \t\n=("; -Function *history_inhibit_expansion_function = NULL; - -int rl_inhibit_completion = 0; -int rl_attempted_completion_over = 0; -char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; -char *rl_completer_word_break_characters = NULL; -char *rl_completer_quote_characters = NULL; -CPFunction *rl_completion_entry_function = NULL; -CPPFunction *rl_attempted_completion_function = NULL; +const char *rl_library_version = "EditLine wrapper"; +static char empty[] = { '\0' }; +static char expand_chars[] = { ' ', '\t', '\n', '=', '(', '\0' }; +static char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@', '$', + '>', '<', '=', ';', '|', '&', '{', '(', '\0' }; +char *rl_readline_name = empty; +FILE *rl_instream = NULL; +FILE *rl_outstream = NULL; +int rl_point = 0; +int rl_end = 0; +char *rl_line_buffer = NULL; +VCPFunction *rl_linefunc = NULL; +int rl_done = 0; +VFunction *rl_event_hook = NULL; + +int history_base = 1; /* probably never subject to change */ +int history_length = 0; +int max_input_history = 0; +char history_expansion_char = '!'; +char history_subst_char = '^'; +char *history_no_expand_chars = expand_chars; +Function *history_inhibit_expansion_function = NULL; +char *history_arg_extract(int start, int end, const char *str); + +int rl_inhibit_completion = 0; +int rl_attempted_completion_over = 0; +char *rl_basic_word_break_characters = break_chars; +char *rl_completer_word_break_characters = NULL; +char *rl_completer_quote_characters = NULL; +Function *rl_completion_entry_function = NULL; +CPPFunction *rl_attempted_completion_function = NULL; +Function *rl_pre_input_hook = NULL; +Function *rl_startup1_hook = NULL; +Function *rl_getc_function = NULL; +char *rl_terminal_name = NULL; +int rl_already_prompted = 0; +int rl_filename_completion_desired = 0; +int rl_ignore_completion_duplicates = 0; +int rl_catch_signals = 1; +VFunction *rl_redisplay_function = NULL; +Function *rl_startup_hook = NULL; +VFunction *rl_completion_display_matches_hook = NULL; +VFunction *rl_prep_term_function = NULL; +VFunction *rl_deprep_term_function = NULL; + +/* + * The current prompt string. + */ +char *rl_prompt = NULL; +/* + * This is set to character indicating type of completion being done by + * rl_complete_internal(); this is available for application completion + * functions. + */ +int rl_completion_type = 0; + +/* + * If more than this number of items results from query for possible + * completions, we ask user if they are sure to really display the list. + */ +int rl_completion_query_items = 100; + +/* + * List of characters which are word break characters, but should be left + * in the parsed text when it is passed to the completion function. + * Shell uses this to help determine what kind of completing to do. + */ +char *rl_special_prefixes = NULL; + +/* + * This is the character appended to the completed words if at the end of + * the line. Default is ' ' (a space). + */ +int rl_completion_append_character = ' '; + +/* stuff below is used internally by libedit for readline emulation */ -/* used for readline emulation */ static History *h = NULL; static EditLine *e = NULL; +static Function *map[256]; /* internal functions */ -static unsigned char _el_rl_complete __P((EditLine *, int)); -static char *_get_prompt __P((EditLine *)); -static HIST_ENTRY *_move_history __P((int)); -static int _history_search_gen __P((const char *, int, int)); -static int _history_expand_command __P((const char *, size_t, char **)); -static char *_rl_compat_sub __P((const char *, const char *, - const char *, int)); -static int rl_complete_internal __P((int)); +static unsigned char _el_rl_complete(EditLine *, int); +static unsigned char _el_rl_tstp(EditLine *, int); +static char *_get_prompt(EditLine *); +static HIST_ENTRY *_move_history(int); +static int _history_expand_command(const char *, size_t, size_t, + char **); +static char *_rl_compat_sub(const char *, const char *, + const char *, int); +static int _rl_event_read_char(EditLine *, char *); +static void _rl_update_pos(void); -/* - * needed for prompt switching in readline() - */ -static char *el_rl_prompt = NULL; /* ARGSUSED */ static char * -_get_prompt(el) - EditLine *el; +_get_prompt(EditLine *el __attribute__((__unused__))) { - return el_rl_prompt; + rl_already_prompted = 1; + return (rl_prompt); } + /* * generic function for moving around history */ static HIST_ENTRY * -_move_history(op) - int op; +_move_history(int op) { HistEvent ev; static HIST_ENTRY rl_he; @@ -129,9 +191,9 @@ _move_history(op) return (HIST_ENTRY *) NULL; rl_he.line = ev.str; - rl_he.data = ""; + rl_he.data = NULL; - return &rl_he; + return (&rl_he); } @@ -143,10 +205,12 @@ _move_history(op) * initialize rl compat stuff */ int -rl_initialize() +rl_initialize(void) { HistEvent ev; const LineInfo *li; + int editmode = 1; + struct termios t; if (e != NULL) el_end(e); @@ -157,11 +221,21 @@ rl_initialize() rl_instream = stdin; if (!rl_outstream) rl_outstream = stdout; + + /* + * See if we don't really want to run the editor + */ + if (tcgetattr(fileno(rl_instream), &t) != -1 && (t.c_lflag & ECHO) == 0) + editmode = 0; + e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr); + if (!editmode) + el_set(e, EL_EDITMODE, 0); + h = history_init(); if (!e || !h) - return -1; + return (-1); history(h, &ev, H_SETSIZE, INT_MAX); /* unlimited */ history_length = 0; @@ -169,33 +243,59 @@ rl_initialize() el_set(e, EL_HIST, history, h); /* for proper prompt printing in readline() */ - el_rl_prompt = strdup(""); + rl_prompt = strdup(""); + if (rl_prompt == NULL) { + history_end(h); + el_end(e); + return -1; + } el_set(e, EL_PROMPT, _get_prompt); - el_set(e, EL_SIGNAL, 1); + el_set(e, EL_SIGNAL, rl_catch_signals); /* set default mode to "emacs"-style and read setting afterwards */ /* so this can be overriden */ el_set(e, EL_EDITOR, "emacs"); - - /* for word completition - this has to go AFTER rebinding keys */ - /* to emacs-style */ + if (rl_terminal_name != NULL) + el_set(e, EL_TERMINAL, rl_terminal_name); + else + el_get(e, EL_TERMINAL, &rl_terminal_name); + + /* + * Word completion - this has to go AFTER rebinding keys + * to emacs-style. + */ el_set(e, EL_ADDFN, "rl_complete", - "ReadLine compatible completition function", - _el_rl_complete); + "ReadLine compatible completion function", + _el_rl_complete); el_set(e, EL_BIND, "^I", "rl_complete", NULL); + /* + * Send TSTP when ^Z is pressed. + */ + el_set(e, EL_ADDFN, "rl_tstp", + "ReadLine compatible suspend function", + _el_rl_tstp); + el_set(e, EL_BIND, "^Z", "rl_tstp", NULL); + /* read settings from configuration file */ el_source(e, NULL); - /* some readline apps do use this */ + /* + * Unfortunately, some applications really do use rl_point + * and rl_line_buffer directly. + */ li = el_line(e); - /* LINTED const cast */ - rl_line_buffer = (char *) li->buffer; - rl_point = rl_end = 0; + /* a cheesy way to get rid of const cast. */ + rl_line_buffer = memchr(li->buffer, *li->buffer, 1); + _rl_update_pos(); - return 0; + if (rl_startup_hook) + (*rl_startup_hook)(NULL, 0); + + return (0); } + /* * read one line from input stream and return it, chomping * trailing newline (if there is any) @@ -206,38 +306,58 @@ readline(const char *prompt) HistEvent ev; int count; const char *ret; + char *buf; + static int used_event_hook; if (e == NULL || h == NULL) rl_initialize(); + rl_done = 0; + /* update prompt accordingly to what has been passed */ - if (!prompt) prompt = ""; - if (strcmp(el_rl_prompt, prompt) != 0) { - free(el_rl_prompt); - el_rl_prompt = strdup(prompt); + if (!prompt) + prompt = ""; + if (strcmp(rl_prompt, prompt) != 0) { + free(rl_prompt); + rl_prompt = strdup(prompt); + if (rl_prompt == NULL) + return NULL; } + if (rl_pre_input_hook) + (*rl_pre_input_hook)(NULL, 0); + + if (rl_event_hook && !(e->el_flags&NO_TTY)) { + el_set(e, EL_GETCFN, _rl_event_read_char); + used_event_hook = 1; + } + + if (!rl_event_hook && used_event_hook) { + el_set(e, EL_GETCFN, EL_BUILTIN_GETCFN); + used_event_hook = 0; + } + + rl_already_prompted = 0; + /* get one line from input stream */ ret = el_gets(e, &count); if (ret && count > 0) { - char *foo; int lastidx; - foo = strdup(ret); + buf = strdup(ret); + if (buf == NULL) + return NULL; lastidx = count - 1; - if (foo[lastidx] == '\n') - foo[lastidx] = '\0'; - - ret = foo; + if (buf[lastidx] == '\n') + buf[lastidx] = '\0'; } else - ret = NULL; + buf = NULL; history(h, &ev, H_GETSIZE); history_length = ev.num; - /* LINTED const cast */ - return (char *) ret; + return buf; } /* @@ -249,67 +369,187 @@ readline(const char *prompt) * history expansion functions */ void -using_history() +using_history(void) { if (h == NULL || e == NULL) rl_initialize(); } + /* * substitute ``what'' with ``with'', returning resulting string; if - * globally == 1, substitutes all occurences of what, otherwise only the + * globally == 1, substitutes all occurrences of what, otherwise only the * first one */ -static char * -_rl_compat_sub(str, what, with, globally) - const char *str, *what, *with; - int globally; -{ - char *result; - const char *temp, *new; - int len, with_len, what_len, add; - size_t size, i; +static char * +_rl_compat_sub(const char *str, const char *what, const char *with, + int globally) +{ + const char *s; + char *r, *result; + size_t len, with_len, what_len; - result = malloc((size = 16)); - temp = str; + len = strlen(str); with_len = strlen(with); what_len = strlen(what); - len = 0; - do { - new = strstr(temp, what); - if (new) { - i = new - temp; - add = i + with_len; - if (i + add + 1 >= size) { - size += add + 1; - result = realloc(result, size); - } - (void)strncpy(&result[len], temp, i); - len += i; - (void)strcpy(&result[len], with); /* safe */ - len += with_len; - temp = new + what_len; - } else { - add = strlen(temp); - if (len + add + 1 >= size) { - size += add + 1; - result = realloc(result, size); + + /* calculate length we need for result */ + s = str; + while (*s) { + if (*s == *what && !strncmp(s, what, what_len)) { + len += with_len - what_len; + if (!globally) + break; + s += what_len; + } else + s++; + } + r = result = malloc(len + 1); + if (result == NULL) + return NULL; + s = str; + while (*s) { + if (*s == *what && !strncmp(s, what, what_len)) { + (void)strncpy(r, with, with_len); + r += with_len; + s += what_len; + if (!globally) { + (void)strcpy(r, s); + return(result); } - (void)strcpy(&result[len], temp); /* safe */ - len += add; - temp = NULL; + } else + *r++ = *s++; + } + *r = 0; + return(result); +} + +static char *last_search_pat; /* last !?pat[?] search pattern */ +static char *last_search_match; /* last !?pat[?] that matched */ + +const char * +get_history_event(const char *cmd, int *cindex, int qchar) +{ + int idx, sign, sub, num, begin, ret; + size_t len; + char *pat; + const char *rptr; + HistEvent ev; + + idx = *cindex; + if (cmd[idx++] != history_expansion_char) + return(NULL); + + /* find out which event to take */ + if (cmd[idx] == history_expansion_char || cmd[idx] == 0) { + if (history(h, &ev, H_FIRST) != 0) + return(NULL); + *cindex = cmd[idx]? (idx + 1):idx; + return(ev.str); + } + sign = 0; + if (cmd[idx] == '-') { + sign = 1; + idx++; + } + + if ('0' <= cmd[idx] && cmd[idx] <= '9') { + HIST_ENTRY *rl_he; + + num = 0; + while (cmd[idx] && '0' <= cmd[idx] && cmd[idx] <= '9') { + num = num * 10 + cmd[idx] - '0'; + idx++; } - } while (temp && globally); - result[len] = '\0'; + if (sign) + num = history_length - num + 1; + + if (!(rl_he = history_get(num))) + return(NULL); + + *cindex = idx; + return(rl_he->line); + } + sub = 0; + if (cmd[idx] == '?') { + sub = 1; + idx++; + } + begin = idx; + while (cmd[idx]) { + if (cmd[idx] == '\n') + break; + if (sub && cmd[idx] == '?') + break; + if (!sub && (cmd[idx] == ':' || cmd[idx] == ' ' + || cmd[idx] == '\t' || cmd[idx] == qchar)) + break; + idx++; + } + len = idx - begin; + if (sub && cmd[idx] == '?') + idx++; + if (sub && len == 0 && last_search_pat && *last_search_pat) + pat = last_search_pat; + else if (len == 0) + return(NULL); + else { + if ((pat = malloc(len + 1)) == NULL) + return NULL; + (void)strncpy(pat, cmd + begin, len); + pat[len] = '\0'; + } + + if (history(h, &ev, H_CURR) != 0) { + if (pat != last_search_pat) + free(pat); + return (NULL); + } + num = ev.num; + + if (sub) { + if (pat != last_search_pat) { + if (last_search_pat) + free(last_search_pat); + last_search_pat = pat; + } + ret = history_search(pat, -1); + } else + ret = history_search_prefix(pat, -1); + + if (ret == -1) { + /* restore to end of list on failed search */ + history(h, &ev, H_FIRST); + (void)fprintf(rl_outstream, "%s: Event not found\n", pat); + if (pat != last_search_pat) + free(pat); + return(NULL); + } - return result; + if (sub && len) { + if (last_search_match && last_search_match != pat) + free(last_search_match); + last_search_match = pat; + } + + if (pat != last_search_pat) + free(pat); + + if (history(h, &ev, H_CURR) != 0) + return(NULL); + *cindex = idx; + rptr = ev.str; + + /* roll back to original position */ + (void)history(h, &ev, H_SET, num); + + return rptr; } /* * the real function doing history expansion - takes as argument command * to do and data upon which the command should be executed * does expansion the way I've understood readline documentation - * word designator ``%'' isn't supported (yet ?) * * returns 0 if data was not modified, 1 if it was and 2 if the string * should be only printed and not executed; in case of error, @@ -317,146 +557,145 @@ _rl_compat_sub(str, what, with, globally * it's callers responsibility to free() string returned in *result */ static int -_history_expand_command(command, cmdlen, result) - const char *command; - size_t cmdlen; - char **result; -{ - char **arr, *tempcmd, *line, *search = NULL, *cmd; - const char *event_data = NULL; - static char *from = NULL, *to = NULL; - int start = -1, end = -1, max, i, idx; - int h_on = 0, t_on = 0, r_on = 0, e_on = 0, p_on = 0, - g_on = 0; - int event_num = 0, retval; - size_t cmdsize; +_history_expand_command(const char *command, size_t offs, size_t cmdlen, + char **result) +{ + char *tmp, *search = NULL, *aptr; + const char *ptr, *cmd; + static char *from = NULL, *to = NULL; + int start, end, idx, has_mods = 0; + int p_on = 0, g_on = 0; *result = NULL; + aptr = NULL; + ptr = NULL; - cmd = alloca(cmdlen + 1); - (void)strncpy(cmd, command, cmdlen); - cmd[cmdlen] = 0; + /* First get event specifier */ + idx = 0; - idx = 1; - /* find out which event to take */ - if (cmd[idx] == history_expansion_char) { - event_num = history_length; - idx++; + if (strchr(":^*$", command[offs + 1])) { + char str[4]; + /* + * "!:" is shorthand for "!!:". + * "!^", "!*" and "!$" are shorthand for + * "!!:^", "!!:*" and "!!:$" respectively. + */ + str[0] = str[1] = '!'; + str[2] = '0'; + ptr = get_history_event(str, &idx, 0); + idx = (command[offs + 1] == ':')? 1:0; + has_mods = 1; } else { - int off, num; - size_t len; - off = idx; - while (cmd[off] && !strchr(":^$*-%", cmd[off])) - off++; - num = atoi(&cmd[idx]); - if (num != 0) { - event_num = num; - if (num < 0) - event_num += history_length + 1; + if (command[offs + 1] == '#') { + /* use command so far */ + if ((aptr = malloc(offs + 1)) == NULL) + return -1; + (void)strncpy(aptr, command, offs); + aptr[offs] = '\0'; + idx = 1; } else { - int prefix = 1, curr_num; - HistEvent ev; + int qchar; - len = off - idx; - if (cmd[idx] == '?') { - idx++, len--; - if (cmd[off - 1] == '?') - len--; - else if (cmd[off] != '\n' && cmd[off] != '\0') - return -1; - prefix = 0; - } - search = alloca(len + 1); - (void)strncpy(search, &cmd[idx], len); - search[len] = '\0'; + qchar = (offs > 0 && command[offs - 1] == '"')? '"':0; + ptr = get_history_event(command + offs, &idx, qchar); + } + has_mods = command[offs + idx] == ':'; + } - if (history(h, &ev, H_CURR) != 0) - return -1; - curr_num = ev.num; + if (ptr == NULL && aptr == NULL) + return(-1); - if (prefix) - retval = history_search_prefix(search, -1); + if (!has_mods) { + *result = strdup(aptr? aptr : ptr); + if (aptr) + free(aptr); + return(1); + } + + cmd = command + offs + idx + 1; + + /* Now parse any word designators */ + + if (*cmd == '%') /* last word matched by ?pat? */ + tmp = strdup(last_search_match? last_search_match:""); + else if (strchr("^*$-0123456789", *cmd)) { + start = end = -1; + if (*cmd == '^') + start = end = 1, cmd++; + else if (*cmd == '$') + start = -1, cmd++; + else if (*cmd == '*') + start = 1, cmd++; + else if (*cmd == '-' || isdigit((unsigned char) *cmd)) { + start = 0; + while (*cmd && '0' <= *cmd && *cmd <= '9') + start = start * 10 + *cmd++ - '0'; + + if (*cmd == '-') { + if (isdigit((unsigned char) cmd[1])) { + cmd++; + end = 0; + while (*cmd && '0' <= *cmd && *cmd <= '9') + end = end * 10 + *cmd++ - '0'; + } else if (cmd[1] == '$') { + cmd += 2; + end = -1; + } else { + cmd++; + end = -2; + } + } else if (*cmd == '*') + end = -1, cmd++; else - retval = history_search(search, -1); - - if (retval == -1) { - fprintf(rl_outstream, "%s: Event not found\n", - search); - return -1; - } - if (history(h, &ev, H_CURR) != 0) - return -1; - event_data = ev.str; - - /* roll back to original position */ - history(h, &ev, H_NEXT_EVENT, curr_num); + end = start; + } + tmp = history_arg_extract(start, end, aptr? aptr:ptr); + if (tmp == NULL) { + (void)fprintf(rl_outstream, "%s: Bad word specifier", + command + offs + idx); + if (aptr) + free(aptr); + return(-1); } - idx = off; - } - - if (!event_data && event_num >= 0) { - HIST_ENTRY *rl_he; - rl_he = history_get(event_num); - if (!rl_he) - return 0; - event_data = rl_he->line; } else - return -1; + tmp = strdup(aptr? aptr:ptr); - if (cmd[idx] != ':') - return -1; - cmd += idx + 1; + if (aptr) + free(aptr); - /* recognize cmd */ - if (*cmd == '^') - start = end = 1, cmd++; - else if (*cmd == '$') - start = end = -1, cmd++; - else if (*cmd == '*') - start = 1, end = -1, cmd++; - else if (isdigit((unsigned char) *cmd)) { - const char *temp; - int shifted = 0; - - start = atoi(cmd); - temp = cmd; - for (; isdigit((unsigned char) *cmd); cmd++); - if (temp != cmd) - shifted = 1; - if (shifted && *cmd == '-') { - if (!isdigit((unsigned char) *(cmd + 1))) - end = -2; - else { - end = atoi(cmd + 1); - for (; isdigit((unsigned char) *cmd); cmd++); - } - } else if (shifted && *cmd == '*') - end = -1, cmd++; - else if (shifted) - end = start; + if (*cmd == 0 || (cmd - (command + offs) >= cmdlen)) { + *result = tmp; + return(1); } - if (*cmd == ':') - cmd++; - line = strdup(event_data); for (; *cmd; cmd++) { if (*cmd == ':') continue; - else if (*cmd == 'h') - h_on = 1 | g_on, g_on = 0; - else if (*cmd == 't') - t_on = 1 | g_on, g_on = 0; - else if (*cmd == 'r') - r_on = 1 | g_on, g_on = 0; - else if (*cmd == 'e') - e_on = 1 | g_on, g_on = 0; - else if (*cmd == 'p') - p_on = 1 | g_on, g_on = 0; + else if (*cmd == 'h') { /* remove trailing path */ + if ((aptr = strrchr(tmp, '/')) != NULL) + *aptr = 0; + } else if (*cmd == 't') { /* remove leading path */ + if ((aptr = strrchr(tmp, '/')) != NULL) { + aptr = strdup(aptr + 1); + free(tmp); + tmp = aptr; + } + } else if (*cmd == 'r') { /* remove trailing suffix */ + if ((aptr = strrchr(tmp, '.')) != NULL) + *aptr = 0; + } else if (*cmd == 'e') { /* remove all but suffix */ + if ((aptr = strrchr(tmp, '.')) != NULL) { + aptr = strdup(aptr); + free(tmp); + tmp = aptr; + } + } else if (*cmd == 'p') /* print only */ + p_on = 1; else if (*cmd == 'g') g_on = 2; else if (*cmd == 's' || *cmd == '&') { - char *what, *with, delim; - int len, from_len; + char *what, *with, delim; + size_t len, from_len; size_t size; if (*cmd == '&' && (from == NULL || to == NULL)) @@ -465,25 +704,37 @@ _history_expand_command(command, cmdlen, delim = *(++cmd), cmd++; size = 16; what = realloc(from, size); + if (what == NULL) { + free(from); + return 0; + } len = 0; for (; *cmd && *cmd != delim; cmd++) { - if (*cmd == '\\' - && *(cmd + 1) == delim) + if (*cmd == '\\' && cmd[1] == delim) cmd++; - if (len >= size) - what = realloc(what, - (size <<= 1)); + if (len >= size) { + char *nwhat; + nwhat = realloc(what, + (size <<= 1)); + if (nwhat == NULL) { + free(what); + return 0; + } + what = nwhat; + } what[len++] = *cmd; } what[len] = '\0'; from = what; if (*what == '\0') { free(what); - if (search) + if (search) { from = strdup(search); - else { + if (from == NULL) + return 0; + } else { from = NULL; - return -1; + return (-1); } } cmd++; /* shift after delim */ @@ -492,12 +743,22 @@ _history_expand_command(command, cmdlen, size = 16; with = realloc(to, size); + if (with == NULL) { + free(to); + return -1; + } len = 0; from_len = strlen(from); for (; *cmd && *cmd != delim; cmd++) { if (len + from_len + 1 >= size) { + char *nwith; size += from_len + 1; - with = realloc(with, size); + nwith = realloc(with, size); + if (nwith == NULL) { + free(with); + return -1; + } + with = nwith; } if (*cmd == '&') { /* safe */ @@ -513,111 +774,66 @@ _history_expand_command(command, cmdlen, } with[len] = '\0'; to = with; - - tempcmd = _rl_compat_sub(line, from, to, - (g_on) ? 1 : 0); - free(line); - line = tempcmd; - g_on = 0; } - } - } - - arr = history_tokenize(line); - free(line); /* no more needed */ - if (arr && *arr == NULL) - free(arr), arr = NULL; - if (!arr) - return -1; - - /* find out max valid idx to array of array */ - max = 0; - for (i = 0; arr[i]; i++) - max++; - max--; - - /* set boundaries to something relevant */ - if (start < 0) - start = 1; - if (end < 0) - end = max - ((end < -1) ? 1 : 0); - - /* check boundaries ... */ - if (start > max || end > max || start > end) - return -1; - for (i = 0; i <= max; i++) { - char *temp; - if (h_on && (i == 1 || h_on > 1) && - (temp = strrchr(arr[i], '/'))) - *(temp + 1) = '\0'; - if (t_on && (i == 1 || t_on > 1) && - (temp = strrchr(arr[i], '/'))) - (void)strcpy(arr[i], temp + 1); - if (r_on && (i == 1 || r_on > 1) && - (temp = strrchr(arr[i], '.'))) - *temp = '\0'; - if (e_on && (i == 1 || e_on > 1) && - (temp = strrchr(arr[i], '.'))) - (void)strcpy(arr[i], temp); - } - - cmdsize = 1, cmdlen = 0; - tempcmd = malloc(cmdsize); - for (i = start; start <= i && i <= end; i++) { - int arr_len; - - arr_len = strlen(arr[i]); - if (cmdlen + arr_len + 1 >= cmdsize) { - cmdsize += arr_len + 1; - tempcmd = realloc(tempcmd, cmdsize); + aptr = _rl_compat_sub(tmp, from, to, g_on); + if (aptr) { + free(tmp); + tmp = aptr; + } + g_on = 0; } - (void)strcpy(&tempcmd[cmdlen], arr[i]); /* safe */ - cmdlen += arr_len; - tempcmd[cmdlen++] = ' '; /* add a space */ } - while (cmdlen > 0 && isspace((unsigned char) tempcmd[cmdlen - 1])) - cmdlen--; - tempcmd[cmdlen] = '\0'; - - *result = tempcmd; - - for (i = 0; i <= max; i++) - free(arr[i]); - free(arr), arr = (char **) NULL; - return (p_on) ? 2 : 1; + *result = tmp; + return (p_on? 2:1); } + /* * csh-style history expansion */ int -history_expand(str, output) - char *str; - char **output; -{ - int i, retval = 0, idx; - size_t size; - char *temp, *result; +history_expand(char *str, char **output) +{ + int ret = 0; + size_t idx, i, size; + char *tmp, *result; if (h == NULL || e == NULL) rl_initialize(); - *output = strdup(str); /* do it early */ + if (history_expansion_char == 0) { + *output = strdup(str); + return(0); + } + *output = NULL; if (str[0] == history_subst_char) { /* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */ - temp = alloca(4 + strlen(str) + 1); - temp[0] = temp[1] = history_expansion_char; - temp[2] = ':'; - temp[3] = 's'; - (void)strcpy(temp + 4, str); - str = temp; + *output = malloc(strlen(str) + 4 + 1); + if (*output == NULL) + return 0; + (*output)[0] = (*output)[1] = history_expansion_char; + (*output)[2] = ':'; + (*output)[3] = 's'; + (void)strcpy((*output) + 4, str); + str = *output; + } else { + *output = strdup(str); + if (*output == NULL) + return 0; } -#define ADD_STRING(what, len) \ + +#define ADD_STRING(what, len) \ { \ - if (idx + len + 1 > size) \ - result = realloc(result, (size += len + 1)); \ + if (idx + len + 1 > size) { \ + char *nresult = realloc(result, (size += len + 1));\ + if (nresult == NULL) { \ + free(*output); \ + return 0; \ + } \ + result = nresult; \ + } \ (void)strncpy(&result[idx], what, len); \ idx += len; \ result[idx] = '\0'; \ @@ -626,9 +842,10 @@ history_expand(str, output) result = NULL; size = idx = 0; for (i = 0; str[i];) { - int start, j, loop_again; - size_t len; + int qchar, loop_again; + size_t len, start, j; + qchar = 0; loop_again = 1; start = j = i; loop: @@ -639,22 +856,21 @@ loop: continue; } if (!loop_again) { - if (str[j] == '?') { - while (str[j] && str[++j] != '?'); - if (str[j] == '?') - j++; - } else if (isspace((unsigned char) str[j])) + if (isspace((unsigned char) str[j]) + || str[j] == qchar) break; } if (str[j] == history_expansion_char && !strchr(history_no_expand_chars, str[j + 1]) && (!history_inhibit_expansion_function || - (*history_inhibit_expansion_function) (str, j) == 0)) + (*history_inhibit_expansion_function)(str, + (int)j) == 0)) break; } - if (str[j] && str[j + 1] != '#' && loop_again) { + if (str[j] && loop_again) { i = j; + qchar = (j > 0 && str[j - 1] == '"' )? '"':0; j++; if (str[j] == history_expansion_char) j++; @@ -662,95 +878,165 @@ loop: goto loop; } len = i - start; - temp = &str[start]; - ADD_STRING(temp, len); + tmp = &str[start]; + ADD_STRING(tmp, len); - if (str[i] == '\0' || str[i] != history_expansion_char - || str[i + 1] == '#') { + if (str[i] == '\0' || str[i] != history_expansion_char) { len = j - i; - temp = &str[i]; - ADD_STRING(temp, len); + tmp = &str[i]; + ADD_STRING(tmp, len); if (start == 0) - retval = 0; + ret = 0; else - retval = 1; + ret = 1; break; } - retval = _history_expand_command(&str[i], (size_t)(j - i), - &temp); - if (retval != -1) { - len = strlen(temp); - ADD_STRING(temp, len); + ret = _history_expand_command (str, i, (j - i), &tmp); + if (ret > 0 && tmp) { + len = strlen(tmp); + ADD_STRING(tmp, len); + free(tmp); } i = j; - } /* for(i ...) */ + } - if (retval == 2) { - add_history(temp); + /* ret is 2 for "print only" option */ + if (ret == 2) { + add_history(result); #ifdef GDB_411_HACK /* gdb 4.11 has been shipped with readline, where */ /* history_expand() returned -1 when the line */ /* should not be executed; in readline 2.1+ */ /* it should return 2 in such a case */ - retval = -1; + ret = -1; #endif } free(*output); *output = result; - return retval; + return (ret); +} + +/* +* Return a string consisting of arguments of "str" from "start" to "end". +*/ +char * +history_arg_extract(int start, int end, const char *str) +{ + size_t i, len, max; + char **arr, *result; + + arr = history_tokenize(str); + if (!arr) + return(NULL); + if (arr && *arr == NULL) { + free(arr); + return(NULL); + } + + for (max = 0; arr[max]; max++) + continue; + max--; + + if (start == '$') + start = max; + if (end == '$') + end = max; + if (end < 0) + end = max + end + 1; + if (start < 0) + start = end; + + if (start < 0 || end < 0 || start > max || end > max || start > end) + return(NULL); + + for (i = start, len = 0; i <= end; i++) + len += strlen(arr[i]) + 1; + len++; + result = malloc(len); + if (result == NULL) + return NULL; + + for (i = start, len = 0; i <= end; i++) { + (void)strcpy(result + len, arr[i]); + len += strlen(arr[i]); + if (i < end) + result[len++] = ' '; + } + result[len] = 0; + + for (i = 0; arr[i]; i++) + free(arr[i]); + free(arr); + + return(result); } /* - * Parse the string into individual tokens, similarily to how shell would do it. + * Parse the string into individual tokens, + * similar to how shell would do it. */ char ** -history_tokenize(str) - const char *str; +history_tokenize(const char *str) { - int size = 1, result_idx = 0, i, start; + int size = 1, idx = 0, i, start; size_t len; char **result = NULL, *temp, delim = '\0'; - for (i = 0; str[i]; i++) { + for (i = 0; str[i];) { while (isspace((unsigned char) str[i])) i++; start = i; - for (; str[i]; i++) { + for (; str[i];) { if (str[i] == '\\') { - if (str[i] != '\0') + if (str[i+1] != '\0') i++; } else if (str[i] == delim) delim = '\0'; else if (!delim && - (isspace((unsigned char) str[i]) || - strchr("()<>;&|$", str[i]))) + (isspace((unsigned char) str[i]) || + strchr("()<>;&|$", str[i]))) break; else if (!delim && strchr("'`\"", str[i])) delim = str[i]; + if (str[i]) + i++; } - if (result_idx + 2 >= size) { + if (idx + 2 >= size) { + char **nresult; size <<= 1; - result = realloc(result, size * sizeof(char *)); + nresult = realloc(result, size * sizeof(char *)); + if (nresult == NULL) { + free(result); + return NULL; + } + result = nresult; } len = i - start; temp = malloc(len + 1); + if (temp == NULL) { + for (i = 0; i < idx; i++) + free(result[i]); + free(result); + return NULL; + } (void)strncpy(temp, &str[start], len); temp[len] = '\0'; - result[result_idx++] = temp; - result[result_idx] = NULL; + result[idx++] = temp; + result[idx] = NULL; + if (str[i]) + i++; } - - return result; + return (result); } + /* * limit size of history record to ``max'' events */ void -stifle_history(max) - int max; +stifle_history(int max) { HistEvent ev; @@ -761,11 +1047,12 @@ stifle_history(max) max_input_history = max; } + /* * "unlimit" size of history - set the limit to maximum allowed int value */ int -unstifle_history() +unstifle_history(void) { HistEvent ev; int omax; @@ -773,121 +1060,149 @@ unstifle_history() history(h, &ev, H_SETSIZE, INT_MAX); omax = max_input_history; max_input_history = INT_MAX; - return omax; /* some value _must_ be returned */ + return (omax); /* some value _must_ be returned */ } + int -history_is_stifled() +history_is_stifled(void) { + /* cannot return true answer */ return (max_input_history != INT_MAX); } + /* * read history from a file given */ int -read_history(filename) - const char *filename; +read_history(const char *filename) { HistEvent ev; if (h == NULL || e == NULL) rl_initialize(); - return history(h, &ev, H_LOAD, filename); + return (history(h, &ev, H_LOAD, filename)); } + /* * write history to a file given */ int -write_history(filename) - const char *filename; +write_history(const char *filename) { HistEvent ev; if (h == NULL || e == NULL) rl_initialize(); - return history(h, &ev, H_SAVE, filename); + return (history(h, &ev, H_SAVE, filename)); } + /* * returns history ``num''th event * * returned pointer points to static variable */ HIST_ENTRY * -history_get(num) - int num; +history_get(int num) { static HIST_ENTRY she; HistEvent ev; - int i = 1, curr_num; + int curr_num; if (h == NULL || e == NULL) rl_initialize(); - /* rewind to beginning */ + /* save current position */ if (history(h, &ev, H_CURR) != 0) - return NULL; + return (NULL); curr_num = ev.num; - if (history(h, &ev, H_LAST) != 0) - return NULL; /* error */ - while (i < num && history(h, &ev, H_PREV) == 0) - i++; - if (i != num) - return NULL; /* not so many entries */ + + /* start from most recent */ + if (history(h, &ev, H_FIRST) != 0) + return (NULL); /* error */ + + /* look backwards for event matching specified offset */ + if (history(h, &ev, H_NEXT_EVENT, num)) + return (NULL); she.line = ev.str; she.data = NULL; - /* rewind history to the same event it was before */ - (void) history(h, &ev, H_FIRST); - (void) history(h, &ev, H_NEXT_EVENT, curr_num); + /* restore pointer to where it was */ + (void)history(h, &ev, H_SET, curr_num); - return &she; + return (&she); } + /* * add the line to history table */ int -add_history(line) - const char *line; +add_history(const char *line) { HistEvent ev; if (h == NULL || e == NULL) rl_initialize(); - (void) history(h, &ev, H_ENTER, line); + (void)history(h, &ev, H_ENTER, line); if (history(h, &ev, H_GETSIZE) == 0) history_length = ev.num; - return (!(history_length > 0)); /* return 0 if all is okay */ + return (!(history_length > 0)); /* return 0 if all is okay */ } + +/* + * remove the specified entry from the history list and return it. + */ +HIST_ENTRY * +remove_history(int num) +{ + static HIST_ENTRY she; + HistEvent ev; + + if (h == NULL || e == NULL) + rl_initialize(); + + if (history(h, &ev, H_DEL, num) != 0) + return NULL; + + she.line = ev.str; + she.data = NULL; + + return &she; +} + + /* * clear the history list - delete all entries */ void -clear_history() +clear_history(void) { HistEvent ev; + history(h, &ev, H_CLEAR); } + /* * returns offset of the current history event */ int -where_history() +where_history(void) { HistEvent ev; int curr_num, off; if (history(h, &ev, H_CURR) != 0) - return 0; + return (0); curr_num = ev.num; history(h, &ev, H_FIRST); @@ -895,29 +1210,32 @@ where_history() while (ev.num != curr_num && history(h, &ev, H_NEXT) == 0) off++; - return off; + return (off); } + /* * returns current history event or NULL if there is no such event */ HIST_ENTRY * -current_history() +current_history(void) { - return _move_history(H_CURR); + + return (_move_history(H_CURR)); } + /* * returns total number of bytes history events' data are using */ int -history_total_bytes() +history_total_bytes(void) { HistEvent ev; int curr_num, size; if (history(h, &ev, H_CURR) != 0) - return -1; + return (-1); curr_num = ev.num; history(h, &ev, H_FIRST); @@ -929,133 +1247,118 @@ history_total_bytes() /* get to the same position as before */ history(h, &ev, H_PREV_EVENT, curr_num); - return size; + return (size); } + /* * sets the position in the history list to ``pos'' */ int -history_set_pos(pos) - int pos; +history_set_pos(int pos) { HistEvent ev; - int off, curr_num; + int curr_num; if (pos > history_length || pos < 0) - return -1; + return (-1); history(h, &ev, H_CURR); curr_num = ev.num; - history(h, &ev, H_FIRST); - off = 0; - while (off < pos && history(h, &ev, H_NEXT) == 0) - off++; - if (off != pos) { /* do a rollback in case of error */ - history(h, &ev, H_FIRST); - history(h, &ev, H_NEXT_EVENT, curr_num); - return -1; + if (history(h, &ev, H_SET, pos)) { + history(h, &ev, H_SET, curr_num); + return(-1); } - return 0; + return (0); } + /* * returns previous event in history and shifts pointer accordingly */ HIST_ENTRY * -previous_history() +previous_history(void) { - return _move_history(H_PREV); + + return (_move_history(H_PREV)); } + /* * returns next event in history and shifts pointer accordingly */ HIST_ENTRY * -next_history() +next_history(void) { - return _move_history(H_NEXT); + + return (_move_history(H_NEXT)); } + /* - * generic history search function + * searches for first history event containing the str */ -static int -_history_search_gen(str, direction, pos) - const char *str; - int direction, pos; -{ - HistEvent ev; - const char *strp; - int curr_num; +int +history_search(const char *str, int direction) +{ + HistEvent ev; + const char *strp; + int curr_num; if (history(h, &ev, H_CURR) != 0) - return -1; + return (-1); curr_num = ev.num; for (;;) { - strp = strstr(ev.str, str); - if (strp && (pos < 0 || &ev.str[pos] == strp)) + if ((strp = strstr(ev.str, str)) != NULL) return (int) (strp - ev.str); - if (history(h, &ev, direction < 0 ? H_PREV : H_NEXT) != 0) + if (history(h, &ev, direction < 0 ? H_NEXT:H_PREV) != 0) break; } - - history(h, &ev, direction < 0 ? H_NEXT_EVENT : H_PREV_EVENT, curr_num); - - return -1; + history(h, &ev, H_SET, curr_num); + return (-1); } -/* - * searches for first history event containing the str - */ -int -history_search(str, direction) - const char *str; - int direction; -{ - return _history_search_gen(str, direction, -1); -} /* * searches for first history event beginning with str */ int -history_search_prefix(str, direction) - const char *str; - int direction; +history_search_prefix(const char *str, int direction) { - return _history_search_gen(str, direction, 0); + HistEvent ev; + + return (history(h, &ev, direction < 0? H_PREV_STR:H_NEXT_STR, str)); } + /* * search for event in history containing str, starting at offset * abs(pos); continue backward, if pos<0, forward otherwise */ /* ARGSUSED */ int -history_search_pos(str, direction, pos) - const char *str; - int direction, pos; +history_search_pos(const char *str, + int direction __attribute__((__unused__)), int pos) { - HistEvent ev; - int curr_num, off; + HistEvent ev; + int curr_num, off; off = (pos > 0) ? pos : -pos; pos = (pos > 0) ? 1 : -1; if (history(h, &ev, H_CURR) != 0) - return -1; + return (-1); curr_num = ev.num; if (history_set_pos(off) != 0 || history(h, &ev, H_CURR) != 0) - return -1; + return (-1); for (;;) { if (strstr(ev.str, str)) - return off; + return (off); if (history(h, &ev, (pos < 0) ? H_PREV : H_NEXT) != 0) break; } @@ -1063,144 +1366,23 @@ history_search_pos(str, direction, pos) /* set "current" pointer back to previous state */ history(h, &ev, (pos < 0) ? H_NEXT_EVENT : H_PREV_EVENT, curr_num); - return -1; + return (-1); } /********************************/ -/* completition functions */ +/* completion functions */ -/* - * does tilde expansion of strings of type ``~user/foo'' - * if ``user'' isn't valid user name or ``txt'' doesn't start - * w/ '~', returns pointer to strdup()ed copy of ``txt'' - * - * it's callers's responsibility to free() returned string - */ char * -tilde_expand(txt) - char *txt; +tilde_expand(char *name) { - struct passwd *pass; - char *temp; - size_t len = 0; - - if (txt[0] != '~') - return strdup(txt); - - temp = strchr(txt + 1, '/'); - if (temp == NULL) - temp = strdup(txt + 1); - else { - len = temp - txt + 1; /* text until string after slash */ - temp = malloc(len); - (void)strncpy(temp, txt + 1, len - 2); - temp[len - 2] = '\0'; - } - pass = getpwnam(temp); - free(temp); /* value no more needed */ - if (pass == NULL) - return strdup(txt); - - /* update pointer txt to point at string immedially following */ - /* first slash */ - txt += len; - - temp = malloc(strlen(pass->pw_dir) + 1 + strlen(txt) + 1); - (void)sprintf(temp, "%s/%s", pass->pw_dir, txt); - - return temp; + return fn_tilde_expand(name); } -/* - * return first found file name starting by the ``text'' or NULL if no - * such file can be found - * value of ``state'' is ignored - * - * it's caller's responsibility to free returned string - */ -char * -filename_completion_function(text, state) - const char *text; - int state; -{ - static DIR *dir = NULL; - static char *filename = NULL, *dirname = NULL; - static size_t filename_len = 0; - struct dirent *entry; - char *temp; - size_t len; - - if (state == 0 || dir == NULL) { - if (dir != NULL) { - closedir(dir); - dir = NULL; - } - temp = strrchr(text, '/'); - if (temp) { - temp++; - filename = realloc(filename, strlen(temp) + 1); - (void)strcpy(filename, temp); - len = temp - text; /* including last slash */ - dirname = realloc(dirname, len + 1); - (void)strncpy(dirname, text, len); - dirname[len] = '\0'; - } else { - filename = strdup(text); - dirname = NULL; - } - - /* support for ``~user'' syntax */ - if (dirname && *dirname == '~') { - temp = tilde_expand(dirname); - dirname = realloc(dirname, strlen(temp) + 1); - (void)strcpy(dirname, temp); /* safe */ - free(temp); /* no more needed */ - } - /* will be used in cycle */ - filename_len = strlen(filename); - if (filename_len == 0) - return NULL; /* no expansion possible */ - - dir = opendir(dirname ? dirname : "."); - if (!dir) - return NULL; /* cannot open the directory */ - } - /* find the match */ - while ((entry = readdir(dir)) != NULL) { - /* otherwise, get first entry where first */ - /* filename_len characters are equal */ - if (entry->d_name[0] == filename[0] -#if defined(__SVR4) || defined(__linux__) - && strlen(entry->d_name) >= filename_len -#else - && entry->d_namlen >= filename_len -#endif - && strncmp(entry->d_name, filename, - filename_len) == 0) - break; - } - - if (entry) { /* match found */ - - struct stat stbuf; -#if defined(__SVR4) || defined(__linux__) - len = strlen(entry->d_name) + -#else - len = entry->d_namlen + -#endif - ((dirname) ? strlen(dirname) : 0) + 1 + 1; - temp = malloc(len); - (void)sprintf(temp, "%s%s", - dirname ? dirname : "", entry->d_name); /* safe */ - - /* test, if it's directory */ - if (stat(temp, &stbuf) == 0 && S_ISDIR(stbuf.st_mode)) - strcat(temp, "/"); /* safe */ - } else - temp = NULL; - - return temp; +char * +filename_completion_function(const char *name, int state) +{ + return fn_filename_completion_function(name, state); } /* @@ -1210,15 +1392,14 @@ filename_completion_function(text, state * (usually '~'); state is ignored * it's callers responsibility to free returned value */ -char * -username_completion_function(text, state) - const char *text; - int state; +char * +username_completion_function(const char *text, int state) { - struct passwd *pwd; + struct passwd *pwd, pwres; + char pwbuf[1024]; if (text[0] == '\0') - return NULL; + return (NULL); if (*text == '~') text++; @@ -1226,171 +1407,86 @@ username_completion_function(text, state if (state == 0) setpwent(); - while ((pwd = getpwent()) && text[0] == pwd->pw_name[0] - && strcmp(text, pwd->pw_name) == 0); + while (getpwent_r(&pwres, pwbuf, sizeof(pwbuf), &pwd) == 0 + && pwd != NULL && text[0] == pwd->pw_name[0] + && strcmp(text, pwd->pw_name) == 0); if (pwd == NULL) { endpwent(); - return NULL; + return (NULL); } - return strdup(pwd->pw_name); + return (strdup(pwd->pw_name)); } + /* - * el-compatible wrapper around rl_complete; needed for key binding + * el-compatible wrapper to send TSTP on ^Z */ /* ARGSUSED */ static unsigned char -_el_rl_complete(el, ch) - EditLine *el; - int ch; +_el_rl_tstp(EditLine *el __attribute__((__unused__)), int ch __attribute__((__unused__))) { - return (unsigned char) rl_complete(0, ch); + (void)kill(0, SIGTSTP); + return CC_NORM; } /* - * returns list of completitions for text given + * Display list of strings in columnar format on readline's output stream. + * 'matches' is list of strings, 'len' is number of strings in 'matches', + * 'max' is maximum length of string in 'matches'. */ -char ** -completion_matches(text, genfunc) - const char *text; - CPFunction *genfunc; +void +rl_display_match_list(char **matches, int len, int max) { - char **match_list = NULL, *retstr, *prevstr; - size_t math_list_len, max_equal, which, i; - int matches; - - if (h == NULL || e == NULL) - rl_initialize(); - - matches = 0; - math_list_len = 1; - while ((retstr = (*genfunc) (text, matches)) != NULL) { - if (matches + 1 >= math_list_len) { - math_list_len <<= 1; - match_list = realloc(match_list, - math_list_len * sizeof(char *)); - } - match_list[++matches] = retstr; - } - - if (!match_list) - return (char **) NULL; /* nothing found */ - /* find least denominator and insert it to match_list[0] */ - which = 2; - prevstr = match_list[1]; - max_equal = strlen(prevstr); - for (; which < matches; which++) { - for (i = 0; i < max_equal && - prevstr[i] == match_list[which][i]; i++) - continue; - max_equal = i; - } - - retstr = malloc(max_equal + 1); - (void)strncpy(retstr, match_list[1], max_equal); - retstr[max_equal] = '\0'; - match_list[0] = retstr; - - /* add NULL as last pointer to the array */ - if (matches + 1 >= math_list_len) - match_list = realloc(match_list, - (math_list_len + 1) * sizeof(char *)); - match_list[matches + 1] = (char *) NULL; - - return match_list; + fn_display_match_list(e, matches, len, max); } -/* - * called by rl_complete() - */ -/* ARGSUSED */ -static int -rl_complete_internal(what_to_do) - int what_to_do; +static const char * +/*ARGSUSED*/ +_rl_completion_append_character_function(const char *dummy + __attribute__((__unused__))) { - CPFunction *complet_func; - const LineInfo *li; - char *temp, *temp2, **arr; - size_t len; - - if (h == NULL || e == NULL) - rl_initialize(); - - complet_func = rl_completion_entry_function; - if (!complet_func) - complet_func = filename_completion_function; - - li = el_line(e); - /* LINTED const cast */ - temp = (char *) li->cursor; - while (temp > li->buffer && - !strchr(rl_basic_word_break_characters, *(temp - 1))) - temp--; - - len = li->cursor - temp; - temp2 = alloca(len + 1); - (void)strncpy(temp2, temp, len); - temp = temp2; - temp[len] = '\0'; - - /* these can be used by function called in completion_matches() */ - /* or (*rl_attempted_completion_function)() */ - rl_point = li->cursor - li->buffer; - rl_end = li->lastchar - li->buffer; - - if (!rl_attempted_completion_function) - arr = completion_matches(temp, complet_func); - else { - int end = li->cursor - li->buffer; - arr = (*rl_attempted_completion_function) (temp, (int) - (end - len), end); - } - - if (arr) { - int i; - - el_deletestr(e, (int)len); - el_insertstr(e, arr[0]); - if (strcmp(arr[0], arr[1]) == 0) { - /* lcd is valid object, so add a space to mark it */ - /* in case of filename completition, add a space */ - /* only if object found is not directory */ - size_t alen = strlen(arr[0]); - if (complet_func != filename_completion_function - || (alen > 0 && (arr[0])[alen - 1] != '/')) - el_insertstr(e, " "); - } else - /* lcd is not a valid object - further specification */ - /* is needed */ - el_beep(e); - - /* free elements of array and the array itself */ - for (i = 0; arr[i]; i++) - free(arr[i]); - free(arr), arr = NULL; - - return CC_REFRESH; - } - return CC_NORM; + static char buf[2]; + buf[1] = rl_completion_append_character; + return buf; } + /* * complete word at current point */ +/* ARGSUSED */ int -rl_complete(ignore, invoking_key) - int ignore, invoking_key; +rl_complete(int ignore __attribute__((__unused__)), int invoking_key) { if (h == NULL || e == NULL) rl_initialize(); if (rl_inhibit_completion) { - rl_insert(ignore, invoking_key); - return CC_REFRESH; - } else - return rl_complete_internal(invoking_key); + char arr[2]; + arr[0] = (char)invoking_key; + arr[1] = '\0'; + el_insertstr(e, arr); + return (CC_REFRESH); + } + + /* Just look at how many global variables modify this operation! */ + return fn_complete(e, + (CPFunction *)rl_completion_entry_function, + rl_attempted_completion_function, + rl_basic_word_break_characters, rl_special_prefixes, + _rl_completion_append_character_function, rl_completion_query_items, + &rl_completion_type, &rl_attempted_completion_over, + &rl_point, &rl_end); +} + + +/* ARGSUSED */ +static unsigned char +_el_rl_complete(EditLine *el __attribute__((__unused__)), int ch) +{ + return (unsigned char)rl_complete(0, ch); } /* @@ -1401,11 +1497,9 @@ rl_complete(ignore, invoking_key) * bind key c to readline-type function func */ int -rl_bind_key(c, func) - int c; - int func __P((int, int)); +rl_bind_key(int c, int func(int, int)) { - int retval = -1; + int retval = -1; if (h == NULL || e == NULL) rl_initialize(); @@ -1415,45 +1509,47 @@ rl_bind_key(c, func) e->el_map.key[c] = ED_INSERT; retval = 0; } - return retval; + return (retval); } + /* * read one key from input - handles chars pushed back * to input stream also */ int -rl_read_key() +rl_read_key(void) { - char fooarr[2 * sizeof(int)]; + char fooarr[2 * sizeof(int)]; if (e == NULL || h == NULL) rl_initialize(); - return el_getc(e, fooarr); + return (el_getc(e, fooarr)); } + /* * reset the terminal */ /* ARGSUSED */ void -rl_reset_terminal(p) - const char *p; +rl_reset_terminal(const char *p __attribute__((__unused__))) { + if (h == NULL || e == NULL) rl_initialize(); el_reset(e); } + /* * insert character ``c'' back into input stream, ``count'' times */ int -rl_insert(count, c) - int count, c; +rl_insert(int count, int c) { - char arr[2]; + char arr[2]; if (h == NULL || e == NULL) rl_initialize(); @@ -1465,5 +1561,215 @@ rl_insert(count, c) for (; count > 0; count--) el_push(e, arr); + return (0); +} + +/*ARGSUSED*/ +int +rl_newline(int count, int c) +{ + /* + * Readline-4.0 appears to ignore the args. + */ + return rl_insert(1, '\n'); +} + +/*ARGSUSED*/ +static unsigned char +rl_bind_wrapper(EditLine *el, unsigned char c) +{ + if (map[c] == NULL) + return CC_ERROR; + + _rl_update_pos(); + + (*map[c])(NULL, c); + + /* If rl_done was set by the above call, deal with it here */ + if (rl_done) + return CC_EOF; + + return CC_NORM; +} + +int +rl_add_defun(const char *name, Function *fun, int c) +{ + char dest[8]; + if (c >= sizeof(map) / sizeof(map[0]) || c < 0) + return -1; + map[(unsigned char)c] = fun; + el_set(e, EL_ADDFN, name, name, rl_bind_wrapper); + vis(dest, c, VIS_WHITE|VIS_NOSLASH, 0); + el_set(e, EL_BIND, dest, name); return 0; } + +void +rl_callback_read_char() +{ + int count = 0, done = 0; + const char *buf = el_gets(e, &count); + char *wbuf; + + if (buf == NULL || count-- <= 0) + return; + if (count == 0 && buf[0] == CTRL('d')) + done = 1; + if (buf[count] == '\n' || buf[count] == '\r') + done = 2; + + if (done && rl_linefunc != NULL) { + el_set(e, EL_UNBUFFERED, 0); + if (done == 2) { + if ((wbuf = strdup(buf)) != NULL) + wbuf[count] = '\0'; + } else + wbuf = NULL; + (*(void (*)(const char *))rl_linefunc)(wbuf); + el_set(e, EL_UNBUFFERED, 1); + } +} + +void +rl_callback_handler_install (const char *prompt, VCPFunction *linefunc) +{ + if (e == NULL) { + rl_initialize(); + } + if (rl_prompt) + free(rl_prompt); + rl_prompt = prompt ? strdup(strchr(prompt, *prompt)) : NULL; + rl_linefunc = linefunc; + el_set(e, EL_UNBUFFERED, 1); +} + +void +rl_callback_handler_remove(void) +{ + el_set(e, EL_UNBUFFERED, 0); +} + +void +rl_redisplay(void) +{ + char a[2]; + a[0] = CTRL('r'); + a[1] = '\0'; + el_push(e, a); +} + +int +rl_get_previous_history(int count, int key) +{ + char a[2]; + a[0] = key; + a[1] = '\0'; + while (count--) + el_push(e, a); + return 0; +} + +void +/*ARGSUSED*/ +rl_prep_terminal(int meta_flag) +{ + el_set(e, EL_PREP_TERM, 1); +} + +void +rl_deprep_terminal() +{ + el_set(e, EL_PREP_TERM, 0); +} + +int +rl_read_init_file(const char *s) +{ + return(el_source(e, s)); +} + +int +rl_parse_and_bind(const char *line) +{ + const char **argv; + int argc; + Tokenizer *tok; + + tok = tok_init(NULL); + tok_str(tok, line, &argc, &argv); + argc = el_parse(e, argc, argv); + tok_end(tok); + return (argc ? 1 : 0); +} + +int +rl_variable_bind(const char *var, const char *value) +{ + /* + * The proper return value is undocument, but this is what the + * readline source seems to do. + */ + return ((el_set(e, EL_BIND, "", var, value) == -1) ? 1 : 0); +} + +void +rl_stuff_char(int c) +{ + char buf[2]; + + buf[0] = c; + buf[1] = '\0'; + el_insertstr(e, buf); +} + +static int +_rl_event_read_char(EditLine *el, char *cp) +{ + int n, num_read = 0; + + *cp = 0; + while (rl_event_hook) { + + (*rl_event_hook)(); + +#if defined(FIONREAD) + if (ioctl(el->el_infd, FIONREAD, &n) < 0) + return(-1); + if (n) + num_read = read(el->el_infd, cp, 1); + else + num_read = 0; +#elif defined(F_SETFL) && defined(O_NDELAY) + if ((n = fcntl(el->el_infd, F_GETFL, 0)) < 0) + return(-1); + if (fcntl(el->el_infd, F_SETFL, n|O_NDELAY) < 0) + return(-1); + num_read = read(el->el_infd, cp, 1); + if (fcntl(el->el_infd, F_SETFL, n)) + return(-1); +#else + /* not non-blocking, but what you gonna do? */ + num_read = read(el->el_infd, cp, 1); + return(-1); +#endif + + if (num_read < 0 && errno == EAGAIN) + continue; + if (num_read == 0) + continue; + break; + } + if (!rl_event_hook) + el_set(el, EL_GETCFN, EL_BUILTIN_GETCFN); + return(num_read); +} + +static void +_rl_update_pos(void) +{ + const LineInfo *li = el_line(e); + + rl_point = li->cursor - li->buffer; + rl_end = li->lastchar - li->buffer; +}