version 1.14, 2001/01/01 11:03:16 |
version 1.31, 2003/06/19 16:04:57 |
|
|
* POSSIBILITY OF SUCH DAMAGE. |
* POSSIBILITY OF SUCH DAMAGE. |
*/ |
*/ |
|
|
#include <sys/cdefs.h> |
#include "config.h" |
#if !defined(lint) && !defined(SCCSID) |
#if !defined(lint) && !defined(SCCSID) |
__RCSID("$NetBSD$"); |
__RCSID("$NetBSD$"); |
#endif /* not lint && not SCCSID */ |
#endif /* not lint && not SCCSID */ |
Line 51 __RCSID("$NetBSD$"); |
|
Line 51 __RCSID("$NetBSD$"); |
|
#include <stdlib.h> |
#include <stdlib.h> |
#include <unistd.h> |
#include <unistd.h> |
#include <limits.h> |
#include <limits.h> |
|
#ifdef HAVE_ALLOCA_H |
|
#include <alloca.h> |
|
#endif |
#include "histedit.h" |
#include "histedit.h" |
#include "readline.h" |
#include "readline/readline.h" |
#include "sys.h" |
|
#include "el.h" |
#include "el.h" |
#include "fcns.h" /* for EL_NUM_FCNS */ |
#include "fcns.h" /* for EL_NUM_FCNS */ |
|
|
Line 66 __RCSID("$NetBSD$"); |
|
Line 68 __RCSID("$NetBSD$"); |
|
/* readline compatibility stuff - look at readline sources/documentation */ |
/* readline compatibility stuff - look at readline sources/documentation */ |
/* to see what these variables mean */ |
/* to see what these variables mean */ |
const char *rl_library_version = "EditLine wrapper"; |
const char *rl_library_version = "EditLine wrapper"; |
char *rl_readline_name = ""; |
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_instream = NULL; |
FILE *rl_outstream = NULL; |
FILE *rl_outstream = NULL; |
int rl_point = 0; |
int rl_point = 0; |
Line 78 int history_length = 0; |
|
Line 84 int history_length = 0; |
|
int max_input_history = 0; |
int max_input_history = 0; |
char history_expansion_char = '!'; |
char history_expansion_char = '!'; |
char history_subst_char = '^'; |
char history_subst_char = '^'; |
char *history_no_expand_chars = " \t\n=("; |
char *history_no_expand_chars = expand_chars; |
Function *history_inhibit_expansion_function = NULL; |
Function *history_inhibit_expansion_function = NULL; |
|
|
int rl_inhibit_completion = 0; |
int rl_inhibit_completion = 0; |
int rl_attempted_completion_over = 0; |
int rl_attempted_completion_over = 0; |
char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; |
char *rl_basic_word_break_characters = break_chars; |
char *rl_completer_word_break_characters = NULL; |
char *rl_completer_word_break_characters = NULL; |
char *rl_completer_quote_characters = NULL; |
char *rl_completer_quote_characters = NULL; |
CPFunction *rl_completion_entry_function = NULL; |
CPFunction *rl_completion_entry_function = NULL; |
Line 103 int rl_completion_type = 0; |
|
Line 109 int rl_completion_type = 0; |
|
int rl_completion_query_items = 100; |
int rl_completion_query_items = 100; |
|
|
/* |
/* |
* If not zero, non-unique completions always show list of possible matches. |
* 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 = (char *)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 */ |
|
|
|
/* if not zero, non-unique completions always show list of possible matches */ |
static int _rl_complete_show_all = 0; |
static int _rl_complete_show_all = 0; |
|
|
/* used for readline emulation */ |
|
static History *h = NULL; |
static History *h = NULL; |
static EditLine *e = NULL; |
static EditLine *e = NULL; |
static int el_rl_complete_cmdnum = 0; |
static int el_rl_complete_cmdnum = 0; |
Line 131 static char *el_rl_prompt = NULL; |
|
Line 149 static char *el_rl_prompt = NULL; |
|
|
|
/* ARGSUSED */ |
/* ARGSUSED */ |
static char * |
static char * |
_get_prompt(EditLine *el) |
_get_prompt(EditLine *el __attribute__((__unused__))) |
{ |
{ |
return (el_rl_prompt); |
return (el_rl_prompt); |
} |
} |
Line 169 rl_initialize(void) |
|
Line 187 rl_initialize(void) |
|
HistEvent ev; |
HistEvent ev; |
const LineInfo *li; |
const LineInfo *li; |
int i; |
int i; |
|
int editmode = 1; |
|
struct termios t; |
|
|
if (e != NULL) |
if (e != NULL) |
el_end(e); |
el_end(e); |
Line 179 rl_initialize(void) |
|
Line 199 rl_initialize(void) |
|
rl_instream = stdin; |
rl_instream = stdin; |
if (!rl_outstream) |
if (!rl_outstream) |
rl_outstream = stdout; |
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); |
e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr); |
|
|
|
if (!editmode) |
|
el_set(e, EL_EDITMODE, 0); |
|
|
h = history_init(); |
h = history_init(); |
if (!e || !h) |
if (!e || !h) |
return (-1); |
return (-1); |
Line 192 rl_initialize(void) |
|
Line 222 rl_initialize(void) |
|
|
|
/* for proper prompt printing in readline() */ |
/* for proper prompt printing in readline() */ |
el_rl_prompt = strdup(""); |
el_rl_prompt = strdup(""); |
|
if (el_rl_prompt == NULL) { |
|
history_end(h); |
|
el_end(e); |
|
return -1; |
|
} |
el_set(e, EL_PROMPT, _get_prompt); |
el_set(e, EL_PROMPT, _get_prompt); |
el_set(e, EL_SIGNAL, 1); |
el_set(e, EL_SIGNAL, 1); |
|
|
Line 227 rl_initialize(void) |
|
Line 262 rl_initialize(void) |
|
* and rl_line_buffer directly. |
* and rl_line_buffer directly. |
*/ |
*/ |
li = el_line(e); |
li = el_line(e); |
/* LINTED const cast */ |
/* a cheesy way to get rid of const cast. */ |
rl_line_buffer = (char *) li->buffer; |
rl_line_buffer = memchr(li->buffer, *li->buffer, 1); |
rl_point = rl_end = 0; |
rl_point = rl_end = 0; |
|
|
return (0); |
return (0); |
Line 245 readline(const char *prompt) |
|
Line 280 readline(const char *prompt) |
|
HistEvent ev; |
HistEvent ev; |
int count; |
int count; |
const char *ret; |
const char *ret; |
|
char *buf; |
|
|
if (e == NULL || h == NULL) |
if (e == NULL || h == NULL) |
rl_initialize(); |
rl_initialize(); |
Line 255 readline(const char *prompt) |
|
Line 291 readline(const char *prompt) |
|
if (strcmp(el_rl_prompt, prompt) != 0) { |
if (strcmp(el_rl_prompt, prompt) != 0) { |
free(el_rl_prompt); |
free(el_rl_prompt); |
el_rl_prompt = strdup(prompt); |
el_rl_prompt = strdup(prompt); |
|
if (el_rl_prompt == NULL) |
|
return NULL; |
} |
} |
/* get one line from input stream */ |
/* get one line from input stream */ |
ret = el_gets(e, &count); |
ret = el_gets(e, &count); |
|
|
if (ret && count > 0) { |
if (ret && count > 0) { |
char *foo; |
|
int lastidx; |
int lastidx; |
|
|
foo = strdup(ret); |
buf = strdup(ret); |
|
if (buf == NULL) |
|
return NULL; |
lastidx = count - 1; |
lastidx = count - 1; |
if (foo[lastidx] == '\n') |
if (buf[lastidx] == '\n') |
foo[lastidx] = '\0'; |
buf[lastidx] = '\0'; |
|
|
ret = foo; |
|
} else |
} else |
ret = NULL; |
buf = NULL; |
|
|
history(h, &ev, H_GETSIZE); |
history(h, &ev, H_GETSIZE); |
history_length = ev.num; |
history_length = ev.num; |
|
|
/* LINTED const cast */ |
return buf; |
return (char *) ret; |
|
} |
} |
|
|
/* |
/* |
Line 297 using_history(void) |
|
Line 333 using_history(void) |
|
|
|
/* |
/* |
* substitute ``what'' with ``with'', returning resulting string; if |
* 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 |
* first one |
*/ |
*/ |
static char * |
static char * |
Line 306 _rl_compat_sub(const char *str, const ch |
|
Line 342 _rl_compat_sub(const char *str, const ch |
|
{ |
{ |
char *result; |
char *result; |
const char *temp, *new; |
const char *temp, *new; |
int len, with_len, what_len, add; |
size_t len, with_len, what_len, add; |
size_t size, i; |
size_t size, i; |
|
|
result = malloc((size = 16)); |
result = malloc((size = 16)); |
|
if (result == NULL) |
|
return NULL; |
temp = str; |
temp = str; |
with_len = strlen(with); |
with_len = strlen(with); |
what_len = strlen(what); |
what_len = strlen(what); |
Line 320 _rl_compat_sub(const char *str, const ch |
|
Line 358 _rl_compat_sub(const char *str, const ch |
|
i = new - temp; |
i = new - temp; |
add = i + with_len; |
add = i + with_len; |
if (i + add + 1 >= size) { |
if (i + add + 1 >= size) { |
|
char *nresult; |
size += add + 1; |
size += add + 1; |
result = realloc(result, size); |
nresult = realloc(result, size); |
|
if (nresult == NULL) { |
|
free(result); |
|
return NULL; |
|
} |
|
result = nresult; |
} |
} |
(void) strncpy(&result[len], temp, i); |
(void) strncpy(&result[len], temp, i); |
len += i; |
len += i; |
Line 331 _rl_compat_sub(const char *str, const ch |
|
Line 375 _rl_compat_sub(const char *str, const ch |
|
} else { |
} else { |
add = strlen(temp); |
add = strlen(temp); |
if (len + add + 1 >= size) { |
if (len + add + 1 >= size) { |
|
char *nresult; |
size += add + 1; |
size += add + 1; |
result = realloc(result, size); |
nresult = realloc(result, size); |
|
if (nresult == NULL) { |
|
free(result); |
|
return NULL; |
|
} |
|
result = nresult; |
} |
} |
(void) strcpy(&result[len], temp); /* safe */ |
(void) strcpy(&result[len], temp); /* safe */ |
len += add; |
len += add; |
Line 475 _history_expand_command(const char *comm |
|
Line 525 _history_expand_command(const char *comm |
|
cmd++; |
cmd++; |
|
|
line = strdup(event_data); |
line = strdup(event_data); |
|
if (line == NULL) |
|
return 0; |
for (; *cmd; cmd++) { |
for (; *cmd; cmd++) { |
if (*cmd == ':') |
if (*cmd == ':') |
continue; |
continue; |
Line 492 _history_expand_command(const char *comm |
|
Line 544 _history_expand_command(const char *comm |
|
g_on = 2; |
g_on = 2; |
else if (*cmd == 's' || *cmd == '&') { |
else if (*cmd == 's' || *cmd == '&') { |
char *what, *with, delim; |
char *what, *with, delim; |
int len, from_len; |
size_t len, from_len; |
size_t size; |
size_t size; |
|
|
if (*cmd == '&' && (from == NULL || to == NULL)) |
if (*cmd == '&' && (from == NULL || to == NULL)) |
Line 501 _history_expand_command(const char *comm |
|
Line 553 _history_expand_command(const char *comm |
|
delim = *(++cmd), cmd++; |
delim = *(++cmd), cmd++; |
size = 16; |
size = 16; |
what = realloc(from, size); |
what = realloc(from, size); |
|
if (what == NULL) { |
|
free(from); |
|
return 0; |
|
} |
len = 0; |
len = 0; |
for (; *cmd && *cmd != delim; cmd++) { |
for (; *cmd && *cmd != delim; cmd++) { |
if (*cmd == '\\' |
if (*cmd == '\\' |
&& *(cmd + 1) == delim) |
&& *(cmd + 1) == delim) |
cmd++; |
cmd++; |
if (len >= size) |
if (len >= size) { |
what = realloc(what, |
char *nwhat; |
|
nwhat = realloc(what, |
(size <<= 1)); |
(size <<= 1)); |
|
if (nwhat == NULL) { |
|
free(what); |
|
return 0; |
|
} |
|
what = nwhat; |
|
} |
what[len++] = *cmd; |
what[len++] = *cmd; |
} |
} |
what[len] = '\0'; |
what[len] = '\0'; |
from = what; |
from = what; |
if (*what == '\0') { |
if (*what == '\0') { |
free(what); |
free(what); |
if (search) |
if (search) { |
from = strdup(search); |
from = strdup(search); |
else { |
if (from == NULL) |
|
return 0; |
|
} else { |
from = NULL; |
from = NULL; |
return (-1); |
return (-1); |
} |
} |
Line 528 _history_expand_command(const char *comm |
|
Line 593 _history_expand_command(const char *comm |
|
|
|
size = 16; |
size = 16; |
with = realloc(to, size); |
with = realloc(to, size); |
|
if (with == NULL) { |
|
free(to); |
|
return -1; |
|
} |
len = 0; |
len = 0; |
from_len = strlen(from); |
from_len = strlen(from); |
for (; *cmd && *cmd != delim; cmd++) { |
for (; *cmd && *cmd != delim; cmd++) { |
if (len + from_len + 1 >= size) { |
if (len + from_len + 1 >= size) { |
|
char *nwith; |
size += from_len + 1; |
size += from_len + 1; |
with = realloc(with, size); |
nwith = realloc(with, size); |
|
if (nwith == NULL) { |
|
free(with); |
|
return -1; |
|
} |
|
with = nwith; |
} |
} |
if (*cmd == '&') { |
if (*cmd == '&') { |
/* safe */ |
/* safe */ |
Line 552 _history_expand_command(const char *comm |
|
Line 627 _history_expand_command(const char *comm |
|
|
|
tempcmd = _rl_compat_sub(line, from, to, |
tempcmd = _rl_compat_sub(line, from, to, |
(g_on) ? 1 : 0); |
(g_on) ? 1 : 0); |
free(line); |
if (tempcmd) { |
line = tempcmd; |
free(line); |
|
line = tempcmd; |
|
} |
g_on = 0; |
g_on = 0; |
} |
} |
} |
} |
Line 599 _history_expand_command(const char *comm |
|
Line 676 _history_expand_command(const char *comm |
|
} |
} |
|
|
cmdsize = 1, cmdlen = 0; |
cmdsize = 1, cmdlen = 0; |
tempcmd = malloc(cmdsize); |
if ((tempcmd = malloc(cmdsize)) == NULL) |
|
return 0; |
for (i = start; start <= i && i <= end; i++) { |
for (i = start; start <= i && i <= end; i++) { |
int arr_len; |
int arr_len; |
|
|
arr_len = strlen(arr[i]); |
arr_len = strlen(arr[i]); |
if (cmdlen + arr_len + 1 >= cmdsize) { |
if (cmdlen + arr_len + 1 >= cmdsize) { |
|
char *ntempcmd; |
cmdsize += arr_len + 1; |
cmdsize += arr_len + 1; |
tempcmd = realloc(tempcmd, cmdsize); |
ntempcmd = realloc(tempcmd, cmdsize); |
|
if (ntempcmd == NULL) { |
|
free(tempcmd); |
|
return 0; |
|
} |
|
tempcmd = ntempcmd; |
} |
} |
(void) strcpy(&tempcmd[cmdlen], arr[i]); /* safe */ |
(void) strcpy(&tempcmd[cmdlen], arr[i]); /* safe */ |
cmdlen += arr_len; |
cmdlen += arr_len; |
Line 639 history_expand(char *str, char **output) |
|
Line 723 history_expand(char *str, char **output) |
|
rl_initialize(); |
rl_initialize(); |
|
|
*output = strdup(str); /* do it early */ |
*output = strdup(str); /* do it early */ |
|
if (*output == NULL) |
|
return 0; |
|
|
if (str[0] == history_subst_char) { |
if (str[0] == history_subst_char) { |
/* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */ |
/* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */ |
Line 651 history_expand(char *str, char **output) |
|
Line 737 history_expand(char *str, char **output) |
|
} |
} |
#define ADD_STRING(what, len) \ |
#define ADD_STRING(what, len) \ |
{ \ |
{ \ |
if (idx + len + 1 > size) \ |
if (idx + len + 1 > size) { \ |
result = realloc(result, (size += len + 1)); \ |
char *nresult = realloc(result, (size += len + 1));\ |
|
if (nresult == NULL) { \ |
|
free(*output); \ |
|
return 0; \ |
|
} \ |
|
result = nresult; \ |
|
} \ |
(void)strncpy(&result[idx], what, len); \ |
(void)strncpy(&result[idx], what, len); \ |
idx += len; \ |
idx += len; \ |
result[idx] = '\0'; \ |
result[idx] = '\0'; \ |
Line 766 history_tokenize(const char *str) |
|
Line 858 history_tokenize(const char *str) |
|
} |
} |
|
|
if (result_idx + 2 >= size) { |
if (result_idx + 2 >= size) { |
|
char **nresult; |
size <<= 1; |
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; |
len = i - start; |
temp = malloc(len + 1); |
temp = malloc(len + 1); |
|
if (temp == NULL) { |
|
free(result); |
|
return NULL; |
|
} |
(void) strncpy(temp, &str[start], len); |
(void) strncpy(temp, &str[start], len); |
temp[len] = '\0'; |
temp[len] = '\0'; |
result[result_idx++] = temp; |
result[result_idx++] = temp; |
Line 1083 history_search_prefix(const char *str, i |
|
Line 1185 history_search_prefix(const char *str, i |
|
*/ |
*/ |
/* ARGSUSED */ |
/* ARGSUSED */ |
int |
int |
history_search_pos(const char *str, int direction, int pos) |
history_search_pos(const char *str, |
|
int direction __attribute__((__unused__)), int pos) |
{ |
{ |
HistEvent ev; |
HistEvent ev; |
int curr_num, off; |
int curr_num, off; |
Line 1134 tilde_expand(char *txt) |
|
Line 1237 tilde_expand(char *txt) |
|
return (strdup(txt)); |
return (strdup(txt)); |
|
|
temp = strchr(txt + 1, '/'); |
temp = strchr(txt + 1, '/'); |
if (temp == NULL) |
if (temp == NULL) { |
temp = strdup(txt + 1); |
temp = strdup(txt + 1); |
else { |
if (temp == NULL) |
|
return NULL; |
|
} else { |
len = temp - txt + 1; /* text until string after slash */ |
len = temp - txt + 1; /* text until string after slash */ |
temp = malloc(len); |
temp = malloc(len); |
|
if (temp == NULL) |
|
return NULL; |
(void) strncpy(temp, txt + 1, len - 2); |
(void) strncpy(temp, txt + 1, len - 2); |
temp[len - 2] = '\0'; |
temp[len - 2] = '\0'; |
} |
} |
Line 1152 tilde_expand(char *txt) |
|
Line 1259 tilde_expand(char *txt) |
|
txt += len; |
txt += len; |
|
|
temp = malloc(strlen(pass->pw_dir) + 1 + strlen(txt) + 1); |
temp = malloc(strlen(pass->pw_dir) + 1 + strlen(txt) + 1); |
|
if (temp == NULL) |
|
return NULL; |
(void) sprintf(temp, "%s/%s", pass->pw_dir, txt); |
(void) sprintf(temp, "%s/%s", pass->pw_dir, txt); |
|
|
return (temp); |
return (temp); |
Line 1176 filename_completion_function(const char |
|
Line 1285 filename_completion_function(const char |
|
size_t len; |
size_t len; |
|
|
if (state == 0 || dir == NULL) { |
if (state == 0 || dir == NULL) { |
if (dir != NULL) { |
|
closedir(dir); |
|
dir = NULL; |
|
} |
|
temp = strrchr(text, '/'); |
temp = strrchr(text, '/'); |
if (temp) { |
if (temp) { |
|
char *nptr; |
temp++; |
temp++; |
filename = realloc(filename, strlen(temp) + 1); |
nptr = realloc(filename, strlen(temp) + 1); |
|
if (nptr == NULL) { |
|
free(filename); |
|
return NULL; |
|
} |
|
filename = nptr; |
(void) strcpy(filename, temp); |
(void) strcpy(filename, temp); |
len = temp - text; /* including last slash */ |
len = temp - text; /* including last slash */ |
dirname = realloc(dirname, len + 1); |
nptr = realloc(dirname, len + 1); |
|
if (nptr == NULL) { |
|
free(filename); |
|
return NULL; |
|
} |
|
dirname = nptr; |
(void) strncpy(dirname, text, len); |
(void) strncpy(dirname, text, len); |
dirname[len] = '\0'; |
dirname[len] = '\0'; |
} else { |
} else { |
filename = strdup(text); |
filename = strdup(text); |
|
if (filename == NULL) |
|
return NULL; |
dirname = NULL; |
dirname = NULL; |
} |
} |
|
|
/* support for ``~user'' syntax */ |
/* support for ``~user'' syntax */ |
if (dirname && *dirname == '~') { |
if (dirname && *dirname == '~') { |
|
char *nptr; |
temp = tilde_expand(dirname); |
temp = tilde_expand(dirname); |
dirname = realloc(dirname, strlen(temp) + 1); |
if (temp == NULL) |
|
return NULL; |
|
nptr = realloc(dirname, strlen(temp) + 1); |
|
if (nptr == NULL) { |
|
free(dirname); |
|
return NULL; |
|
} |
|
dirname = nptr; |
(void) strcpy(dirname, temp); /* safe */ |
(void) strcpy(dirname, temp); /* safe */ |
free(temp); /* no longer needed */ |
free(temp); /* no longer needed */ |
} |
} |
Line 1206 filename_completion_function(const char |
|
Line 1332 filename_completion_function(const char |
|
if (filename_len == 0) |
if (filename_len == 0) |
return (NULL); /* no expansion possible */ |
return (NULL); /* no expansion possible */ |
|
|
|
if (dir != NULL) { |
|
(void)closedir(dir); |
|
dir = NULL; |
|
} |
dir = opendir(dirname ? dirname : "."); |
dir = opendir(dirname ? dirname : "."); |
if (!dir) |
if (!dir) |
return (NULL); /* cannot open the directory */ |
return (NULL); /* cannot open the directory */ |
Line 1235 filename_completion_function(const char |
|
Line 1365 filename_completion_function(const char |
|
#endif |
#endif |
((dirname) ? strlen(dirname) : 0) + 1 + 1; |
((dirname) ? strlen(dirname) : 0) + 1 + 1; |
temp = malloc(len); |
temp = malloc(len); |
|
if (temp == NULL) |
|
return NULL; |
(void) sprintf(temp, "%s%s", |
(void) sprintf(temp, "%s%s", |
dirname ? dirname : "", entry->d_name); /* safe */ |
dirname ? dirname : "", entry->d_name); /* safe */ |
|
|
/* test, if it's directory */ |
/* test, if it's directory */ |
if (stat(temp, &stbuf) == 0 && S_ISDIR(stbuf.st_mode)) |
if (stat(temp, &stbuf) == 0 && S_ISDIR(stbuf.st_mode)) |
strcat(temp, "/"); /* safe */ |
strcat(temp, "/"); /* safe */ |
} else |
} else { |
|
(void)closedir(dir); |
|
dir = NULL; |
temp = NULL; |
temp = NULL; |
|
} |
|
|
return (temp); |
return (temp); |
} |
} |
Line 1285 username_completion_function(const char |
|
Line 1420 username_completion_function(const char |
|
*/ |
*/ |
/* ARGSUSED */ |
/* ARGSUSED */ |
static unsigned char |
static unsigned char |
_el_rl_complete(EditLine *el, int ch) |
_el_rl_complete(EditLine *el __attribute__((__unused__)), int ch) |
{ |
{ |
return (unsigned char) rl_complete(0, ch); |
return (unsigned char) rl_complete(0, ch); |
} |
} |
Line 1299 completion_matches(const char *text, CPF |
|
Line 1434 completion_matches(const char *text, CPF |
|
{ |
{ |
char **match_list = NULL, *retstr, *prevstr; |
char **match_list = NULL, *retstr, *prevstr; |
size_t match_list_len, max_equal, which, i; |
size_t match_list_len, max_equal, which, i; |
int matches; |
size_t matches; |
|
|
if (h == NULL || e == NULL) |
if (h == NULL || e == NULL) |
rl_initialize(); |
rl_initialize(); |
|
|
matches = 0; |
matches = 0; |
match_list_len = 1; |
match_list_len = 1; |
while ((retstr = (*genfunc) (text, matches)) != NULL) { |
while ((retstr = (*genfunc) (text, (int)matches)) != NULL) { |
if (matches + 1 >= match_list_len) { |
/* allow for list terminator here */ |
match_list_len <<= 1; |
if (matches + 3 >= match_list_len) { |
match_list = realloc(match_list, |
char **nmatch_list; |
|
while (matches + 3 >= match_list_len) |
|
match_list_len <<= 1; |
|
nmatch_list = realloc(match_list, |
match_list_len * sizeof(char *)); |
match_list_len * sizeof(char *)); |
|
if (nmatch_list == NULL) { |
|
free(match_list); |
|
return NULL; |
|
} |
|
match_list = nmatch_list; |
|
|
} |
} |
match_list[++matches] = retstr; |
match_list[++matches] = retstr; |
} |
} |
|
|
if (!match_list) |
if (!match_list) |
return (char **) NULL; /* nothing found */ |
return NULL; /* nothing found */ |
|
|
/* find least denominator and insert it to match_list[0] */ |
/* find least denominator and insert it to match_list[0] */ |
which = 2; |
which = 2; |
Line 1330 completion_matches(const char *text, CPF |
|
Line 1474 completion_matches(const char *text, CPF |
|
} |
} |
|
|
retstr = malloc(max_equal + 1); |
retstr = malloc(max_equal + 1); |
|
if (retstr == NULL) { |
|
free(match_list); |
|
return NULL; |
|
} |
(void) strncpy(retstr, match_list[1], max_equal); |
(void) strncpy(retstr, match_list[1], max_equal); |
retstr[max_equal] = '\0'; |
retstr[max_equal] = '\0'; |
match_list[0] = retstr; |
match_list[0] = retstr; |
|
|
/* add NULL as last pointer to the array */ |
/* add NULL as last pointer to the array */ |
if (matches + 1 >= match_list_len) |
|
match_list = realloc(match_list, |
|
(match_list_len + 1) * sizeof(char *)); |
|
match_list[matches + 1] = (char *) NULL; |
match_list[matches + 1] = (char *) NULL; |
|
|
return (match_list); |
return (match_list); |
|
|
_rl_qsort_string_compare(i1, i2) |
_rl_qsort_string_compare(i1, i2) |
const void *i1, *i2; |
const void *i1, *i2; |
{ |
{ |
const char *s1 = ((const char **)i1)[0]; |
const char *s1 = ((const char * const *)i1)[0]; |
const char *s2 = ((const char **)i2)[0]; |
const char *s2 = ((const char * const *)i2)[0]; |
|
|
return strcasecmp(s1, s2); |
return strcasecmp(s1, s2); |
} |
} |
Line 1383 rl_display_match_list (matches, len, max |
|
Line 1528 rl_display_match_list (matches, len, max |
|
count++; |
count++; |
|
|
/* Sort the items if they are not already sorted. */ |
/* Sort the items if they are not already sorted. */ |
qsort(&matches[1], len-1, sizeof(char *), _rl_qsort_string_compare); |
qsort(&matches[1], (size_t)(len - 1), sizeof(char *), |
|
_rl_qsort_string_compare); |
|
|
idx = 1; |
idx = 1; |
for(; count > 0; count--) { |
for(; count > 0; count--) { |
Line 1422 rl_complete_internal(int what_to_do) |
|
Line 1568 rl_complete_internal(int what_to_do) |
|
if (!complet_func) |
if (!complet_func) |
complet_func = filename_completion_function; |
complet_func = filename_completion_function; |
|
|
|
/* We now look backwards for the start of a filename/variable word */ |
li = el_line(e); |
li = el_line(e); |
ctemp = (char *) li->cursor; |
ctemp = (const char *) li->cursor; |
while (ctemp > li->buffer && |
while (ctemp > li->buffer |
!strchr(rl_basic_word_break_characters, *(ctemp - 1))) |
&& !strchr(rl_basic_word_break_characters, ctemp[-1]) |
|
&& (!rl_special_prefixes |
|
|| !strchr(rl_special_prefixes, ctemp[-1]) ) ) |
ctemp--; |
ctemp--; |
|
|
len = li->cursor - ctemp; |
len = li->cursor - ctemp; |
Line 1469 rl_complete_internal(int what_to_do) |
|
Line 1618 rl_complete_internal(int what_to_do) |
|
* object is a directory. |
* object is a directory. |
*/ |
*/ |
size_t alen = strlen(matches[0]); |
size_t alen = strlen(matches[0]); |
if (complet_func != filename_completion_function |
if ((complet_func != filename_completion_function |
|| (alen > 0 && (matches[0])[alen - 1] != '/')) |
|| (alen > 0 && (matches[0])[alen - 1] != '/')) |
el_insertstr(e, " "); |
&& rl_completion_append_character) { |
|
char buf[2]; |
|
buf[0] = rl_completion_append_character; |
|
buf[1] = '\0'; |
|
el_insertstr(e, buf); |
|
} |
} else if (what_to_do == '!') { |
} else if (what_to_do == '!') { |
display_matches: |
display_matches: |
/* |
/* |
Line 1507 rl_complete_internal(int what_to_do) |
|
Line 1661 rl_complete_internal(int what_to_do) |
|
rl_display_match_list(matches, matches_num, |
rl_display_match_list(matches, matches_num, |
maxlen); |
maxlen); |
retval = CC_REDISPLAY; |
retval = CC_REDISPLAY; |
|
} else if (matches[0][0]) { |
|
/* |
|
* There was some common match, but the name was |
|
* not complete enough. Next tab will print possible |
|
* completions. |
|
*/ |
|
el_beep(e); |
} else { |
} else { |
/* lcd is not a valid object - further specification */ |
/* lcd is not a valid object - further specification */ |
/* is needed */ |
/* is needed */ |
Line 1591 rl_read_key(void) |
|
Line 1752 rl_read_key(void) |
|
*/ |
*/ |
/* ARGSUSED */ |
/* ARGSUSED */ |
void |
void |
rl_reset_terminal(const char *p) |
rl_reset_terminal(const char *p __attribute__((__unused__))) |
{ |
{ |
|
|
if (h == NULL || e == NULL) |
if (h == NULL || e == NULL) |