Imported from ../bash-2.05a.tar.gz.
This commit is contained in:
parent
28ef6c316f
commit
f73dda092b
303 changed files with 37069 additions and 28812 deletions
|
|
@ -121,6 +121,12 @@ documentation: force
|
|||
test -d doc || mkdir doc
|
||||
-( cd doc && $(MAKE) $(MFLAGS) )
|
||||
|
||||
# Since tilde.c is shared between readline and bash, make sure we compile
|
||||
# it with the right flags when it's built as part of readline
|
||||
tilde.o: tilde.c
|
||||
rm -f $@
|
||||
$(CC) $(CCFLAGS) -DREADLINE_LIBRARY -c $(srcdir)/tilde.c
|
||||
|
||||
force:
|
||||
|
||||
install:
|
||||
|
|
@ -152,7 +158,7 @@ bind.o: ansi_stdlib.h posixstat.h
|
|||
bind.o: rldefs.h ${BUILD_DIR}/config.h rlconf.h
|
||||
bind.o: readline.h keymaps.h rltypedefs.h chardefs.h tilde.h
|
||||
bind.o: history.h rlstdc.h
|
||||
callback.o: rlconf.h
|
||||
callback.o: rlconf.h ansi_stdlib.h
|
||||
callback.o: rldefs.h ${BUILD_DIR}/config.h rlconf.h
|
||||
callback.o: readline.h keymaps.h rltypedefs.h chardefs.h tilde.h rlstdc.h
|
||||
compat.o: rlstdc.h
|
||||
|
|
@ -228,7 +234,7 @@ tilde.o: tilde.h
|
|||
undo.o: ansi_stdlib.h
|
||||
undo.o: rldefs.h ${BUILD_DIR}/config.h rlconf.h
|
||||
undo.o: readline.h keymaps.h rltypedefs.h chardefs.h tilde.h
|
||||
undo.o: history.h rlstdc.h
|
||||
undo.o: history.h rlstdc.h xmalloc.h
|
||||
util.o: posixjmp.h ansi_stdlib.h
|
||||
util.o: rldefs.h ${BUILD_DIR}/config.h rlconf.h
|
||||
util.o: readline.h keymaps.h rltypedefs.h chardefs.h tilde.h rlstdc.h
|
||||
|
|
|
|||
|
|
@ -25,14 +25,24 @@
|
|||
|
||||
/* String conversion functions. */
|
||||
extern int atoi ();
|
||||
extern long int atol ();
|
||||
|
||||
extern double atof ();
|
||||
extern double strtod ();
|
||||
|
||||
/* Memory allocation functions. */
|
||||
extern char *malloc ();
|
||||
extern char *realloc ();
|
||||
/* Generic pointer type. */
|
||||
#ifndef PTR_T
|
||||
|
||||
#if defined (__STDC__)
|
||||
# define PTR_T void *
|
||||
#else
|
||||
# define PTR_T char *
|
||||
#endif
|
||||
|
||||
#endif /* PTR_T */
|
||||
|
||||
extern PTR_T malloc ();
|
||||
extern PTR_T realloc ();
|
||||
extern void free ();
|
||||
|
||||
/* Other miscellaneous functions. */
|
||||
|
|
|
|||
|
|
@ -68,9 +68,9 @@ extern char *strchr (), *strrchr ();
|
|||
/* Variables exported by this file. */
|
||||
Keymap rl_binding_keymap;
|
||||
|
||||
static int _rl_read_init_file __P((const char *, int));
|
||||
static int glean_key_from_name __P((char *));
|
||||
static int substring_member_of_array __P((char *, const char **));
|
||||
static int _rl_read_init_file PARAMS((const char *, int));
|
||||
static int glean_key_from_name PARAMS((char *));
|
||||
static int substring_member_of_array PARAMS((char *, const char **));
|
||||
|
||||
static int currently_reading_init_file;
|
||||
|
||||
|
|
@ -255,7 +255,7 @@ rl_generic_bind (type, keyseq, data, map)
|
|||
return -1;
|
||||
}
|
||||
|
||||
keys = xmalloc (1 + (2 * strlen (keyseq)));
|
||||
keys = (char *)xmalloc (1 + (2 * strlen (keyseq)));
|
||||
|
||||
/* Translate the ASCII representation of KEYSEQ into an array of
|
||||
characters. Stuff the characters into KEYS, and the length of
|
||||
|
|
@ -269,7 +269,7 @@ rl_generic_bind (type, keyseq, data, map)
|
|||
/* Bind keys, making new keymaps as necessary. */
|
||||
for (i = 0; i < keys_len; i++)
|
||||
{
|
||||
int ic = (int) ((unsigned char)keys[i]);
|
||||
unsigned char ic = keys[i];
|
||||
|
||||
if (_rl_convert_meta_chars_to_ascii && META_CHAR (ic))
|
||||
{
|
||||
|
|
@ -393,16 +393,16 @@ rl_translate_keyseq (seq, array, len)
|
|||
for (temp = 2, c -= '0'; ISOCTAL (seq[i]) && temp--; i++)
|
||||
c = (c * 8) + OCTVALUE (seq[i]);
|
||||
i--; /* auto-increment in for loop */
|
||||
array[l++] = c % (largest_char + 1);
|
||||
array[l++] = c & largest_char;
|
||||
break;
|
||||
case 'x':
|
||||
i++;
|
||||
for (temp = 3, c = 0; isxdigit (seq[i]) && temp--; i++)
|
||||
for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i]) && temp--; i++)
|
||||
c = (c * 16) + HEXVALUE (seq[i]);
|
||||
if (temp == 3)
|
||||
if (temp == 2)
|
||||
c = 'x';
|
||||
i--; /* auto-increment in for loop */
|
||||
array[l++] = c % (largest_char + 1);
|
||||
array[l++] = c & largest_char;
|
||||
break;
|
||||
default: /* backslashes before non-special chars just add the char */
|
||||
array[l++] = c;
|
||||
|
|
@ -472,7 +472,7 @@ _rl_untranslate_macro_value (seq)
|
|||
char *ret, *r, *s;
|
||||
int c;
|
||||
|
||||
r = ret = xmalloc (7 * strlen (seq) + 1);
|
||||
r = ret = (char *)xmalloc (7 * strlen (seq) + 1);
|
||||
for (s = seq; *s; s++)
|
||||
{
|
||||
c = *s;
|
||||
|
|
@ -547,7 +547,7 @@ rl_function_of_keyseq (keyseq, map, type)
|
|||
|
||||
for (i = 0; keyseq && keyseq[i]; i++)
|
||||
{
|
||||
int ic = keyseq[i];
|
||||
unsigned char ic = keyseq[i];
|
||||
|
||||
if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
|
||||
{
|
||||
|
|
@ -782,7 +782,7 @@ _rl_init_file_error (msg)
|
|||
/* */
|
||||
/* **************************************************************** */
|
||||
|
||||
typedef int _rl_parser_func_t __P((char *));
|
||||
typedef int _rl_parser_func_t PARAMS((char *));
|
||||
|
||||
/* Things that mean `Control'. */
|
||||
const char *_rl_possible_control_prefixes[] = {
|
||||
|
|
@ -1145,7 +1145,7 @@ rl_parse_and_bind (string)
|
|||
char *seq;
|
||||
register int j, k, passc;
|
||||
|
||||
seq = xmalloc (1 + strlen (string));
|
||||
seq = (char *)xmalloc (1 + strlen (string));
|
||||
for (j = 1, k = passc = 0; string[j]; j++)
|
||||
{
|
||||
/* Allow backslash to quote characters, but leave them in place.
|
||||
|
|
@ -1203,7 +1203,7 @@ rl_parse_and_bind (string)
|
|||
/* Temporary. Handle old-style keyname with macro-binding. */
|
||||
if (*funname == '\'' || *funname == '"')
|
||||
{
|
||||
unsigned char useq[2];
|
||||
char useq[2];
|
||||
int fl = strlen (funname);
|
||||
|
||||
useq[0] = key; useq[1] = '\0';
|
||||
|
|
@ -1245,10 +1245,12 @@ static struct {
|
|||
{ "disable-completion", &rl_inhibit_completion, 0 },
|
||||
{ "enable-keypad", &_rl_enable_keypad, 0 },
|
||||
{ "expand-tilde", &rl_complete_with_tilde_expansion, 0 },
|
||||
{ "history-preserve-point", &_rl_history_preserve_point, 0 },
|
||||
{ "horizontal-scroll-mode", &_rl_horizontal_scroll_mode, 0 },
|
||||
{ "input-meta", &_rl_meta_flag, 0 },
|
||||
{ "mark-directories", &_rl_complete_mark_directories, 0 },
|
||||
{ "mark-modified-lines", &_rl_mark_modified_lines, 0 },
|
||||
{ "match-hidden-files", &_rl_match_hidden_files, 0 },
|
||||
{ "meta-flag", &_rl_meta_flag, 0 },
|
||||
{ "output-meta", &_rl_output_meta_chars, 0 },
|
||||
{ "prefer-visible-bell", &_rl_prefer_visible_bell, V_SPECIAL },
|
||||
|
|
@ -1294,7 +1296,7 @@ hack_special_boolean_var (i)
|
|||
}
|
||||
}
|
||||
|
||||
typedef int _rl_sv_func_t __P((const char *));
|
||||
typedef int _rl_sv_func_t PARAMS((const char *));
|
||||
|
||||
/* These *must* correspond to the array indices for the appropriate
|
||||
string variable. (Though they're not used right now.) */
|
||||
|
|
@ -1308,12 +1310,12 @@ typedef int _rl_sv_func_t __P((const char *));
|
|||
#define V_INT 2
|
||||
|
||||
/* Forward declarations */
|
||||
static int sv_bell_style __P((const char *));
|
||||
static int sv_combegin __P((const char *));
|
||||
static int sv_compquery __P((const char *));
|
||||
static int sv_editmode __P((const char *));
|
||||
static int sv_isrchterm __P((const char *));
|
||||
static int sv_keymap __P((const char *));
|
||||
static int sv_bell_style PARAMS((const char *));
|
||||
static int sv_combegin PARAMS((const char *));
|
||||
static int sv_compquery PARAMS((const char *));
|
||||
static int sv_editmode PARAMS((const char *));
|
||||
static int sv_isrchterm PARAMS((const char *));
|
||||
static int sv_keymap PARAMS((const char *));
|
||||
|
||||
static struct {
|
||||
const char *name;
|
||||
|
|
@ -1446,24 +1448,22 @@ sv_keymap (value)
|
|||
return 1;
|
||||
}
|
||||
|
||||
#define _SET_BELL(v) do { _rl_bell_preference = v; return 0; } while (0)
|
||||
|
||||
static int
|
||||
sv_bell_style (value)
|
||||
const char *value;
|
||||
{
|
||||
if (value == 0 || *value == '\0')
|
||||
_SET_BELL (AUDIBLE_BELL);
|
||||
_rl_bell_preference = AUDIBLE_BELL;
|
||||
else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
|
||||
_SET_BELL (NO_BELL);
|
||||
_rl_bell_preference = NO_BELL;
|
||||
else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
|
||||
_SET_BELL (AUDIBLE_BELL);
|
||||
_rl_bell_preference = AUDIBLE_BELL;
|
||||
else if (_rl_stricmp (value, "visible") == 0)
|
||||
_SET_BELL (VISIBLE_BELL);
|
||||
_rl_bell_preference = VISIBLE_BELL;
|
||||
else
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
#undef _SET_BELL
|
||||
|
||||
static int
|
||||
sv_isrchterm (value)
|
||||
|
|
@ -1493,7 +1493,7 @@ sv_isrchterm (value)
|
|||
v[end] = '\0';
|
||||
|
||||
/* The value starts at v + beg. Translate it into a character string. */
|
||||
_rl_isearch_terminators = (unsigned char *)xmalloc (2 * strlen (v) + 1);
|
||||
_rl_isearch_terminators = (char *)xmalloc (2 * strlen (v) + 1);
|
||||
rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
|
||||
_rl_isearch_terminators[end] = '\0';
|
||||
|
||||
|
|
@ -1751,7 +1751,7 @@ rl_invoking_keyseqs_in_map (function, map)
|
|||
if (result_index + 2 > result_size)
|
||||
{
|
||||
result_size += 10;
|
||||
result = (char **) xrealloc (result, result_size * sizeof (char *));
|
||||
result = (char **)xrealloc (result, result_size * sizeof (char *));
|
||||
}
|
||||
|
||||
result[result_index++] = keyname;
|
||||
|
|
@ -1803,7 +1803,7 @@ rl_invoking_keyseqs_in_map (function, map)
|
|||
if (result_index + 2 > result_size)
|
||||
{
|
||||
result_size += 10;
|
||||
result = (char **) xrealloc (result, result_size * sizeof (char *));
|
||||
result = (char **)xrealloc (result, result_size * sizeof (char *));
|
||||
}
|
||||
|
||||
result[result_index++] = keyname;
|
||||
|
|
@ -1951,7 +1951,7 @@ _rl_macro_dumper_internal (print_readably, map, prefix)
|
|||
prefix_len = prefix ? strlen (prefix) : 0;
|
||||
if (key == ESC)
|
||||
{
|
||||
keyname = xmalloc (3 + prefix_len);
|
||||
keyname = (char *)xmalloc (3 + prefix_len);
|
||||
if (prefix)
|
||||
strcpy (keyname, prefix);
|
||||
keyname[prefix_len] = '\\';
|
||||
|
|
@ -1963,7 +1963,7 @@ _rl_macro_dumper_internal (print_readably, map, prefix)
|
|||
keyname = _rl_get_keyname (key);
|
||||
if (prefix)
|
||||
{
|
||||
out = xmalloc (strlen (keyname) + prefix_len + 1);
|
||||
out = (char *)xmalloc (strlen (keyname) + prefix_len + 1);
|
||||
strcpy (out, prefix);
|
||||
strcpy (out + prefix_len, keyname);
|
||||
free (keyname);
|
||||
|
|
|
|||
|
|
@ -30,6 +30,13 @@
|
|||
#if defined (READLINE_CALLBACKS)
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifdef HAVE_STDLIB_H
|
||||
# include <stdlib.h>
|
||||
#else
|
||||
# include "ansi_stdlib.h"
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/* System-specific feature definitions and include files. */
|
||||
|
|
|
|||
|
|
@ -27,10 +27,14 @@
|
|||
|
||||
#if defined (HAVE_CONFIG_H)
|
||||
# if defined (HAVE_STRING_H)
|
||||
# if ! defined (STDC_HEADERS) && defined (HAVE_MEMORY_H)
|
||||
# include <memory.h>
|
||||
# endif
|
||||
# include <string.h>
|
||||
# else
|
||||
# include <strings.h>
|
||||
# endif /* HAVE_STRING_H */
|
||||
# if defined (HAVE_STRINGS_H)
|
||||
# include <strings.h>
|
||||
# endif /* HAVE_STRINGS_H */
|
||||
#else
|
||||
# include <string.h>
|
||||
#endif /* !HAVE_CONFIG_H */
|
||||
|
|
@ -60,33 +64,56 @@
|
|||
#define UNMETA(c) ((c) & (~meta_character_bit))
|
||||
#define UNCTRL(c) _rl_to_upper(((c)|control_character_bit))
|
||||
|
||||
/* Old versions
|
||||
#define _rl_lowercase_p(c) (((c) > ('a' - 1) && (c) < ('z' + 1)))
|
||||
#define _rl_uppercase_p(c) (((c) > ('A' - 1) && (c) < ('Z' + 1)))
|
||||
#define _rl_digit_p(c) ((c) >= '0' && (c) <= '9')
|
||||
*/
|
||||
#if defined STDC_HEADERS || (!defined (isascii) && !defined (HAVE_ISASCII))
|
||||
# define IN_CTYPE_DOMAIN(c) 1
|
||||
#else
|
||||
# define IN_CTYPE_DOMAIN(c) isascii(c)
|
||||
#endif
|
||||
|
||||
#define _rl_lowercase_p(c) (islower(c))
|
||||
#define _rl_uppercase_p(c) (isupper(c))
|
||||
#define _rl_digit_p(x) (isdigit (x))
|
||||
#if !defined (isxdigit) && !defined (HAVE_ISXDIGIT)
|
||||
# define isxdigit(c) (isdigit((c)) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
|
||||
#endif
|
||||
|
||||
#define _rl_pure_alphabetic(c) (_rl_lowercase_p(c) || _rl_uppercase_p(c))
|
||||
#define ALPHABETIC(c) (_rl_lowercase_p(c) || _rl_uppercase_p(c) || _rl_digit_p(c))
|
||||
#define NON_NEGATIVE(c) ((unsigned char)(c) == (c))
|
||||
|
||||
/* Old versions
|
||||
# define _rl_to_upper(c) (_rl_lowercase_p(c) ? ((c) - 32) : (c))
|
||||
# define _rl_to_lower(c) (_rl_uppercase_p(c) ? ((c) + 32) : (c))
|
||||
*/
|
||||
#define ISALNUM(c) (IN_CTYPE_DOMAIN (c) && isalnum (c))
|
||||
#define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
|
||||
#define ISDIGIT(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))
|
||||
#define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
|
||||
#define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (c))
|
||||
#define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper (c))
|
||||
#define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (c))
|
||||
|
||||
#define _rl_lowercase_p(c) (NON_NEGATIVE(c) && ISLOWER(c))
|
||||
#define _rl_uppercase_p(c) (NON_NEGATIVE(c) && ISUPPER(c))
|
||||
#define _rl_digit_p(c) ((c) >= '0' && (c) <= '9')
|
||||
|
||||
#define _rl_pure_alphabetic(c) (NON_NEGATIVE(c) && ISALPHA(c))
|
||||
#define ALPHABETIC(c) (NON_NEGATIVE(c) && ISALNUM(c))
|
||||
|
||||
#ifndef _rl_to_upper
|
||||
# define _rl_to_upper(c) (islower(c) ? toupper(c) : (c))
|
||||
# define _rl_to_lower(c) (isupper(c) ? tolower(c) : (c))
|
||||
# define _rl_to_upper(c) (_rl_lowercase_p(c) ? toupper((unsigned char)c) : (c))
|
||||
# define _rl_to_lower(c) (_rl_uppercase_p(c) ? tolower((unsigned char)c) : (c))
|
||||
#endif
|
||||
|
||||
#ifndef _rl_digit_value
|
||||
#define _rl_digit_value(x) ((x) - '0')
|
||||
# define _rl_digit_value(x) ((x) - '0')
|
||||
#endif
|
||||
|
||||
#ifndef _rl_isident
|
||||
# define _rl_isident(c) (ISALNUM(c) || (c) == '_')
|
||||
#endif
|
||||
|
||||
#ifndef ISOCTAL
|
||||
# define ISOCTAL(c) ((c) >= '0' && (c) <= '7')
|
||||
#endif
|
||||
#define OCTVALUE(c) ((c) - '0')
|
||||
|
||||
#define HEXVALUE(c) \
|
||||
(((c) >= 'a' && (c) <= 'f') \
|
||||
? (c)-'a'+10 \
|
||||
: (c) >= 'A' && (c) <= 'F' ? (c)-'A'+10 : (c)-'0')
|
||||
|
||||
#ifndef NEWLINE
|
||||
#define NEWLINE '\n'
|
||||
#endif
|
||||
|
|
@ -123,18 +150,4 @@
|
|||
#endif
|
||||
#define ESC CTRL('[')
|
||||
|
||||
#ifndef ISOCTAL
|
||||
#define ISOCTAL(c) ((c) >= '0' && (c) <= '7')
|
||||
#endif
|
||||
#define OCTVALUE(c) ((c) - '0')
|
||||
|
||||
#ifndef isxdigit
|
||||
# define isxdigit(c) (isdigit((c)) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
|
||||
#endif
|
||||
|
||||
#define HEXVALUE(c) \
|
||||
(((c) >= 'a' && (c) <= 'f') \
|
||||
? (c)-'a'+10 \
|
||||
: (c) >= 'A' && (c) <= 'F' ? (c)-'A'+10 : (c)-'0')
|
||||
|
||||
#endif /* _CHARDEFS_H_ */
|
||||
|
|
|
|||
|
|
@ -30,18 +30,18 @@
|
|||
#include "rlstdc.h"
|
||||
#include "rltypedefs.h"
|
||||
|
||||
extern void rl_free_undo_list __P((void));
|
||||
extern int rl_maybe_save_line __P((void));
|
||||
extern int rl_maybe_unsave_line __P((void));
|
||||
extern int rl_maybe_replace_line __P((void));
|
||||
extern void rl_free_undo_list PARAMS((void));
|
||||
extern int rl_maybe_save_line PARAMS((void));
|
||||
extern int rl_maybe_unsave_line PARAMS((void));
|
||||
extern int rl_maybe_replace_line PARAMS((void));
|
||||
|
||||
extern int rl_crlf __P((void));
|
||||
extern int rl_ding __P((void));
|
||||
extern int rl_alphabetic __P((int));
|
||||
extern int rl_crlf PARAMS((void));
|
||||
extern int rl_ding PARAMS((void));
|
||||
extern int rl_alphabetic PARAMS((int));
|
||||
|
||||
extern char **rl_completion_matches __P((const char *, rl_compentry_func_t *));
|
||||
extern char *rl_username_completion_function __P((const char *, int));
|
||||
extern char *rl_filename_completion_function __P((const char *, int));
|
||||
extern char **rl_completion_matches PARAMS((const char *, rl_compentry_func_t *));
|
||||
extern char *rl_username_completion_function PARAMS((const char *, int));
|
||||
extern char *rl_filename_completion_function PARAMS((const char *, int));
|
||||
|
||||
/* Provide backwards-compatible entry points for old function names. */
|
||||
|
||||
|
|
|
|||
|
|
@ -67,10 +67,19 @@ typedef int QSFUNC (const void *, const void *);
|
|||
typedef int QSFUNC ();
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_LSTAT
|
||||
# define LSTAT lstat
|
||||
#else
|
||||
# define LSTAT stat
|
||||
#endif
|
||||
|
||||
/* Unix version of a hidden file. Could be different on other systems. */
|
||||
#define HIDDEN_FILE(fname) ((fname)[0] == '.')
|
||||
|
||||
/* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
|
||||
defined. */
|
||||
#if !defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE)
|
||||
extern struct passwd *getpwent __P((void));
|
||||
extern struct passwd *getpwent PARAMS((void));
|
||||
#endif /* !HAVE_GETPW_DECLS || _POSIX_SOURCE */
|
||||
|
||||
/* If non-zero, then this is the address of a function to call when
|
||||
|
|
@ -86,17 +95,28 @@ rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)N
|
|||
# if !defined (X_OK)
|
||||
# define X_OK 1
|
||||
# endif
|
||||
static int stat_char __P((char *));
|
||||
static int stat_char PARAMS((char *));
|
||||
#endif
|
||||
|
||||
static char *rl_quote_filename __P((char *, int, char *));
|
||||
static char *rl_quote_filename PARAMS((char *, int, char *));
|
||||
|
||||
static char **remove_duplicate_matches __P((char **));
|
||||
static void insert_match __P((char *, int, int, char *));
|
||||
static int append_to_match __P((char *, int, int));
|
||||
static void insert_all_matches __P((char **, int, char *));
|
||||
static void display_matches __P((char **));
|
||||
static int compute_lcd_of_matches __P((char **, int, const char *));
|
||||
static int get_y_or_n PARAMS((void));
|
||||
static char *printable_part PARAMS((char *));
|
||||
static int print_filename PARAMS((char *, char *));
|
||||
static char find_completion_word PARAMS((int *, int *));
|
||||
|
||||
static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
|
||||
|
||||
static char **remove_duplicate_matches PARAMS((char **));
|
||||
static void insert_match PARAMS((char *, int, int, char *));
|
||||
static int append_to_match PARAMS((char *, int, int, int));
|
||||
static void insert_all_matches PARAMS((char **, int, char *));
|
||||
static void display_matches PARAMS((char **));
|
||||
static int compute_lcd_of_matches PARAMS((char **, int, const char *));
|
||||
static int postprocess_matches PARAMS((char ***, int));
|
||||
|
||||
static char *make_quoted_replacement PARAMS((char *, int, char *));
|
||||
static void free_match_list PARAMS((char **));
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
|
|
@ -123,6 +143,10 @@ int _rl_completion_case_fold = 1;
|
|||
int _rl_completion_case_fold;
|
||||
#endif
|
||||
|
||||
/* If non-zero, don't match hidden files (filenames beginning with a `.' on
|
||||
Unix) when doing filename completion. */
|
||||
int _rl_match_hidden_files = 1;
|
||||
|
||||
/* Global variables available to applications using readline. */
|
||||
|
||||
#if defined (VISIBLE_STATS)
|
||||
|
|
@ -387,7 +411,7 @@ printable_part (pathname)
|
|||
|
||||
temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL;
|
||||
#if defined (__MSDOS__)
|
||||
if (rl_filename_completion_desired && temp == 0 && isalpha (pathname[0]) && pathname[1] == ':')
|
||||
if (rl_filename_completion_desired && temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
|
||||
temp = pathname + 1;
|
||||
#endif
|
||||
return (temp ? ++temp : pathname);
|
||||
|
|
@ -461,7 +485,7 @@ print_filename (to_print, full_pathname)
|
|||
|
||||
slen = strlen (s);
|
||||
tlen = strlen (to_print);
|
||||
new_full_pathname = xmalloc (slen + tlen + 2);
|
||||
new_full_pathname = (char *)xmalloc (slen + tlen + 2);
|
||||
strcpy (new_full_pathname, s);
|
||||
new_full_pathname[slen] = '/';
|
||||
strcpy (new_full_pathname + slen + 1, to_print);
|
||||
|
|
@ -496,7 +520,7 @@ rl_quote_filename (s, rtype, qcp)
|
|||
{
|
||||
char *r;
|
||||
|
||||
r = xmalloc (strlen (s) + 2);
|
||||
r = (char *)xmalloc (strlen (s) + 2);
|
||||
*r = *rl_completer_quote_characters;
|
||||
strcpy (r + 1, s);
|
||||
if (qcp)
|
||||
|
|
@ -507,7 +531,7 @@ rl_quote_filename (s, rtype, qcp)
|
|||
/* Find the bounds of the current word for completion purposes, and leave
|
||||
rl_point set to the end of the word. This function skips quoted
|
||||
substrings (characters between matched pairs of characters in
|
||||
rl_completer_quote_characters. First we try to find an unclosed
|
||||
rl_completer_quote_characters). First we try to find an unclosed
|
||||
quoted substring on which to do matching. If one is not found, we use
|
||||
the word break characters to find the boundaries of the current word.
|
||||
We call an application-specific function to decide whether or not a
|
||||
|
|
@ -797,13 +821,40 @@ compute_lcd_of_matches (match_list, matches, text)
|
|||
value of matches[0]. */
|
||||
if (low == 0 && text && *text)
|
||||
{
|
||||
match_list[0] = xmalloc (strlen (text) + 1);
|
||||
match_list[0] = (char *)xmalloc (strlen (text) + 1);
|
||||
strcpy (match_list[0], text);
|
||||
}
|
||||
else
|
||||
{
|
||||
match_list[0] = xmalloc (low + 1);
|
||||
strncpy (match_list[0], match_list[1], low);
|
||||
match_list[0] = (char *)xmalloc (low + 1);
|
||||
|
||||
/* If we are ignoring case, try to preserve the case of the string
|
||||
the user typed in the face of multiple matches differing in case. */
|
||||
if (_rl_completion_case_fold)
|
||||
{
|
||||
/* sort the list to get consistent answers. */
|
||||
qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
|
||||
|
||||
si = strlen (text);
|
||||
if (si <= low)
|
||||
{
|
||||
for (i = 1; i <= matches; i++)
|
||||
if (strncmp (match_list[i], text, si) == 0)
|
||||
{
|
||||
strncpy (match_list[0], match_list[i], low);
|
||||
break;
|
||||
}
|
||||
/* no casematch, use first entry */
|
||||
if (i > matches)
|
||||
strncpy (match_list[0], match_list[1], low);
|
||||
}
|
||||
else
|
||||
/* otherwise, just use the text the user typed. */
|
||||
strncpy (match_list[0], text, low);
|
||||
}
|
||||
else
|
||||
strncpy (match_list[0], match_list[1], low);
|
||||
|
||||
match_list[0][low] = '\0';
|
||||
}
|
||||
|
||||
|
|
@ -1102,14 +1153,16 @@ insert_match (match, start, mtype, qc)
|
|||
just-inserted match. If the user has specified that directories
|
||||
should be marked by a trailing `/', append one of those instead. The
|
||||
default trailing character is a space. Returns the number of characters
|
||||
appended. */
|
||||
appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
|
||||
has them) and don't add a suffix for a symlink to a directory. A
|
||||
nontrivial match is one that actually adds to the word being completed. */
|
||||
static int
|
||||
append_to_match (text, delimiter, quote_char)
|
||||
append_to_match (text, delimiter, quote_char, nontrivial_match)
|
||||
char *text;
|
||||
int delimiter, quote_char;
|
||||
int delimiter, quote_char, nontrivial_match;
|
||||
{
|
||||
char temp_string[4], *filename;
|
||||
int temp_string_index;
|
||||
int temp_string_index, s;
|
||||
struct stat finfo;
|
||||
|
||||
temp_string_index = 0;
|
||||
|
|
@ -1126,11 +1179,19 @@ append_to_match (text, delimiter, quote_char)
|
|||
if (rl_filename_completion_desired)
|
||||
{
|
||||
filename = tilde_expand (text);
|
||||
if (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
|
||||
s = nontrivial_match ? LSTAT (filename, &finfo) : stat (filename, &finfo);
|
||||
if (s == 0 && S_ISDIR (finfo.st_mode))
|
||||
{
|
||||
if (_rl_complete_mark_directories && rl_line_buffer[rl_point] != '/')
|
||||
rl_insert_text ("/");
|
||||
}
|
||||
#ifdef S_ISLNK
|
||||
/* Don't add anything if the filename is a symlink and resolves to a
|
||||
directory. */
|
||||
else if (s == 0 && S_ISLNK (finfo.st_mode) &&
|
||||
stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
|
||||
;
|
||||
#endif
|
||||
else
|
||||
{
|
||||
if (rl_point == rl_end)
|
||||
|
|
@ -1210,7 +1271,7 @@ rl_complete_internal (what_to_do)
|
|||
{
|
||||
char **matches;
|
||||
rl_compentry_func_t *our_func;
|
||||
int start, end, delimiter, found_quote, i;
|
||||
int start, end, delimiter, found_quote, i, nontrivial_lcd;
|
||||
char *text, *saved_line_buffer;
|
||||
char quote_char;
|
||||
|
||||
|
|
@ -1240,6 +1301,9 @@ rl_complete_internal (what_to_do)
|
|||
|
||||
text = rl_copy_text (start, end);
|
||||
matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
|
||||
/* nontrivial_lcd is set if the common prefix adds something to the word
|
||||
being completed. */
|
||||
nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
|
||||
free (text);
|
||||
|
||||
if (matches == 0)
|
||||
|
|
@ -1291,7 +1355,7 @@ rl_complete_internal (what_to_do)
|
|||
rl_ding (); /* There are other matches remaining. */
|
||||
}
|
||||
else
|
||||
append_to_match (matches[0], delimiter, quote_char);
|
||||
append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
|
||||
|
||||
break;
|
||||
|
||||
|
|
@ -1428,7 +1492,7 @@ rl_username_completion_function (text, state)
|
|||
}
|
||||
else
|
||||
{
|
||||
value = xmalloc (2 + strlen (entry->pw_name));
|
||||
value = (char *)xmalloc (2 + strlen (entry->pw_name));
|
||||
|
||||
*value = *text;
|
||||
|
||||
|
|
@ -1483,7 +1547,7 @@ rl_filename_completion_function (text, state)
|
|||
|
||||
#if defined (__MSDOS__)
|
||||
/* special hack for //X/... */
|
||||
if (dirname[0] == '/' && dirname[1] == '/' && isalpha (dirname[2]) && dirname[3] == '/')
|
||||
if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
|
||||
temp = strrchr (dirname + 3, '/');
|
||||
#endif
|
||||
|
||||
|
|
@ -1494,7 +1558,7 @@ rl_filename_completion_function (text, state)
|
|||
}
|
||||
#if defined (__MSDOS__)
|
||||
/* searches from current directory on the drive */
|
||||
else if (isalpha (dirname[0]) && dirname[1] == ':')
|
||||
else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
|
||||
{
|
||||
strcpy (filename, dirname + 2);
|
||||
dirname[2] = '\0';
|
||||
|
|
@ -1544,10 +1608,14 @@ rl_filename_completion_function (text, state)
|
|||
entry = (struct dirent *)NULL;
|
||||
while (directory && (entry = readdir (directory)))
|
||||
{
|
||||
/* Special case for no filename.
|
||||
All entries except "." and ".." match. */
|
||||
/* Special case for no filename. If the user has disabled the
|
||||
`match-hidden-files' variable, skip filenames beginning with `.'.
|
||||
All other entries except "." and ".." match. */
|
||||
if (filename_len == 0)
|
||||
{
|
||||
if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name))
|
||||
continue;
|
||||
|
||||
if (entry->d_name[0] != '.' ||
|
||||
(entry->d_name[1] &&
|
||||
(entry->d_name[1] != '.' || entry->d_name[2])))
|
||||
|
|
@ -1607,7 +1675,7 @@ rl_filename_completion_function (text, state)
|
|||
if (rl_complete_with_tilde_expansion && *users_dirname == '~')
|
||||
{
|
||||
dirlen = strlen (dirname);
|
||||
temp = xmalloc (2 + dirlen + D_NAMLEN (entry));
|
||||
temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
|
||||
strcpy (temp, dirname);
|
||||
/* Canonicalization cuts off any final slash present. We
|
||||
may need to add it back. */
|
||||
|
|
@ -1620,7 +1688,7 @@ rl_filename_completion_function (text, state)
|
|||
else
|
||||
{
|
||||
dirlen = strlen (users_dirname);
|
||||
temp = xmalloc (2 + dirlen + D_NAMLEN (entry));
|
||||
temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
|
||||
strcpy (temp, users_dirname);
|
||||
/* Make sure that temp has a trailing slash here. */
|
||||
if (users_dirname[dirlen - 1] != '/')
|
||||
|
|
@ -1745,7 +1813,8 @@ rl_menu_complete (count, ignore)
|
|||
else
|
||||
{
|
||||
insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
|
||||
append_to_match (matches[match_list_index], delimiter, quote_char);
|
||||
append_to_match (matches[match_list_index], delimiter, quote_char,
|
||||
strcmp (orig_text, matches[match_list_index]));
|
||||
}
|
||||
|
||||
completion_changed_buffer = 1;
|
||||
|
|
|
|||
|
|
@ -62,11 +62,11 @@ extern char *strchr (), *strrchr ();
|
|||
extern char *_rl_term_forward_char;
|
||||
#endif
|
||||
|
||||
static void update_line __P((char *, char *, int, int, int, int));
|
||||
static void space_to_eol __P((int));
|
||||
static void delete_chars __P((int));
|
||||
static void insert_some_chars __P((char *, int));
|
||||
static void cr __P((void));
|
||||
static void update_line PARAMS((char *, char *, int, int, int, int));
|
||||
static void space_to_eol PARAMS((int));
|
||||
static void delete_chars PARAMS((int));
|
||||
static void insert_some_chars PARAMS((char *, int));
|
||||
static void cr PARAMS((void));
|
||||
|
||||
static int *inv_lbreaks, *vis_lbreaks;
|
||||
static int inv_lbsize, vis_lbsize;
|
||||
|
|
@ -202,7 +202,7 @@ expand_prompt (pmt, lp, lip, niflp)
|
|||
}
|
||||
|
||||
l = strlen (pmt);
|
||||
r = ret = xmalloc (l + 1);
|
||||
r = ret = (char *)xmalloc (l + 1);
|
||||
|
||||
invfl = 0; /* invisible chars in first line of prompt */
|
||||
|
||||
|
|
@ -335,16 +335,16 @@ init_line_structures (minsize)
|
|||
{
|
||||
if (line_size < minsize)
|
||||
line_size = minsize;
|
||||
visible_line = xmalloc (line_size);
|
||||
invisible_line = xmalloc (line_size);
|
||||
visible_line = (char *)xmalloc (line_size);
|
||||
invisible_line = (char *)xmalloc (line_size);
|
||||
}
|
||||
else if (line_size < minsize) /* ensure it can hold MINSIZE chars */
|
||||
{
|
||||
line_size *= 2;
|
||||
if (line_size < minsize)
|
||||
line_size = minsize;
|
||||
visible_line = xrealloc (visible_line, line_size);
|
||||
invisible_line = xrealloc (invisible_line, line_size);
|
||||
visible_line = (char *)xrealloc (visible_line, line_size);
|
||||
invisible_line = (char *)xrealloc (invisible_line, line_size);
|
||||
}
|
||||
|
||||
for (n = minsize; n < line_size; n++)
|
||||
|
|
@ -421,8 +421,8 @@ rl_redisplay ()
|
|||
if (temp >= line_size)
|
||||
{
|
||||
line_size = (temp + 1024) - (temp % 1024);
|
||||
visible_line = xrealloc (visible_line, line_size);
|
||||
line = invisible_line = xrealloc (invisible_line, line_size);
|
||||
visible_line = (char *)xrealloc (visible_line, line_size);
|
||||
line = invisible_line = (char *)xrealloc (invisible_line, line_size);
|
||||
}
|
||||
strncpy (line + out, local_prompt, local_len);
|
||||
out += local_len;
|
||||
|
|
@ -455,8 +455,8 @@ rl_redisplay ()
|
|||
if (temp >= line_size)
|
||||
{
|
||||
line_size = (temp + 1024) - (temp % 1024);
|
||||
visible_line = xrealloc (visible_line, line_size);
|
||||
line = invisible_line = xrealloc (invisible_line, line_size);
|
||||
visible_line = (char *)xrealloc (visible_line, line_size);
|
||||
line = invisible_line = (char *)xrealloc (invisible_line, line_size);
|
||||
}
|
||||
strncpy (line + out, prompt_this_line, pmtlen);
|
||||
out += pmtlen;
|
||||
|
|
@ -530,8 +530,8 @@ rl_redisplay ()
|
|||
if (out + 8 >= line_size) /* XXX - 8 for \t */
|
||||
{
|
||||
line_size *= 2;
|
||||
visible_line = xrealloc (visible_line, line_size);
|
||||
invisible_line = xrealloc (invisible_line, line_size);
|
||||
visible_line = (char *)xrealloc (visible_line, line_size);
|
||||
invisible_line = (char *)xrealloc (invisible_line, line_size);
|
||||
line = invisible_line;
|
||||
}
|
||||
|
||||
|
|
@ -1330,7 +1330,7 @@ rl_character_len (c, pos)
|
|||
if (CTRL_CHAR (c) || c == RUBOUT)
|
||||
return (2);
|
||||
|
||||
return ((isprint (uc)) ? 1 : 2);
|
||||
return ((ISPRINT (uc)) ? 1 : 2);
|
||||
}
|
||||
|
||||
/* How to print things in the "echo-area". The prompt is treated as a
|
||||
|
|
@ -1357,7 +1357,12 @@ rl_message (va_alist)
|
|||
format = va_arg (args, char *);
|
||||
#endif
|
||||
|
||||
#if defined (HAVE_VSNPRINTF)
|
||||
vsnprintf (msg_buf, sizeof (msg_buf) - 1, format, args);
|
||||
#else
|
||||
vsprintf (msg_buf, format, args);
|
||||
msg_buf[sizeof(msg_buf) - 1] = '\0'; /* overflow? */
|
||||
#endif
|
||||
va_end (args);
|
||||
|
||||
rl_display_prompt = msg_buf;
|
||||
|
|
@ -1370,6 +1375,7 @@ rl_message (format, arg1, arg2)
|
|||
char *format;
|
||||
{
|
||||
sprintf (msg_buf, format, arg1, arg2);
|
||||
msg_buf[sizeof(msg_buf) - 1] = '\0'; /* overflow? */
|
||||
rl_display_prompt = msg_buf;
|
||||
(*rl_redisplay_function) ();
|
||||
return 0;
|
||||
|
|
@ -1436,7 +1442,7 @@ _rl_make_prompt_for_search (pchar)
|
|||
if (saved_local_prompt == 0)
|
||||
{
|
||||
len = (rl_prompt && *rl_prompt) ? strlen (rl_prompt) : 0;
|
||||
pmt = xmalloc (len + 2);
|
||||
pmt = (char *)xmalloc (len + 2);
|
||||
if (len)
|
||||
strcpy (pmt, rl_prompt);
|
||||
pmt[len] = pchar;
|
||||
|
|
@ -1445,7 +1451,7 @@ _rl_make_prompt_for_search (pchar)
|
|||
else
|
||||
{
|
||||
len = *saved_local_prompt ? strlen (saved_local_prompt) : 0;
|
||||
pmt = xmalloc (len + 2);
|
||||
pmt = (char *)xmalloc (len + 2);
|
||||
if (len)
|
||||
strcpy (pmt, saved_local_prompt);
|
||||
pmt[len] = pchar;
|
||||
|
|
|
|||
|
|
@ -422,7 +422,7 @@ This is disabled by default.
|
|||
@end deftypevar
|
||||
|
||||
@deftypevar {char *} history_word_delimiters
|
||||
The characters that separate tokens for \fBhistory_tokenize()\fP.
|
||||
The characters that separate tokens for @code{history_tokenize()}.
|
||||
The default value is @code{" \t\n()<>;&|"}.
|
||||
@end deftypevar
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
@set EDITION 4.2-beta
|
||||
@set VERSION 4.2-beta
|
||||
@set UPDATED 2001 Mar 12
|
||||
@set UPDATE-MONTH Mar 2001
|
||||
@set EDITION 4.2a
|
||||
@set VERSION 4.2a
|
||||
@set UPDATED 2001 October 9
|
||||
@set UPDATE-MONTH October 2001
|
||||
|
||||
@set LASTCHANGE Mon Mar 12 05:36:44 EST 2001
|
||||
@set LASTCHANGE Tue Oct 9 15:03:34 EDT 2001
|
||||
|
|
|
|||
|
|
@ -176,6 +176,16 @@ in any file that uses Readline's features. Since some of the definitions
|
|||
in @code{readline.h} use the @code{stdio} library, the file
|
||||
@code{<stdio.h>} should be included before @code{readline.h}.
|
||||
|
||||
@code{readline.h} defines a C preprocessor variable that should
|
||||
be treated as an integer, @code{RL_READLINE_VERSION}, which may
|
||||
be used to conditionally compile application code depending on
|
||||
the installed Readline version. The value is a hexadecimal
|
||||
encoding of the major and minor version numbers of the library,
|
||||
of the form 0x@var{MMmm}. @var{MM} is the two-digit major
|
||||
version number; @var{mm} is the two-digit minor version number.
|
||||
For Readline 4.2, for example, the value of
|
||||
@code{RL_READLINE_VERSION} would be @code{0x0402}.
|
||||
|
||||
@menu
|
||||
* Readline Typedefs:: C declarations to make code readable.
|
||||
* Function Writing:: Variables and calling conventions.
|
||||
|
|
@ -348,6 +358,14 @@ never sets it.
|
|||
The version number of this revision of the library.
|
||||
@end deftypevar
|
||||
|
||||
@deftypevar int rl_readline_version
|
||||
An integer encoding the current version of the library. The encoding is
|
||||
of the form 0x@var{MMmm}, where @var{MM} is the two-digit major version
|
||||
number, and @var{mm} is the two-digit minor version number.
|
||||
For example, for Readline-4.2, @code{rl_readline_version} would have the
|
||||
value 0x0402.
|
||||
@end deftypevar
|
||||
|
||||
@deftypevar {int} rl_gnu_readline_p
|
||||
Always set to 1, denoting that this is @sc{gnu} readline rather than some
|
||||
emulation.
|
||||
|
|
@ -1076,6 +1094,15 @@ Set the time interval (in microseconds) that Readline waits when showing
|
|||
a balancing character when @code{blink-matching-paren} has been enabled.
|
||||
@end deftypefun
|
||||
|
||||
@deftypefun {char *} rl_get_termcap (const char *cap)
|
||||
Retrieve the string value of the termcap capability @var{cap}.
|
||||
Readline fetches the termcap entry for the current terminal name and
|
||||
uses those capabilities to move around the screen line and perform other
|
||||
terminal-specific operations, like erasing a line. Readline does not
|
||||
use all of a terminal's capabilities, and this function will return
|
||||
values for only those capabilities Readline uses.
|
||||
@end deftypefun
|
||||
|
||||
@node Alternate Interface
|
||||
@subsection Alternate Interface
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use these features. There is a document entitled "readline.texinfo"
|
|||
which contains both end-user and programmer documentation for the
|
||||
GNU Readline Library.
|
||||
|
||||
Copyright (C) 1988-2000 Free Software Foundation, Inc.
|
||||
Copyright (C) 1988-2001 Free Software Foundation, Inc.
|
||||
|
||||
Authored by Brian Fox and Chet Ramey.
|
||||
|
||||
|
|
@ -235,7 +235,7 @@ words, to the end of the next word.
|
|||
Word boundaries are the same as those used by @kbd{M-f}.
|
||||
|
||||
@item M-@key{DEL}
|
||||
Kill from the cursor the start of the previous word, or, if between
|
||||
Kill from the cursor the start of the current word, or, if between
|
||||
words, to the start of the previous word.
|
||||
Word boundaries are the same as those used by @kbd{M-b}.
|
||||
|
||||
|
|
@ -312,6 +312,10 @@ the line, thereby executing the command from the history list.
|
|||
A movement command will terminate the search, make the last line found
|
||||
the current line, and begin editing.
|
||||
|
||||
Readline remembers the last incremental search string. If two
|
||||
@kbd{C-r}s are typed without any intervening characters defining a new
|
||||
search string, any remembered search string is used.
|
||||
|
||||
Non-incremental searches read the entire search string before starting
|
||||
to search for matching history lines. The search string may be
|
||||
typed by the user or be part of the contents of the current line.
|
||||
|
|
@ -452,6 +456,11 @@ arrow keys. The default is @samp{off}.
|
|||
If set to @samp{on}, tilde expansion is performed when Readline
|
||||
attempts word completion. The default is @samp{off}.
|
||||
|
||||
@vindex history-preserve-point
|
||||
If set to @samp{on}, the history code attempts to place point at the
|
||||
same location on each history line retrived with @code{previous-history}
|
||||
or @code{next-history}.
|
||||
|
||||
@item horizontal-scroll-mode
|
||||
@vindex horizontal-scroll-mode
|
||||
This variable can be set to either @samp{on} or @samp{off}. Setting it
|
||||
|
|
@ -503,6 +512,14 @@ This variable, when set to @samp{on}, causes Readline to display an
|
|||
asterisk (@samp{*}) at the start of history lines which have been modified.
|
||||
This variable is @samp{off} by default.
|
||||
|
||||
@item match-hidden-files
|
||||
@vindex match-hidden-files
|
||||
This variable, when set to @samp{on}, causes Readline to match files whose
|
||||
names begin with a @samp{.} (hidden files) when performing filename
|
||||
completion, unless the leading @samp{.} is
|
||||
supplied by the user in the filename to be completed.
|
||||
This variable is @samp{on} by default.
|
||||
|
||||
@item output-meta
|
||||
@vindex output-meta
|
||||
If set to @samp{on}, Readline will display characters with the
|
||||
|
|
@ -644,11 +661,11 @@ horizontal tab
|
|||
@item \v
|
||||
vertical tab
|
||||
@item \@var{nnn}
|
||||
the character whose @sc{ascii} code is the octal value @var{nnn}
|
||||
(one to three digits)
|
||||
@item \x@var{nnn}
|
||||
the character whose @sc{ascii} code is the hexadecimal value @var{nnn}
|
||||
the eight-bit character whose value is the octal value @var{nnn}
|
||||
(one to three digits)
|
||||
@item \x@var{HH}
|
||||
the eight-bit character whose value is the hexadecimal value @var{HH}
|
||||
(one or two hex digits)
|
||||
@end table
|
||||
|
||||
When entering the text of a macro, single or double quotes must
|
||||
|
|
@ -1021,6 +1038,8 @@ Negative arguments have no effect.
|
|||
@item transpose-words (M-t)
|
||||
Drag the word before point past the word after point,
|
||||
moving point past that word as well.
|
||||
If the insertion point is at the end of the line, this transposes
|
||||
the last two words on the line.
|
||||
|
||||
@item upcase-word (M-u)
|
||||
Uppercase the current (or following) word. With a negative argument,
|
||||
|
|
@ -1534,7 +1553,7 @@ matches were generated.
|
|||
@item complete
|
||||
@btindex complete
|
||||
@example
|
||||
@code{complete [-abcdefjkvu] [-o @var{comp-option}] [-A @var{action}] [-G @var{globpat}] [-W @var{wordlist}]
|
||||
@code{complete [-abcdefgjkvu] [-o @var{comp-option}] [-A @var{action}] [-G @var{globpat}] [-W @var{wordlist}]
|
||||
[-P @var{prefix}] [-S @var{suffix}] [-X @var{filterpat}] [-F @var{function}]
|
||||
[-C @var{command}] @var{name} [@var{name} @dots{}]}
|
||||
@code{complete -pr [@var{name} @dots{}]}
|
||||
|
|
@ -1617,6 +1636,9 @@ File names. May also be specified as @option{-f}.
|
|||
@item function
|
||||
Names of shell functions.
|
||||
|
||||
@item group
|
||||
Group names. May also be specified as @option{-g}.
|
||||
|
||||
@item helptopic
|
||||
Help topics as accepted by the @code{help} builtin (@pxref{Bash Builtins}).
|
||||
|
||||
|
|
|
|||
|
|
@ -41,15 +41,15 @@
|
|||
extern char *xmalloc ();
|
||||
|
||||
/* The names of functions that actually do the manipulation. */
|
||||
int com_list __P((char *));
|
||||
int com_view __P((char *));
|
||||
int com_rename __P((char *));
|
||||
int com_stat __P((char *));
|
||||
int com_pwd __P((char *));
|
||||
int com_delete __P((char *));
|
||||
int com_help __P((char *));
|
||||
int com_cd __P((char *));
|
||||
int com_quit __P((char *));
|
||||
int com_list PARAMS((char *));
|
||||
int com_view PARAMS((char *));
|
||||
int com_rename PARAMS((char *));
|
||||
int com_stat PARAMS((char *));
|
||||
int com_pwd PARAMS((char *));
|
||||
int com_delete PARAMS((char *));
|
||||
int com_help PARAMS((char *));
|
||||
int com_cd PARAMS((char *));
|
||||
int com_quit PARAMS((char *));
|
||||
|
||||
/* A structure which contains information on the commands this program
|
||||
can understand. */
|
||||
|
|
@ -212,8 +212,8 @@ stripwhite (string)
|
|||
/* */
|
||||
/* **************************************************************** */
|
||||
|
||||
char *command_generator __P((const char *, int));
|
||||
char **fileman_completion __P((const char *, int, int));
|
||||
char *command_generator PARAMS((const char *, int));
|
||||
char **fileman_completion PARAMS((const char *, int, int));
|
||||
|
||||
/* Tell the GNU Readline library how to complete. We want to try to complete
|
||||
on command names if this is the first word in the line, or on filenames
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ typedef int QSFUNC (const void *, const void *);
|
|||
typedef int QSFUNC ();
|
||||
#endif
|
||||
|
||||
extern int _rl_qsort_string_compare __P((char **, char **));
|
||||
extern int _rl_qsort_string_compare PARAMS((char **, char **));
|
||||
|
||||
FUNMAP **funmap;
|
||||
static int funmap_size;
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@
|
|||
#define HISTORY_WORD_DELIMITERS " \t\n;&()|<>"
|
||||
#define HISTORY_QUOTE_CHARACTERS "\"'`"
|
||||
|
||||
typedef int _hist_search_func_t __P((const char *, int));
|
||||
typedef int _hist_search_func_t PARAMS((const char *, int));
|
||||
|
||||
static char error_pointer;
|
||||
|
||||
|
|
@ -65,10 +65,10 @@ static char *subst_rhs;
|
|||
static int subst_lhs_len;
|
||||
static int subst_rhs_len;
|
||||
|
||||
static char *get_history_word_specifier __P((char *, char *, int *));
|
||||
static char *history_find_word __P((char *, int));
|
||||
static char *get_history_word_specifier PARAMS((char *, char *, int *));
|
||||
static char *history_find_word PARAMS((char *, int));
|
||||
|
||||
static char *quote_breaks __P((char *));
|
||||
static char *quote_breaks PARAMS((char *));
|
||||
|
||||
/* Variables exported by this file. */
|
||||
/* The character that represents the start of a history expansion
|
||||
|
|
@ -212,7 +212,7 @@ get_history_event (string, caller_index, delimiting_quote)
|
|||
break;
|
||||
|
||||
which = i - local_index;
|
||||
temp = xmalloc (1 + which);
|
||||
temp = (char *)xmalloc (1 + which);
|
||||
if (which)
|
||||
strncpy (temp, string + local_index, which);
|
||||
temp[which] = '\0';
|
||||
|
|
@ -314,7 +314,7 @@ quote_breaks (s)
|
|||
len += 2;
|
||||
}
|
||||
|
||||
r = ret = xmalloc (len);
|
||||
r = ret = (char *)xmalloc (len);
|
||||
*r++ = '\'';
|
||||
for (p = s; p && *p; )
|
||||
{
|
||||
|
|
@ -379,7 +379,7 @@ hist_error(s, start, current, errtype)
|
|||
break;
|
||||
}
|
||||
|
||||
temp = xmalloc (ll + elen + 3);
|
||||
temp = (char *)xmalloc (ll + elen + 3);
|
||||
strncpy (temp, s + start, ll);
|
||||
temp[ll] = ':';
|
||||
temp[ll + 1] = ' ';
|
||||
|
|
@ -415,7 +415,7 @@ get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
|
|||
|
||||
if (si > i || is_rhs)
|
||||
{
|
||||
s = xmalloc (si - i + 1);
|
||||
s = (char *)xmalloc (si - i + 1);
|
||||
for (j = 0, k = i; k < si; j++, k++)
|
||||
{
|
||||
/* Remove a backslash quoting the search string delimiter. */
|
||||
|
|
@ -442,13 +442,13 @@ postproc_subst_rhs ()
|
|||
char *new;
|
||||
int i, j, new_size;
|
||||
|
||||
new = xmalloc (new_size = subst_rhs_len + subst_lhs_len);
|
||||
new = (char *)xmalloc (new_size = subst_rhs_len + subst_lhs_len);
|
||||
for (i = j = 0; i < subst_rhs_len; i++)
|
||||
{
|
||||
if (subst_rhs[i] == '&')
|
||||
{
|
||||
if (j + subst_lhs_len >= new_size)
|
||||
new = xrealloc (new, (new_size = new_size * 2 + subst_lhs_len));
|
||||
new = (char *)xrealloc (new, (new_size = new_size * 2 + subst_lhs_len));
|
||||
strcpy (new + j, subst_lhs);
|
||||
j += subst_lhs_len;
|
||||
}
|
||||
|
|
@ -458,7 +458,7 @@ postproc_subst_rhs ()
|
|||
if (subst_rhs[i] == '\\' && subst_rhs[i + 1] == '&')
|
||||
i++;
|
||||
if (j >= new_size)
|
||||
new = xrealloc (new, new_size *= 2);
|
||||
new = (char *)xrealloc (new, new_size *= 2);
|
||||
new[j++] = subst_rhs[i];
|
||||
}
|
||||
}
|
||||
|
|
@ -485,7 +485,7 @@ history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
|
|||
char *event, *temp, *result, *tstr, *t, c, *word_spec;
|
||||
int result_len;
|
||||
|
||||
result = xmalloc (result_len = 128);
|
||||
result = (char *)xmalloc (result_len = 128);
|
||||
|
||||
i = start;
|
||||
|
||||
|
|
@ -698,7 +698,7 @@ history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
|
|||
if (STREQN (temp+si, subst_lhs, subst_lhs_len))
|
||||
{
|
||||
int len = subst_rhs_len - subst_lhs_len + l_temp;
|
||||
new_event = xmalloc (1 + len);
|
||||
new_event = (char *)xmalloc (1 + len);
|
||||
strncpy (new_event, temp, si);
|
||||
strncpy (new_event + si, subst_rhs, subst_rhs_len);
|
||||
strncpy (new_event + si + subst_rhs_len,
|
||||
|
|
@ -759,7 +759,7 @@ history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
|
|||
|
||||
n = strlen (temp);
|
||||
if (n >= result_len)
|
||||
result = xrealloc (result, n + 2);
|
||||
result = (char *)xrealloc (result, n + 2);
|
||||
strcpy (result, temp);
|
||||
free (temp);
|
||||
|
||||
|
|
@ -790,7 +790,7 @@ history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
|
|||
{ \
|
||||
while (j >= result_len) \
|
||||
result_len += 128; \
|
||||
result = xrealloc (result, result_len); \
|
||||
result = (char *)xrealloc (result, result_len); \
|
||||
} \
|
||||
strcpy (result + j - sl, s); \
|
||||
} \
|
||||
|
|
@ -800,7 +800,7 @@ history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
|
|||
do \
|
||||
{ \
|
||||
if (j >= result_len - 1) \
|
||||
result = xrealloc (result, result_len += 64); \
|
||||
result = (char *)xrealloc (result, result_len += 64); \
|
||||
result[j++] = c; \
|
||||
result[j] = '\0'; \
|
||||
} \
|
||||
|
|
@ -834,7 +834,7 @@ history_expand (hstring, output)
|
|||
}
|
||||
|
||||
/* Prepare the buffer for printing error messages. */
|
||||
result = xmalloc (result_len = 256);
|
||||
result = (char *)xmalloc (result_len = 256);
|
||||
result[0] = '\0';
|
||||
|
||||
only_printing = modified = 0;
|
||||
|
|
@ -851,7 +851,7 @@ history_expand (hstring, output)
|
|||
that is the substitution that we do. */
|
||||
if (hstring[0] == history_subst_char)
|
||||
{
|
||||
string = xmalloc (l + 5);
|
||||
string = (char *)xmalloc (l + 5);
|
||||
|
||||
string[0] = string[1] = history_expansion_char;
|
||||
string[2] = ':';
|
||||
|
|
@ -960,7 +960,7 @@ history_expand (hstring, output)
|
|||
hist_string_extract_single_quoted (string, &i);
|
||||
|
||||
slen = i - quote + 2;
|
||||
temp = xmalloc (slen);
|
||||
temp = (char *)xmalloc (slen);
|
||||
strncpy (temp, string + quote, slen);
|
||||
temp[slen - 1] = '\0';
|
||||
ADD_STRING (temp);
|
||||
|
|
@ -974,7 +974,7 @@ history_expand (hstring, output)
|
|||
case -2: /* history_comment_char */
|
||||
if (i == 0 || member (string[i - 1], history_word_delimiters))
|
||||
{
|
||||
temp = xmalloc (l - i + 1);
|
||||
temp = (char *)xmalloc (l - i + 1);
|
||||
strcpy (temp, string + i);
|
||||
ADD_STRING (temp);
|
||||
free (temp);
|
||||
|
|
@ -1006,7 +1006,7 @@ history_expand (hstring, output)
|
|||
{
|
||||
if (result)
|
||||
{
|
||||
temp = xmalloc (1 + strlen (result));
|
||||
temp = (char *)xmalloc (1 + strlen (result));
|
||||
strcpy (temp, result);
|
||||
ADD_STRING (temp);
|
||||
free (temp);
|
||||
|
|
@ -1140,7 +1140,14 @@ get_history_word_specifier (spec, from, caller_index)
|
|||
i++;
|
||||
last = '$';
|
||||
}
|
||||
else if (!spec[i] || spec[i] == ':') /* could be modifier separator */
|
||||
#if 0
|
||||
else if (!spec[i] || spec[i] == ':')
|
||||
/* check against `:' because there could be a modifier separator */
|
||||
#else
|
||||
else
|
||||
/* csh seems to allow anything to terminate the word spec here,
|
||||
leaving it as an abbreviation. */
|
||||
#endif
|
||||
last = -1; /* x- abbreviates x-$ omitting word `$' */
|
||||
}
|
||||
|
||||
|
|
@ -1196,7 +1203,7 @@ history_arg_extract (first, last, string)
|
|||
{
|
||||
for (size = 0, i = first; i < last; i++)
|
||||
size += strlen (list[i]) + 1;
|
||||
result = xmalloc (size + 1);
|
||||
result = (char *)xmalloc (size + 1);
|
||||
result[0] = '\0';
|
||||
|
||||
for (i = first, offset = 0; i < last; i++)
|
||||
|
|
@ -1329,7 +1336,7 @@ history_tokenize_internal (string, wind, indp)
|
|||
len = i - start;
|
||||
if (result_index + 2 >= size)
|
||||
result = (char **)xrealloc (result, ((size += 10) * sizeof (char *)));
|
||||
result[result_index] = xmalloc (1 + len);
|
||||
result[result_index] = (char *)xmalloc (1 + len);
|
||||
strncpy (result[result_index], string + start, len);
|
||||
result[result_index][len] = '\0';
|
||||
result[++result_index] = (char *)NULL;
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ history_filename (filename)
|
|||
else
|
||||
home_len = strlen (home);
|
||||
|
||||
return_val = xmalloc (2 + home_len + 8); /* strlen(".history") == 8 */
|
||||
return_val = (char *)xmalloc (2 + home_len + 8); /* strlen(".history") == 8 */
|
||||
strcpy (return_val, home);
|
||||
return_val[home_len] = '/';
|
||||
#if defined (__MSDOS__)
|
||||
|
|
@ -161,7 +161,7 @@ read_history_range (filename, from, to)
|
|||
goto error_and_exit;
|
||||
}
|
||||
|
||||
buffer = xmalloc (file_size + 1);
|
||||
buffer = (char *)xmalloc (file_size + 1);
|
||||
|
||||
chars_read = read (file, buffer, file_size);
|
||||
if (chars_read < 0)
|
||||
|
|
@ -276,7 +276,7 @@ history_truncate_file (fname, lines)
|
|||
goto truncate_exit;
|
||||
}
|
||||
|
||||
buffer = xmalloc (file_size + 1);
|
||||
buffer = (char *)xmalloc (file_size + 1);
|
||||
chars_read = read (file, buffer, file_size);
|
||||
close (file);
|
||||
|
||||
|
|
@ -367,7 +367,7 @@ history_do_write (filename, nelements, overwrite)
|
|||
buffer_size += 1 + strlen (the_history[i]->line);
|
||||
|
||||
/* Allocate the buffer, and fill it. */
|
||||
buffer = xmalloc (buffer_size);
|
||||
buffer = (char *)xmalloc (buffer_size);
|
||||
|
||||
for (j = 0, i = history_length - nelements; i < history_length; i++)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -71,6 +71,9 @@ static HIST_ENTRY **the_history = (HIST_ENTRY **)NULL;
|
|||
history that we save. */
|
||||
static int history_stifled;
|
||||
|
||||
/* The current number of slots allocated to the input_history. */
|
||||
static int history_size;
|
||||
|
||||
/* If HISTORY_STIFLED is non-zero, then this is the maximum number of
|
||||
entries to remember. */
|
||||
int history_max_entries;
|
||||
|
|
@ -83,9 +86,6 @@ int history_offset;
|
|||
/* The number of strings currently stored in the history list. */
|
||||
int history_length;
|
||||
|
||||
/* The current number of slots allocated to the input_history. */
|
||||
static int history_size;
|
||||
|
||||
/* The logical `base' of the history array. It defaults to 1. */
|
||||
int history_base = 1;
|
||||
|
||||
|
|
|
|||
|
|
@ -62,81 +62,81 @@ typedef struct _hist_state {
|
|||
|
||||
/* Begin a session in which the history functions might be used. This
|
||||
just initializes the interactive variables. */
|
||||
extern void using_history __P((void));
|
||||
extern void using_history PARAMS((void));
|
||||
|
||||
/* Return the current HISTORY_STATE of the history. */
|
||||
extern HISTORY_STATE *history_get_history_state __P((void));
|
||||
extern HISTORY_STATE *history_get_history_state PARAMS((void));
|
||||
|
||||
/* Set the state of the current history array to STATE. */
|
||||
extern void history_set_history_state __P((HISTORY_STATE *));
|
||||
extern void history_set_history_state PARAMS((HISTORY_STATE *));
|
||||
|
||||
/* Manage the history list. */
|
||||
|
||||
/* Place STRING at the end of the history list.
|
||||
The associated data field (if any) is set to NULL. */
|
||||
extern void add_history __P((const char *));
|
||||
extern void add_history PARAMS((const char *));
|
||||
|
||||
/* A reasonably useless function, only here for completeness. WHICH
|
||||
is the magic number that tells us which element to delete. The
|
||||
elements are numbered from 0. */
|
||||
extern HIST_ENTRY *remove_history __P((int));
|
||||
extern HIST_ENTRY *remove_history PARAMS((int));
|
||||
|
||||
/* Make the history entry at WHICH have LINE and DATA. This returns
|
||||
the old entry so you can dispose of the data. In the case of an
|
||||
invalid WHICH, a NULL pointer is returned. */
|
||||
extern HIST_ENTRY *replace_history_entry __P((int, const char *, histdata_t));
|
||||
extern HIST_ENTRY *replace_history_entry PARAMS((int, const char *, histdata_t));
|
||||
|
||||
/* Clear the history list and start over. */
|
||||
extern void clear_history __P((void));
|
||||
extern void clear_history PARAMS((void));
|
||||
|
||||
/* Stifle the history list, remembering only MAX number of entries. */
|
||||
extern void stifle_history __P((int));
|
||||
extern void stifle_history PARAMS((int));
|
||||
|
||||
/* Stop stifling the history. This returns the previous amount the
|
||||
history was stifled by. The value is positive if the history was
|
||||
stifled, negative if it wasn't. */
|
||||
extern int unstifle_history __P((void));
|
||||
extern int unstifle_history PARAMS((void));
|
||||
|
||||
/* Return 1 if the history is stifled, 0 if it is not. */
|
||||
extern int history_is_stifled __P((void));
|
||||
extern int history_is_stifled PARAMS((void));
|
||||
|
||||
/* Information about the history list. */
|
||||
|
||||
/* Return a NULL terminated array of HIST_ENTRY which is the current input
|
||||
history. Element 0 of this list is the beginning of time. If there
|
||||
is no history, return NULL. */
|
||||
extern HIST_ENTRY **history_list __P((void));
|
||||
extern HIST_ENTRY **history_list PARAMS((void));
|
||||
|
||||
/* Returns the number which says what history element we are now
|
||||
looking at. */
|
||||
extern int where_history __P((void));
|
||||
extern int where_history PARAMS((void));
|
||||
|
||||
/* Return the history entry at the current position, as determined by
|
||||
history_offset. If there is no entry there, return a NULL pointer. */
|
||||
extern HIST_ENTRY *current_history __P((void));
|
||||
extern HIST_ENTRY *current_history PARAMS((void));
|
||||
|
||||
/* Return the history entry which is logically at OFFSET in the history
|
||||
array. OFFSET is relative to history_base. */
|
||||
extern HIST_ENTRY *history_get __P((int));
|
||||
extern HIST_ENTRY *history_get PARAMS((int));
|
||||
|
||||
/* Return the number of bytes that the primary history entries are using.
|
||||
This just adds up the lengths of the_history->lines. */
|
||||
extern int history_total_bytes __P((void));
|
||||
extern int history_total_bytes PARAMS((void));
|
||||
|
||||
/* Moving around the history list. */
|
||||
|
||||
/* Set the position in the history list to POS. */
|
||||
extern int history_set_pos __P((int));
|
||||
extern int history_set_pos PARAMS((int));
|
||||
|
||||
/* Back up history_offset to the previous history entry, and return
|
||||
a pointer to that entry. If there is no previous entry, return
|
||||
a NULL pointer. */
|
||||
extern HIST_ENTRY *previous_history __P((void));
|
||||
extern HIST_ENTRY *previous_history PARAMS((void));
|
||||
|
||||
/* Move history_offset forward to the next item in the input_history,
|
||||
and return the a pointer to that entry. If there is no next entry,
|
||||
return a NULL pointer. */
|
||||
extern HIST_ENTRY *next_history __P((void));
|
||||
extern HIST_ENTRY *next_history PARAMS((void));
|
||||
|
||||
/* Searching the history list. */
|
||||
|
||||
|
|
@ -146,45 +146,45 @@ extern HIST_ENTRY *next_history __P((void));
|
|||
current_history () is the history entry, and the value of this function
|
||||
is the offset in the line of that history entry that the string was
|
||||
found in. Otherwise, nothing is changed, and a -1 is returned. */
|
||||
extern int history_search __P((const char *, int));
|
||||
extern int history_search PARAMS((const char *, int));
|
||||
|
||||
/* Search the history for STRING, starting at history_offset.
|
||||
The search is anchored: matching lines must begin with string.
|
||||
DIRECTION is as in history_search(). */
|
||||
extern int history_search_prefix __P((const char *, int));
|
||||
extern int history_search_prefix PARAMS((const char *, int));
|
||||
|
||||
/* Search for STRING in the history list, starting at POS, an
|
||||
absolute index into the list. DIR, if negative, says to search
|
||||
backwards from POS, else forwards.
|
||||
Returns the absolute index of the history element where STRING
|
||||
was found, or -1 otherwise. */
|
||||
extern int history_search_pos __P((const char *, int, int));
|
||||
extern int history_search_pos PARAMS((const char *, int, int));
|
||||
|
||||
/* Managing the history file. */
|
||||
|
||||
/* Add the contents of FILENAME to the history list, a line at a time.
|
||||
If FILENAME is NULL, then read from ~/.history. Returns 0 if
|
||||
successful, or errno if not. */
|
||||
extern int read_history __P((const char *));
|
||||
extern int read_history PARAMS((const char *));
|
||||
|
||||
/* Read a range of lines from FILENAME, adding them to the history list.
|
||||
Start reading at the FROM'th line and end at the TO'th. If FROM
|
||||
is zero, start at the beginning. If TO is less than FROM, read
|
||||
until the end of the file. If FILENAME is NULL, then read from
|
||||
~/.history. Returns 0 if successful, or errno if not. */
|
||||
extern int read_history_range __P((const char *, int, int));
|
||||
extern int read_history_range PARAMS((const char *, int, int));
|
||||
|
||||
/* Write the current history to FILENAME. If FILENAME is NULL,
|
||||
then write the history list to ~/.history. Values returned
|
||||
are as in read_history (). */
|
||||
extern int write_history __P((const char *));
|
||||
extern int write_history PARAMS((const char *));
|
||||
|
||||
/* Append NELEMENT entries to FILENAME. The entries appended are from
|
||||
the end of the list minus NELEMENTs up to the end of the list. */
|
||||
extern int append_history __P((int, const char *));
|
||||
extern int append_history PARAMS((int, const char *));
|
||||
|
||||
/* Truncate the history file, leaving only the last NLINES lines. */
|
||||
extern int history_truncate_file __P((const char *, int));
|
||||
extern int history_truncate_file PARAMS((const char *, int));
|
||||
|
||||
/* History expansion. */
|
||||
|
||||
|
|
@ -200,12 +200,12 @@ extern int history_truncate_file __P((const char *, int));
|
|||
|
||||
If an error ocurred in expansion, then OUTPUT contains a descriptive
|
||||
error message. */
|
||||
extern int history_expand __P((char *, char **));
|
||||
extern int history_expand PARAMS((char *, char **));
|
||||
|
||||
/* Extract a string segment consisting of the FIRST through LAST
|
||||
arguments present in STRING. Arguments are broken up as in
|
||||
the shell. */
|
||||
extern char *history_arg_extract __P((int, int, const char *));
|
||||
extern char *history_arg_extract PARAMS((int, int, const char *));
|
||||
|
||||
/* Return the text of the history event beginning at the current
|
||||
offset into STRING. Pass STRING with *INDEX equal to the
|
||||
|
|
@ -213,11 +213,11 @@ extern char *history_arg_extract __P((int, int, const char *));
|
|||
DELIMITING_QUOTE is a character that is allowed to end the string
|
||||
specification for what to search for in addition to the normal
|
||||
characters `:', ` ', `\t', `\n', and sometimes `?'. */
|
||||
extern char *get_history_event __P((const char *, int *, int));
|
||||
extern char *get_history_event PARAMS((const char *, int *, int));
|
||||
|
||||
/* Return an array of tokens, much as the shell might. The tokens are
|
||||
parsed out of STRING. */
|
||||
extern char **history_tokenize __P((const char *));
|
||||
extern char **history_tokenize PARAMS((const char *));
|
||||
|
||||
/* Exported history variables. */
|
||||
extern int history_base;
|
||||
|
|
|
|||
|
|
@ -51,6 +51,8 @@
|
|||
string. */
|
||||
char *history_search_delimiter_chars = (char *)NULL;
|
||||
|
||||
static int history_search_internal PARAMS((const char *, int, int));
|
||||
|
||||
/* Search the history for STRING, starting at history_offset.
|
||||
If DIRECTION < 0, then the search is through previous entries, else
|
||||
through subsequent. If ANCHORED is non-zero, the string must
|
||||
|
|
|
|||
|
|
@ -84,6 +84,11 @@ rl_getc_func_t *rl_getc_function = rl_getc;
|
|||
|
||||
static int _keyboard_input_timeout = 100000; /* 0.1 seconds; it's in usec */
|
||||
|
||||
static int ibuffer_space PARAMS((void));
|
||||
static int rl_get_char PARAMS((int *));
|
||||
static int rl_unget_char PARAMS((int));
|
||||
static void rl_gather_tyi PARAMS((void));
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
/* Character Input Buffering */
|
||||
|
|
@ -245,7 +250,7 @@ _rl_input_available ()
|
|||
fd_set readfds, exceptfds;
|
||||
struct timeval timeout;
|
||||
#endif
|
||||
#if defined(FIONREAD)
|
||||
#if !defined (HAVE_SELECT) && defined(FIONREAD)
|
||||
int chars_avail;
|
||||
#endif
|
||||
int tty;
|
||||
|
|
@ -260,11 +265,13 @@ _rl_input_available ()
|
|||
timeout.tv_sec = 0;
|
||||
timeout.tv_usec = _keyboard_input_timeout;
|
||||
return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
|
||||
#endif
|
||||
#else
|
||||
|
||||
#if defined (FIONREAD)
|
||||
if (ioctl (tty, FIONREAD, &chars_avail) == 0)
|
||||
return (chars_avail);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
|
|
@ -278,7 +285,7 @@ _rl_insert_typein (c)
|
|||
char *string;
|
||||
|
||||
i = key = 0;
|
||||
string = xmalloc (ibuffer_len + 1);
|
||||
string = (char *)xmalloc (ibuffer_len + 1);
|
||||
string[i++] = (char) c;
|
||||
|
||||
while ((t = rl_get_char (&key)) &&
|
||||
|
|
|
|||
|
|
@ -52,19 +52,23 @@
|
|||
#include "xmalloc.h"
|
||||
|
||||
/* Variables exported to other files in the readline library. */
|
||||
unsigned char *_rl_isearch_terminators = (unsigned char *)NULL;
|
||||
char *_rl_isearch_terminators = (char *)NULL;
|
||||
|
||||
/* Variables imported from other files in the readline library. */
|
||||
extern HIST_ENTRY *_rl_saved_line_for_history;
|
||||
|
||||
/* Forward declarations */
|
||||
static int rl_search_history __P((int, int));
|
||||
static int rl_search_history PARAMS((int, int));
|
||||
|
||||
/* Last line found by the current incremental search, so we don't `find'
|
||||
identical lines many times in a row. */
|
||||
static char *prev_line_found;
|
||||
|
||||
static unsigned char *default_isearch_terminators = "\033\012";
|
||||
/* Last search string and its length. */
|
||||
static char *last_isearch_string;
|
||||
static int last_isearch_string_len;
|
||||
|
||||
static char *default_isearch_terminators = "\033\012";
|
||||
|
||||
/* Search backwards through the history looking for a string which is typed
|
||||
interactively. Start with the current line. */
|
||||
|
|
@ -99,7 +103,7 @@ rl_display_search (search_string, reverse_p, where)
|
|||
|
||||
searchlen = (search_string && *search_string) ? strlen (search_string) : 0;
|
||||
|
||||
message = xmalloc (searchlen + 33);
|
||||
message = (char *)xmalloc (searchlen + 33);
|
||||
msglen = 0;
|
||||
|
||||
#if defined (NOTDEF)
|
||||
|
|
@ -129,7 +133,7 @@ rl_display_search (search_string, reverse_p, where)
|
|||
|
||||
strcpy (message + msglen, "': ");
|
||||
|
||||
rl_message ("%s", message, 0);
|
||||
rl_message ("%s", message);
|
||||
free (message);
|
||||
(*rl_redisplay_function) ();
|
||||
}
|
||||
|
|
@ -176,7 +180,7 @@ rl_search_history (direction, invoking_key)
|
|||
/* The list of characters which terminate the search, but are not
|
||||
subsequently executed. If the variable isearch-terminators has
|
||||
been set, we use that value, otherwise we use ESC and C-J. */
|
||||
unsigned char *isearch_terminators;
|
||||
char *isearch_terminators;
|
||||
|
||||
RL_SETSTATE(RL_STATE_ISEARCH);
|
||||
orig_point = rl_point;
|
||||
|
|
@ -205,7 +209,7 @@ rl_search_history (direction, invoking_key)
|
|||
else
|
||||
{
|
||||
/* Keep track of this so we can free it. */
|
||||
allocated_line = xmalloc (1 + strlen (rl_line_buffer));
|
||||
allocated_line = (char *)xmalloc (1 + strlen (rl_line_buffer));
|
||||
strcpy (allocated_line, &rl_line_buffer[0]);
|
||||
lines[i] = allocated_line;
|
||||
}
|
||||
|
|
@ -218,7 +222,7 @@ rl_search_history (direction, invoking_key)
|
|||
rl_save_prompt ();
|
||||
|
||||
/* Initialize search parameters. */
|
||||
search_string = xmalloc (search_string_size = 128);
|
||||
search_string = (char *)xmalloc (search_string_size = 128);
|
||||
*search_string = '\0';
|
||||
search_string_index = 0;
|
||||
prev_line_found = (char *)0; /* XXX */
|
||||
|
|
@ -242,7 +246,7 @@ rl_search_history (direction, invoking_key)
|
|||
c = rl_read_key ();
|
||||
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
||||
|
||||
if (_rl_keymap[c].type == ISFUNC)
|
||||
if (c >= 0 && _rl_keymap[c].type == ISFUNC)
|
||||
{
|
||||
f = _rl_keymap[c].function;
|
||||
|
||||
|
|
@ -288,7 +292,18 @@ rl_search_history (direction, invoking_key)
|
|||
{
|
||||
case -1:
|
||||
if (search_string_index == 0)
|
||||
continue;
|
||||
{
|
||||
if (last_isearch_string)
|
||||
{
|
||||
search_string_size = 64 + last_isearch_string_len;
|
||||
search_string = (char *)xrealloc (search_string, search_string_size);
|
||||
strcpy (search_string, last_isearch_string);
|
||||
search_string_index = last_isearch_string_len;
|
||||
rl_display_search (search_string, reverse, -1);
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (reverse)
|
||||
--line_index;
|
||||
else if (line_index != sline_len)
|
||||
|
|
@ -335,7 +350,7 @@ rl_search_history (direction, invoking_key)
|
|||
if (search_string_index + 2 >= search_string_size)
|
||||
{
|
||||
search_string_size += 128;
|
||||
search_string = xrealloc (search_string, search_string_size);
|
||||
search_string = (char *)xrealloc (search_string, search_string_size);
|
||||
}
|
||||
search_string[search_string_index++] = c;
|
||||
search_string[search_string_index] = '\0';
|
||||
|
|
@ -428,8 +443,15 @@ rl_search_history (direction, invoking_key)
|
|||
|
||||
rl_restore_prompt ();
|
||||
|
||||
#if 1
|
||||
/* Save the search string for possible later use. */
|
||||
FREE (last_isearch_string);
|
||||
last_isearch_string = search_string;
|
||||
last_isearch_string_len = search_string_index;
|
||||
#else
|
||||
/* Free the search string. */
|
||||
free (search_string);
|
||||
#endif
|
||||
|
||||
if (last_found_line < orig_line)
|
||||
rl_get_previous_history (orig_line - last_found_line, 0);
|
||||
|
|
@ -442,8 +464,7 @@ rl_search_history (direction, invoking_key)
|
|||
rl_point = line_index;
|
||||
rl_clear_message ();
|
||||
|
||||
if (allocated_line)
|
||||
free (allocated_line);
|
||||
FREE (allocated_line);
|
||||
free (lines);
|
||||
|
||||
RL_UNSETSTATE(RL_STATE_ISEARCH);
|
||||
|
|
|
|||
|
|
@ -70,30 +70,30 @@ extern KEYMAP_ENTRY_ARRAY vi_insertion_keymap, vi_movement_keymap;
|
|||
|
||||
/* Return a new, empty keymap.
|
||||
Free it with free() when you are done. */
|
||||
extern Keymap rl_make_bare_keymap __P((void));
|
||||
extern Keymap rl_make_bare_keymap PARAMS((void));
|
||||
|
||||
/* Return a new keymap which is a copy of MAP. */
|
||||
extern Keymap rl_copy_keymap __P((Keymap));
|
||||
extern Keymap rl_copy_keymap PARAMS((Keymap));
|
||||
|
||||
/* Return a new keymap with the printing characters bound to rl_insert,
|
||||
the lowercase Meta characters bound to run their equivalents, and
|
||||
the Meta digits bound to produce numeric arguments. */
|
||||
extern Keymap rl_make_keymap __P((void));
|
||||
extern Keymap rl_make_keymap PARAMS((void));
|
||||
|
||||
/* Free the storage associated with a keymap. */
|
||||
extern void rl_discard_keymap __P((Keymap));
|
||||
extern void rl_discard_keymap PARAMS((Keymap));
|
||||
|
||||
/* These functions actually appear in bind.c */
|
||||
|
||||
/* Return the keymap corresponding to a given name. Names look like
|
||||
`emacs' or `emacs-meta' or `vi-insert'. */
|
||||
extern Keymap rl_get_keymap_by_name __P((const char *));
|
||||
extern Keymap rl_get_keymap_by_name PARAMS((const char *));
|
||||
|
||||
/* Return the current keymap. */
|
||||
extern Keymap rl_get_keymap __P((void));
|
||||
extern Keymap rl_get_keymap PARAMS((void));
|
||||
|
||||
/* Set the current keymap to MAP. */
|
||||
extern void rl_set_keymap __P((Keymap));
|
||||
extern void rl_set_keymap PARAMS((Keymap));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,6 +70,11 @@ static int rl_kill_index;
|
|||
/* How many slots we have in the kill ring. */
|
||||
static int rl_kill_ring_length;
|
||||
|
||||
static int _rl_copy_to_kill_ring PARAMS((char *, int));
|
||||
static int region_kill_internal PARAMS((int));
|
||||
static int _rl_copy_word_as_kill PARAMS((int, int));
|
||||
static int rl_yank_nth_arg_internal PARAMS((int, int, int));
|
||||
|
||||
/* How to say that you only want to save a certain amount
|
||||
of kill material. */
|
||||
int
|
||||
|
|
@ -129,7 +134,7 @@ _rl_copy_to_kill_ring (text, append)
|
|||
if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)
|
||||
{
|
||||
old = rl_kill_ring[slot];
|
||||
new = xmalloc (1 + strlen (old) + strlen (text));
|
||||
new = (char *)xmalloc (1 + strlen (old) + strlen (text));
|
||||
|
||||
if (append)
|
||||
{
|
||||
|
|
@ -612,7 +617,7 @@ rl_paste_from_clipboard (count, key)
|
|||
if (ptr)
|
||||
{
|
||||
len = ptr - data;
|
||||
ptr = xmalloc (len + 1);
|
||||
ptr = (char *)xmalloc (len + 1);
|
||||
ptr[len] = '\0';
|
||||
strncpy (ptr, data, len);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -163,9 +163,9 @@ _rl_add_macro_char (c)
|
|||
if (current_macro_index + 1 >= current_macro_size)
|
||||
{
|
||||
if (current_macro == 0)
|
||||
current_macro = xmalloc (current_macro_size = 25);
|
||||
current_macro = (char *)xmalloc (current_macro_size = 25);
|
||||
else
|
||||
current_macro = xrealloc (current_macro, current_macro_size += 25);
|
||||
current_macro = (char *)xrealloc (current_macro, current_macro_size += 25);
|
||||
}
|
||||
|
||||
current_macro[current_macro_index++] = c;
|
||||
|
|
|
|||
|
|
@ -71,8 +71,8 @@ static char *legal_lang_values[] =
|
|||
0
|
||||
};
|
||||
|
||||
static char *normalize_codeset __P((char *));
|
||||
static char *find_codeset __P((char *, size_t *));
|
||||
static char *normalize_codeset PARAMS((char *));
|
||||
static char *find_codeset PARAMS((char *, size_t *));
|
||||
#endif /* !HAVE_SETLOCALE */
|
||||
|
||||
/* Check for LC_ALL, LC_CTYPE, and LANG and use the first with a value
|
||||
|
|
@ -141,10 +141,10 @@ normalize_codeset (codeset)
|
|||
all_digits = 1;
|
||||
for (len = 0, i = 0; i < namelen; i++)
|
||||
{
|
||||
if (isalnum (codeset[i]))
|
||||
if (ISALNUM ((unsigned char)codeset[i]))
|
||||
{
|
||||
len++;
|
||||
all_digits &= isdigit (codeset[i]);
|
||||
all_digits &= _rl_digit_p (codeset[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -162,9 +162,9 @@ normalize_codeset (codeset)
|
|||
}
|
||||
|
||||
for (i = 0; i < namelen; i++)
|
||||
if (isalpha (codeset[i]))
|
||||
*wp++ = (isupper (codeset[i])) ? tolower (codeset[i]) : codeset[i];
|
||||
else if (isdigit (codeset[i]))
|
||||
if (ISALPHA ((unsigned char)codeset[i]))
|
||||
*wp++ = _rl_to_lower (codeset[i]);
|
||||
else if (_rl_digit_p (codeset[i]))
|
||||
*wp++ = codeset[i];
|
||||
*wp = '\0';
|
||||
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ extern char *strchr (), *strrchr ();
|
|||
#include "readline.h"
|
||||
#include "rlprivate.h"
|
||||
|
||||
static int find_matching_open __P((char *, int, int));
|
||||
static int find_matching_open PARAMS((char *, int, int));
|
||||
|
||||
/* Non-zero means try to blink the matching open parenthesis when the
|
||||
close parenthesis is inserted. */
|
||||
|
|
|
|||
|
|
@ -67,22 +67,26 @@
|
|||
#include "xmalloc.h"
|
||||
|
||||
#ifndef RL_LIBRARY_VERSION
|
||||
# define RL_LIBRARY_VERSION "4.2"
|
||||
# define RL_LIBRARY_VERSION "4.2a"
|
||||
#endif
|
||||
|
||||
#ifndef RL_READLINE_VERSION
|
||||
# define RL_READLINE_VERSION 0x0402
|
||||
#endif
|
||||
|
||||
/* Evaluates its arguments multiple times. */
|
||||
#define SWAP(s, e) do { int t; t = s; s = e; e = t; } while (0)
|
||||
|
||||
/* Forward declarations used in this file. */
|
||||
void _rl_free_history_entry __P((HIST_ENTRY *));
|
||||
void _rl_free_history_entry PARAMS((HIST_ENTRY *));
|
||||
|
||||
static char *readline_internal __P((void));
|
||||
static void readline_initialize_everything __P((void));
|
||||
static void start_using_history __P((void));
|
||||
static void bind_arrow_keys __P((void));
|
||||
static int rl_change_case __P((int, int));
|
||||
static char *readline_internal PARAMS((void));
|
||||
static void readline_initialize_everything PARAMS((void));
|
||||
static void start_using_history PARAMS((void));
|
||||
static void bind_arrow_keys PARAMS((void));
|
||||
static int rl_change_case PARAMS((int, int));
|
||||
|
||||
static void readline_default_bindings __P((void));
|
||||
static void readline_default_bindings PARAMS((void));
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
|
|
@ -92,6 +96,8 @@ static void readline_default_bindings __P((void));
|
|||
|
||||
const char *rl_library_version = RL_LIBRARY_VERSION;
|
||||
|
||||
int rl_readline_version = RL_READLINE_VERSION;
|
||||
|
||||
/* True if this is `real' readline as opposed to some stub substitute. */
|
||||
int rl_gnu_readline_p = 1;
|
||||
|
||||
|
|
@ -155,8 +161,11 @@ FILE *_rl_in_stream, *_rl_out_stream;
|
|||
FILE *rl_instream = (FILE *)NULL;
|
||||
FILE *rl_outstream = (FILE *)NULL;
|
||||
|
||||
/* Non-zero means echo characters as they are read. */
|
||||
int readline_echoing_p = 1;
|
||||
/* Non-zero means echo characters as they are read. Defaults to no echo;
|
||||
set to 1 if there is a controlling terminal, we can get its attributes,
|
||||
and the attributes include `echo'. Look at rltty.c:prepare_terminal_settings
|
||||
for the code that sets it. */
|
||||
int readline_echoing_p = 0;
|
||||
|
||||
/* Current prompt. */
|
||||
char *rl_prompt = (char *)NULL;
|
||||
|
|
@ -219,7 +228,7 @@ int rl_num_chars_to_read;
|
|||
char *rl_line_buffer = (char *)NULL;
|
||||
int rl_line_buffer_len = 0;
|
||||
|
||||
/* Forward declarations used by the display and termcap code. */
|
||||
/* Forward declarations used by the display, termcap, and history code. */
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
|
|
@ -240,6 +249,14 @@ int _rl_convert_meta_chars_to_ascii = 1;
|
|||
rather than as a meta-prefixed escape sequence. */
|
||||
int _rl_output_meta_chars = 0;
|
||||
|
||||
/* If non-zero, rl_get_previous_history and rl_get_next_history attempt
|
||||
to preserve the value of rl_point from line to line. */
|
||||
int _rl_history_preserve_point = 0;
|
||||
|
||||
/* Saved target point for when _rl_history_preserve_point is set. Special
|
||||
value of -1 means that point is at the end of the line. */
|
||||
static int _rl_history_saved_point = -1;
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
/* Top Level Functions */
|
||||
|
|
@ -258,9 +275,7 @@ rl_set_prompt (prompt)
|
|||
FREE (rl_prompt);
|
||||
rl_prompt = prompt ? savestring (prompt) : (char *)NULL;
|
||||
|
||||
rl_visible_prompt_length = (rl_prompt && *rl_prompt)
|
||||
? rl_expand_prompt (rl_prompt)
|
||||
: 0;
|
||||
rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -583,6 +598,12 @@ _rl_dispatch (key, map)
|
|||
if (key == ESC)
|
||||
RL_UNSETSTATE(RL_STATE_METANEXT);
|
||||
|
||||
if (newkey < 0)
|
||||
{
|
||||
_rl_abort_internal ();
|
||||
return -1;
|
||||
}
|
||||
|
||||
r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key));
|
||||
}
|
||||
else
|
||||
|
|
@ -714,7 +735,7 @@ readline_initialize_everything ()
|
|||
|
||||
/* Allocate data structures. */
|
||||
if (rl_line_buffer == 0)
|
||||
rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
|
||||
rl_line_buffer = (char *)xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
|
||||
|
||||
/* Initialize the terminal interface. */
|
||||
if (rl_terminal_name == 0)
|
||||
|
|
@ -855,6 +876,12 @@ rl_digit_loop ()
|
|||
key = c = rl_read_key ();
|
||||
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
||||
|
||||
if (c < 0)
|
||||
{
|
||||
_rl_abort_internal ();
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* If we see a key bound to `universal-argument' after seeing digits,
|
||||
it ends the argument but is otherwise ignored. */
|
||||
if (_rl_keymap[c].type == ISFUNC &&
|
||||
|
|
@ -901,8 +928,7 @@ rl_digit_loop ()
|
|||
}
|
||||
}
|
||||
|
||||
RL_UNSETSTATE(RL_STATE_NUMERICARG);
|
||||
return 0;
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
/* Add the current digit to the argument in progress. */
|
||||
|
|
@ -1139,6 +1165,10 @@ rl_backward (count, key)
|
|||
else
|
||||
rl_point -= count;
|
||||
}
|
||||
|
||||
if (rl_point < 0)
|
||||
rl_point = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1344,7 +1374,7 @@ rl_insert (count, c)
|
|||
readline because of extra large arguments. */
|
||||
if (count > 1 && count <= 1024)
|
||||
{
|
||||
string = xmalloc (1 + count);
|
||||
string = (char *)xmalloc (1 + count);
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
string[i] = c;
|
||||
|
|
@ -1431,6 +1461,10 @@ rl_newline (count, key)
|
|||
int count, key;
|
||||
{
|
||||
rl_done = 1;
|
||||
|
||||
if (_rl_history_preserve_point)
|
||||
_rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point;
|
||||
|
||||
RL_SETSTATE(RL_STATE_DONE);
|
||||
|
||||
#if defined (VI_MODE)
|
||||
|
|
@ -1487,10 +1521,10 @@ rl_rubout (count, key)
|
|||
}
|
||||
else
|
||||
{
|
||||
int c = the_line[--rl_point];
|
||||
unsigned char c = the_line[--rl_point];
|
||||
rl_delete_text (rl_point, rl_point + 1);
|
||||
|
||||
if (rl_point == rl_end && isprint (c) && _rl_last_c_pos)
|
||||
if (rl_point == rl_end && ISPRINT (c) && _rl_last_c_pos)
|
||||
{
|
||||
int l;
|
||||
l = rl_character_len (c, rl_point);
|
||||
|
|
@ -1685,7 +1719,8 @@ rl_change_case (count, op)
|
|||
/* */
|
||||
/* **************************************************************** */
|
||||
|
||||
/* Transpose the words at point. */
|
||||
/* Transpose the words at point. If point is at the end of the line,
|
||||
transpose the two words before point. */
|
||||
int
|
||||
rl_transpose_words (count, key)
|
||||
int count, key;
|
||||
|
|
@ -2000,6 +2035,10 @@ rl_get_next_history (count, key)
|
|||
|
||||
rl_maybe_replace_line ();
|
||||
|
||||
/* either not saved by rl_newline or at end of line, so set appropriately. */
|
||||
if (_rl_history_saved_point == -1 && (rl_point || rl_end))
|
||||
_rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point;
|
||||
|
||||
temp = (HIST_ENTRY *)NULL;
|
||||
while (count)
|
||||
{
|
||||
|
|
@ -2020,7 +2059,12 @@ rl_get_next_history (count, key)
|
|||
|
||||
strcpy (the_line, temp->line);
|
||||
rl_undo_list = (UNDO_LIST *)temp->data;
|
||||
rl_end = rl_point = strlen (the_line);
|
||||
rl_end = strlen (the_line);
|
||||
rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1)
|
||||
? _rl_history_saved_point
|
||||
: rl_end;
|
||||
if (rl_point > rl_end)
|
||||
rl_point = rl_end;
|
||||
#if defined (VI_MODE)
|
||||
if (rl_editing_mode == vi_mode)
|
||||
rl_point = 0;
|
||||
|
|
@ -2044,6 +2088,10 @@ rl_get_previous_history (count, key)
|
|||
if (count == 0)
|
||||
return 0;
|
||||
|
||||
/* either not saved by rl_newline or at end of line, so set appropriately. */
|
||||
if (_rl_history_saved_point == -1 && (rl_point || rl_end))
|
||||
_rl_history_saved_point = (rl_point == rl_end) ? -1 : rl_point;
|
||||
|
||||
/* If we don't have a line saved, then save this one. */
|
||||
rl_maybe_save_line ();
|
||||
|
||||
|
|
@ -2077,7 +2125,12 @@ rl_get_previous_history (count, key)
|
|||
|
||||
strcpy (the_line, temp->line);
|
||||
rl_undo_list = (UNDO_LIST *)temp->data;
|
||||
rl_end = rl_point = line_len;
|
||||
rl_end = line_len;
|
||||
rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1)
|
||||
? _rl_history_saved_point
|
||||
: rl_end;
|
||||
if (rl_point > rl_end)
|
||||
rl_point = rl_end;
|
||||
|
||||
#if defined (VI_MODE)
|
||||
if (rl_editing_mode == vi_mode)
|
||||
|
|
|
|||
|
|
@ -37,6 +37,11 @@ extern "C" {
|
|||
# include <readline/tilde.h>
|
||||
#endif
|
||||
|
||||
/* Hex-encoded Readline version number. */
|
||||
#define RL_READLINE_VERSION 0x0402 /* Readline 4.2 */
|
||||
#define RL_VERSION_MAJOR 4
|
||||
#define RL_VERSION_MINOR 2
|
||||
|
||||
/* Readline data structures. */
|
||||
|
||||
/* Maintaining the state of undo. We remember individual deletes and inserts
|
||||
|
|
@ -73,184 +78,184 @@ extern FUNMAP **funmap;
|
|||
/* **************************************************************** */
|
||||
|
||||
/* Bindable commands for numeric arguments. */
|
||||
extern int rl_digit_argument __P((int, int));
|
||||
extern int rl_universal_argument __P((int, int));
|
||||
extern int rl_digit_argument PARAMS((int, int));
|
||||
extern int rl_universal_argument PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for moving the cursor. */
|
||||
extern int rl_forward __P((int, int));
|
||||
extern int rl_backward __P((int, int));
|
||||
extern int rl_beg_of_line __P((int, int));
|
||||
extern int rl_end_of_line __P((int, int));
|
||||
extern int rl_forward_word __P((int, int));
|
||||
extern int rl_backward_word __P((int, int));
|
||||
extern int rl_refresh_line __P((int, int));
|
||||
extern int rl_clear_screen __P((int, int));
|
||||
extern int rl_arrow_keys __P((int, int));
|
||||
extern int rl_forward PARAMS((int, int));
|
||||
extern int rl_backward PARAMS((int, int));
|
||||
extern int rl_beg_of_line PARAMS((int, int));
|
||||
extern int rl_end_of_line PARAMS((int, int));
|
||||
extern int rl_forward_word PARAMS((int, int));
|
||||
extern int rl_backward_word PARAMS((int, int));
|
||||
extern int rl_refresh_line PARAMS((int, int));
|
||||
extern int rl_clear_screen PARAMS((int, int));
|
||||
extern int rl_arrow_keys PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for inserting and deleting text. */
|
||||
extern int rl_insert __P((int, int));
|
||||
extern int rl_quoted_insert __P((int, int));
|
||||
extern int rl_tab_insert __P((int, int));
|
||||
extern int rl_newline __P((int, int));
|
||||
extern int rl_do_lowercase_version __P((int, int));
|
||||
extern int rl_rubout __P((int, int));
|
||||
extern int rl_delete __P((int, int));
|
||||
extern int rl_rubout_or_delete __P((int, int));
|
||||
extern int rl_delete_horizontal_space __P((int, int));
|
||||
extern int rl_delete_or_show_completions __P((int, int));
|
||||
extern int rl_insert_comment __P((int, int));
|
||||
extern int rl_insert PARAMS((int, int));
|
||||
extern int rl_quoted_insert PARAMS((int, int));
|
||||
extern int rl_tab_insert PARAMS((int, int));
|
||||
extern int rl_newline PARAMS((int, int));
|
||||
extern int rl_do_lowercase_version PARAMS((int, int));
|
||||
extern int rl_rubout PARAMS((int, int));
|
||||
extern int rl_delete PARAMS((int, int));
|
||||
extern int rl_rubout_or_delete PARAMS((int, int));
|
||||
extern int rl_delete_horizontal_space PARAMS((int, int));
|
||||
extern int rl_delete_or_show_completions PARAMS((int, int));
|
||||
extern int rl_insert_comment PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for changing case. */
|
||||
extern int rl_upcase_word __P((int, int));
|
||||
extern int rl_downcase_word __P((int, int));
|
||||
extern int rl_capitalize_word __P((int, int));
|
||||
extern int rl_upcase_word PARAMS((int, int));
|
||||
extern int rl_downcase_word PARAMS((int, int));
|
||||
extern int rl_capitalize_word PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for transposing characters and words. */
|
||||
extern int rl_transpose_words __P((int, int));
|
||||
extern int rl_transpose_chars __P((int, int));
|
||||
extern int rl_transpose_words PARAMS((int, int));
|
||||
extern int rl_transpose_chars PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for searching within a line. */
|
||||
extern int rl_char_search __P((int, int));
|
||||
extern int rl_backward_char_search __P((int, int));
|
||||
extern int rl_char_search PARAMS((int, int));
|
||||
extern int rl_backward_char_search PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for readline's interface to the command history. */
|
||||
extern int rl_beginning_of_history __P((int, int));
|
||||
extern int rl_end_of_history __P((int, int));
|
||||
extern int rl_get_next_history __P((int, int));
|
||||
extern int rl_get_previous_history __P((int, int));
|
||||
extern int rl_beginning_of_history PARAMS((int, int));
|
||||
extern int rl_end_of_history PARAMS((int, int));
|
||||
extern int rl_get_next_history PARAMS((int, int));
|
||||
extern int rl_get_previous_history PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for managing the mark and region. */
|
||||
extern int rl_set_mark __P((int, int));
|
||||
extern int rl_exchange_point_and_mark __P((int, int));
|
||||
extern int rl_set_mark PARAMS((int, int));
|
||||
extern int rl_exchange_point_and_mark PARAMS((int, int));
|
||||
|
||||
/* Bindable commands to set the editing mode (emacs or vi). */
|
||||
extern int rl_vi_editing_mode __P((int, int));
|
||||
extern int rl_emacs_editing_mode __P((int, int));
|
||||
extern int rl_vi_editing_mode PARAMS((int, int));
|
||||
extern int rl_emacs_editing_mode PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for managing key bindings. */
|
||||
extern int rl_re_read_init_file __P((int, int));
|
||||
extern int rl_dump_functions __P((int, int));
|
||||
extern int rl_dump_macros __P((int, int));
|
||||
extern int rl_dump_variables __P((int, int));
|
||||
extern int rl_re_read_init_file PARAMS((int, int));
|
||||
extern int rl_dump_functions PARAMS((int, int));
|
||||
extern int rl_dump_macros PARAMS((int, int));
|
||||
extern int rl_dump_variables PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for word completion. */
|
||||
extern int rl_complete __P((int, int));
|
||||
extern int rl_possible_completions __P((int, int));
|
||||
extern int rl_insert_completions __P((int, int));
|
||||
extern int rl_menu_complete __P((int, int));
|
||||
extern int rl_complete PARAMS((int, int));
|
||||
extern int rl_possible_completions PARAMS((int, int));
|
||||
extern int rl_insert_completions PARAMS((int, int));
|
||||
extern int rl_menu_complete PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for killing and yanking text, and managing the kill ring. */
|
||||
extern int rl_kill_word __P((int, int));
|
||||
extern int rl_backward_kill_word __P((int, int));
|
||||
extern int rl_kill_line __P((int, int));
|
||||
extern int rl_backward_kill_line __P((int, int));
|
||||
extern int rl_kill_full_line __P((int, int));
|
||||
extern int rl_unix_word_rubout __P((int, int));
|
||||
extern int rl_unix_line_discard __P((int, int));
|
||||
extern int rl_copy_region_to_kill __P((int, int));
|
||||
extern int rl_kill_region __P((int, int));
|
||||
extern int rl_copy_forward_word __P((int, int));
|
||||
extern int rl_copy_backward_word __P((int, int));
|
||||
extern int rl_yank __P((int, int));
|
||||
extern int rl_yank_pop __P((int, int));
|
||||
extern int rl_yank_nth_arg __P((int, int));
|
||||
extern int rl_yank_last_arg __P((int, int));
|
||||
extern int rl_kill_word PARAMS((int, int));
|
||||
extern int rl_backward_kill_word PARAMS((int, int));
|
||||
extern int rl_kill_line PARAMS((int, int));
|
||||
extern int rl_backward_kill_line PARAMS((int, int));
|
||||
extern int rl_kill_full_line PARAMS((int, int));
|
||||
extern int rl_unix_word_rubout PARAMS((int, int));
|
||||
extern int rl_unix_line_discard PARAMS((int, int));
|
||||
extern int rl_copy_region_to_kill PARAMS((int, int));
|
||||
extern int rl_kill_region PARAMS((int, int));
|
||||
extern int rl_copy_forward_word PARAMS((int, int));
|
||||
extern int rl_copy_backward_word PARAMS((int, int));
|
||||
extern int rl_yank PARAMS((int, int));
|
||||
extern int rl_yank_pop PARAMS((int, int));
|
||||
extern int rl_yank_nth_arg PARAMS((int, int));
|
||||
extern int rl_yank_last_arg PARAMS((int, int));
|
||||
/* Not available unless __CYGWIN__ is defined. */
|
||||
#ifdef __CYGWIN__
|
||||
extern int rl_paste_from_clipboard __P((int, int));
|
||||
extern int rl_paste_from_clipboard PARAMS((int, int));
|
||||
#endif
|
||||
|
||||
/* Bindable commands for incremental searching. */
|
||||
extern int rl_reverse_search_history __P((int, int));
|
||||
extern int rl_forward_search_history __P((int, int));
|
||||
extern int rl_reverse_search_history PARAMS((int, int));
|
||||
extern int rl_forward_search_history PARAMS((int, int));
|
||||
|
||||
/* Bindable keyboard macro commands. */
|
||||
extern int rl_start_kbd_macro __P((int, int));
|
||||
extern int rl_end_kbd_macro __P((int, int));
|
||||
extern int rl_call_last_kbd_macro __P((int, int));
|
||||
extern int rl_start_kbd_macro PARAMS((int, int));
|
||||
extern int rl_end_kbd_macro PARAMS((int, int));
|
||||
extern int rl_call_last_kbd_macro PARAMS((int, int));
|
||||
|
||||
/* Bindable undo commands. */
|
||||
extern int rl_revert_line __P((int, int));
|
||||
extern int rl_undo_command __P((int, int));
|
||||
extern int rl_revert_line PARAMS((int, int));
|
||||
extern int rl_undo_command PARAMS((int, int));
|
||||
|
||||
/* Bindable tilde expansion commands. */
|
||||
extern int rl_tilde_expand __P((int, int));
|
||||
extern int rl_tilde_expand PARAMS((int, int));
|
||||
|
||||
/* Bindable terminal control commands. */
|
||||
extern int rl_restart_output __P((int, int));
|
||||
extern int rl_stop_output __P((int, int));
|
||||
extern int rl_restart_output PARAMS((int, int));
|
||||
extern int rl_stop_output PARAMS((int, int));
|
||||
|
||||
/* Miscellaneous bindable commands. */
|
||||
extern int rl_abort __P((int, int));
|
||||
extern int rl_tty_status __P((int, int));
|
||||
extern int rl_abort PARAMS((int, int));
|
||||
extern int rl_tty_status PARAMS((int, int));
|
||||
|
||||
/* Bindable commands for incremental and non-incremental history searching. */
|
||||
extern int rl_history_search_forward __P((int, int));
|
||||
extern int rl_history_search_backward __P((int, int));
|
||||
extern int rl_noninc_forward_search __P((int, int));
|
||||
extern int rl_noninc_reverse_search __P((int, int));
|
||||
extern int rl_noninc_forward_search_again __P((int, int));
|
||||
extern int rl_noninc_reverse_search_again __P((int, int));
|
||||
extern int rl_history_search_forward PARAMS((int, int));
|
||||
extern int rl_history_search_backward PARAMS((int, int));
|
||||
extern int rl_noninc_forward_search PARAMS((int, int));
|
||||
extern int rl_noninc_reverse_search PARAMS((int, int));
|
||||
extern int rl_noninc_forward_search_again PARAMS((int, int));
|
||||
extern int rl_noninc_reverse_search_again PARAMS((int, int));
|
||||
|
||||
/* Bindable command used when inserting a matching close character. */
|
||||
extern int rl_insert_close __P((int, int));
|
||||
extern int rl_insert_close PARAMS((int, int));
|
||||
|
||||
/* Not available unless READLINE_CALLBACKS is defined. */
|
||||
extern void rl_callback_handler_install __P((const char *, rl_vcpfunc_t *));
|
||||
extern void rl_callback_read_char __P((void));
|
||||
extern void rl_callback_handler_remove __P((void));
|
||||
extern void rl_callback_handler_install PARAMS((const char *, rl_vcpfunc_t *));
|
||||
extern void rl_callback_read_char PARAMS((void));
|
||||
extern void rl_callback_handler_remove PARAMS((void));
|
||||
|
||||
/* Things for vi mode. Not available unless readline is compiled -DVI_MODE. */
|
||||
/* VI-mode bindable commands. */
|
||||
extern int rl_vi_redo __P((int, int));
|
||||
extern int rl_vi_undo __P((int, int));
|
||||
extern int rl_vi_yank_arg __P((int, int));
|
||||
extern int rl_vi_fetch_history __P((int, int));
|
||||
extern int rl_vi_search_again __P((int, int));
|
||||
extern int rl_vi_search __P((int, int));
|
||||
extern int rl_vi_complete __P((int, int));
|
||||
extern int rl_vi_tilde_expand __P((int, int));
|
||||
extern int rl_vi_prev_word __P((int, int));
|
||||
extern int rl_vi_next_word __P((int, int));
|
||||
extern int rl_vi_end_word __P((int, int));
|
||||
extern int rl_vi_insert_beg __P((int, int));
|
||||
extern int rl_vi_append_mode __P((int, int));
|
||||
extern int rl_vi_append_eol __P((int, int));
|
||||
extern int rl_vi_eof_maybe __P((int, int));
|
||||
extern int rl_vi_insertion_mode __P((int, int));
|
||||
extern int rl_vi_movement_mode __P((int, int));
|
||||
extern int rl_vi_arg_digit __P((int, int));
|
||||
extern int rl_vi_change_case __P((int, int));
|
||||
extern int rl_vi_put __P((int, int));
|
||||
extern int rl_vi_column __P((int, int));
|
||||
extern int rl_vi_delete_to __P((int, int));
|
||||
extern int rl_vi_change_to __P((int, int));
|
||||
extern int rl_vi_yank_to __P((int, int));
|
||||
extern int rl_vi_delete __P((int, int));
|
||||
extern int rl_vi_back_to_indent __P((int, int));
|
||||
extern int rl_vi_first_print __P((int, int));
|
||||
extern int rl_vi_char_search __P((int, int));
|
||||
extern int rl_vi_match __P((int, int));
|
||||
extern int rl_vi_change_char __P((int, int));
|
||||
extern int rl_vi_subst __P((int, int));
|
||||
extern int rl_vi_overstrike __P((int, int));
|
||||
extern int rl_vi_overstrike_delete __P((int, int));
|
||||
extern int rl_vi_replace __P((int, int));
|
||||
extern int rl_vi_set_mark __P((int, int));
|
||||
extern int rl_vi_goto_mark __P((int, int));
|
||||
extern int rl_vi_redo PARAMS((int, int));
|
||||
extern int rl_vi_undo PARAMS((int, int));
|
||||
extern int rl_vi_yank_arg PARAMS((int, int));
|
||||
extern int rl_vi_fetch_history PARAMS((int, int));
|
||||
extern int rl_vi_search_again PARAMS((int, int));
|
||||
extern int rl_vi_search PARAMS((int, int));
|
||||
extern int rl_vi_complete PARAMS((int, int));
|
||||
extern int rl_vi_tilde_expand PARAMS((int, int));
|
||||
extern int rl_vi_prev_word PARAMS((int, int));
|
||||
extern int rl_vi_next_word PARAMS((int, int));
|
||||
extern int rl_vi_end_word PARAMS((int, int));
|
||||
extern int rl_vi_insert_beg PARAMS((int, int));
|
||||
extern int rl_vi_append_mode PARAMS((int, int));
|
||||
extern int rl_vi_append_eol PARAMS((int, int));
|
||||
extern int rl_vi_eof_maybe PARAMS((int, int));
|
||||
extern int rl_vi_insertion_mode PARAMS((int, int));
|
||||
extern int rl_vi_movement_mode PARAMS((int, int));
|
||||
extern int rl_vi_arg_digit PARAMS((int, int));
|
||||
extern int rl_vi_change_case PARAMS((int, int));
|
||||
extern int rl_vi_put PARAMS((int, int));
|
||||
extern int rl_vi_column PARAMS((int, int));
|
||||
extern int rl_vi_delete_to PARAMS((int, int));
|
||||
extern int rl_vi_change_to PARAMS((int, int));
|
||||
extern int rl_vi_yank_to PARAMS((int, int));
|
||||
extern int rl_vi_delete PARAMS((int, int));
|
||||
extern int rl_vi_back_to_indent PARAMS((int, int));
|
||||
extern int rl_vi_first_print PARAMS((int, int));
|
||||
extern int rl_vi_char_search PARAMS((int, int));
|
||||
extern int rl_vi_match PARAMS((int, int));
|
||||
extern int rl_vi_change_char PARAMS((int, int));
|
||||
extern int rl_vi_subst PARAMS((int, int));
|
||||
extern int rl_vi_overstrike PARAMS((int, int));
|
||||
extern int rl_vi_overstrike_delete PARAMS((int, int));
|
||||
extern int rl_vi_replace PARAMS((int, int));
|
||||
extern int rl_vi_set_mark PARAMS((int, int));
|
||||
extern int rl_vi_goto_mark PARAMS((int, int));
|
||||
|
||||
/* VI-mode utility functions. */
|
||||
extern int rl_vi_check __P((void));
|
||||
extern int rl_vi_domove __P((int, int *));
|
||||
extern int rl_vi_bracktype __P((int));
|
||||
extern int rl_vi_check PARAMS((void));
|
||||
extern int rl_vi_domove PARAMS((int, int *));
|
||||
extern int rl_vi_bracktype PARAMS((int));
|
||||
|
||||
/* VI-mode pseudo-bindable commands, used as utility functions. */
|
||||
extern int rl_vi_fWord __P((int, int));
|
||||
extern int rl_vi_bWord __P((int, int));
|
||||
extern int rl_vi_eWord __P((int, int));
|
||||
extern int rl_vi_fword __P((int, int));
|
||||
extern int rl_vi_bword __P((int, int));
|
||||
extern int rl_vi_eword __P((int, int));
|
||||
extern int rl_vi_fWord PARAMS((int, int));
|
||||
extern int rl_vi_bWord PARAMS((int, int));
|
||||
extern int rl_vi_eWord PARAMS((int, int));
|
||||
extern int rl_vi_fword PARAMS((int, int));
|
||||
extern int rl_vi_bword PARAMS((int, int));
|
||||
extern int rl_vi_eword PARAMS((int, int));
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
|
|
@ -260,171 +265,172 @@ extern int rl_vi_eword __P((int, int));
|
|||
|
||||
/* Readline functions. */
|
||||
/* Read a line of input. Prompt with PROMPT. A NULL PROMPT means none. */
|
||||
extern char *readline __P((const char *));
|
||||
extern char *readline PARAMS((const char *));
|
||||
|
||||
extern int rl_set_prompt __P((const char *));
|
||||
extern int rl_expand_prompt __P((char *));
|
||||
extern int rl_set_prompt PARAMS((const char *));
|
||||
extern int rl_expand_prompt PARAMS((char *));
|
||||
|
||||
extern int rl_initialize __P((void));
|
||||
extern int rl_initialize PARAMS((void));
|
||||
|
||||
/* Undocumented; unused by readline */
|
||||
extern int rl_discard_argument __P((void));
|
||||
extern int rl_discard_argument PARAMS((void));
|
||||
|
||||
/* Utility functions to bind keys to readline commands. */
|
||||
extern int rl_add_defun __P((const char *, rl_command_func_t *, int));
|
||||
extern int rl_bind_key __P((int, rl_command_func_t *));
|
||||
extern int rl_bind_key_in_map __P((int, rl_command_func_t *, Keymap));
|
||||
extern int rl_unbind_key __P((int));
|
||||
extern int rl_unbind_key_in_map __P((int, Keymap));
|
||||
extern int rl_unbind_function_in_map __P((rl_command_func_t *, Keymap));
|
||||
extern int rl_unbind_command_in_map __P((const char *, Keymap));
|
||||
extern int rl_set_key __P((const char *, rl_command_func_t *, Keymap));
|
||||
extern int rl_generic_bind __P((int, const char *, char *, Keymap));
|
||||
extern int rl_variable_bind __P((const char *, const char *));
|
||||
extern int rl_add_defun PARAMS((const char *, rl_command_func_t *, int));
|
||||
extern int rl_bind_key PARAMS((int, rl_command_func_t *));
|
||||
extern int rl_bind_key_in_map PARAMS((int, rl_command_func_t *, Keymap));
|
||||
extern int rl_unbind_key PARAMS((int));
|
||||
extern int rl_unbind_key_in_map PARAMS((int, Keymap));
|
||||
extern int rl_unbind_function_in_map PARAMS((rl_command_func_t *, Keymap));
|
||||
extern int rl_unbind_command_in_map PARAMS((const char *, Keymap));
|
||||
extern int rl_set_key PARAMS((const char *, rl_command_func_t *, Keymap));
|
||||
extern int rl_generic_bind PARAMS((int, const char *, char *, Keymap));
|
||||
extern int rl_variable_bind PARAMS((const char *, const char *));
|
||||
|
||||
/* Backwards compatibility, use rl_generic_bind instead. */
|
||||
extern int rl_macro_bind __P((const char *, const char *, Keymap));
|
||||
extern int rl_macro_bind PARAMS((const char *, const char *, Keymap));
|
||||
|
||||
/* Undocumented in the texinfo manual; not really useful to programs. */
|
||||
extern int rl_translate_keyseq __P((const char *, char *, int *));
|
||||
extern char *rl_untranslate_keyseq __P((int));
|
||||
extern int rl_translate_keyseq PARAMS((const char *, char *, int *));
|
||||
extern char *rl_untranslate_keyseq PARAMS((int));
|
||||
|
||||
extern rl_command_func_t *rl_named_function __P((const char *));
|
||||
extern rl_command_func_t *rl_function_of_keyseq __P((const char *, Keymap, int *));
|
||||
extern rl_command_func_t *rl_named_function PARAMS((const char *));
|
||||
extern rl_command_func_t *rl_function_of_keyseq PARAMS((const char *, Keymap, int *));
|
||||
|
||||
extern void rl_list_funmap_names __P((void));
|
||||
extern char **rl_invoking_keyseqs_in_map __P((rl_command_func_t *, Keymap));
|
||||
extern char **rl_invoking_keyseqs __P((rl_command_func_t *));
|
||||
extern void rl_list_funmap_names PARAMS((void));
|
||||
extern char **rl_invoking_keyseqs_in_map PARAMS((rl_command_func_t *, Keymap));
|
||||
extern char **rl_invoking_keyseqs PARAMS((rl_command_func_t *));
|
||||
|
||||
extern void rl_function_dumper __P((int));
|
||||
extern void rl_macro_dumper __P((int));
|
||||
extern void rl_variable_dumper __P((int));
|
||||
extern void rl_function_dumper PARAMS((int));
|
||||
extern void rl_macro_dumper PARAMS((int));
|
||||
extern void rl_variable_dumper PARAMS((int));
|
||||
|
||||
extern int rl_read_init_file __P((const char *));
|
||||
extern int rl_parse_and_bind __P((char *));
|
||||
extern int rl_read_init_file PARAMS((const char *));
|
||||
extern int rl_parse_and_bind PARAMS((char *));
|
||||
|
||||
/* Functions for manipulating keymaps. */
|
||||
extern Keymap rl_make_bare_keymap __P((void));
|
||||
extern Keymap rl_copy_keymap __P((Keymap));
|
||||
extern Keymap rl_make_keymap __P((void));
|
||||
extern void rl_discard_keymap __P((Keymap));
|
||||
extern Keymap rl_make_bare_keymap PARAMS((void));
|
||||
extern Keymap rl_copy_keymap PARAMS((Keymap));
|
||||
extern Keymap rl_make_keymap PARAMS((void));
|
||||
extern void rl_discard_keymap PARAMS((Keymap));
|
||||
|
||||
extern Keymap rl_get_keymap_by_name __P((const char *));
|
||||
extern char *rl_get_keymap_name __P((Keymap));
|
||||
extern void rl_set_keymap __P((Keymap));
|
||||
extern Keymap rl_get_keymap __P((void));
|
||||
extern Keymap rl_get_keymap_by_name PARAMS((const char *));
|
||||
extern char *rl_get_keymap_name PARAMS((Keymap));
|
||||
extern void rl_set_keymap PARAMS((Keymap));
|
||||
extern Keymap rl_get_keymap PARAMS((void));
|
||||
/* Undocumented; used internally only. */
|
||||
extern void rl_set_keymap_from_edit_mode __P((void));
|
||||
extern char *rl_get_keymap_name_from_edit_mode __P((void));
|
||||
extern void rl_set_keymap_from_edit_mode PARAMS((void));
|
||||
extern char *rl_get_keymap_name_from_edit_mode PARAMS((void));
|
||||
|
||||
/* Functions for manipulating the funmap, which maps command names to functions. */
|
||||
extern int rl_add_funmap_entry __P((const char *, rl_command_func_t *));
|
||||
extern const char **rl_funmap_names __P((void));
|
||||
extern int rl_add_funmap_entry PARAMS((const char *, rl_command_func_t *));
|
||||
extern const char **rl_funmap_names PARAMS((void));
|
||||
/* Undocumented, only used internally -- there is only one funmap, and this
|
||||
function may be called only once. */
|
||||
extern void rl_initialize_funmap __P((void));
|
||||
extern void rl_initialize_funmap PARAMS((void));
|
||||
|
||||
/* Utility functions for managing keyboard macros. */
|
||||
extern void rl_push_macro_input __P((char *));
|
||||
extern void rl_push_macro_input PARAMS((char *));
|
||||
|
||||
/* Functions for undoing, from undo.c */
|
||||
extern void rl_add_undo __P((enum undo_code, int, int, char *));
|
||||
extern void rl_free_undo_list __P((void));
|
||||
extern int rl_do_undo __P((void));
|
||||
extern int rl_begin_undo_group __P((void));
|
||||
extern int rl_end_undo_group __P((void));
|
||||
extern int rl_modifying __P((int, int));
|
||||
extern void rl_add_undo PARAMS((enum undo_code, int, int, char *));
|
||||
extern void rl_free_undo_list PARAMS((void));
|
||||
extern int rl_do_undo PARAMS((void));
|
||||
extern int rl_begin_undo_group PARAMS((void));
|
||||
extern int rl_end_undo_group PARAMS((void));
|
||||
extern int rl_modifying PARAMS((int, int));
|
||||
|
||||
/* Functions for redisplay. */
|
||||
extern void rl_redisplay __P((void));
|
||||
extern int rl_on_new_line __P((void));
|
||||
extern int rl_on_new_line_with_prompt __P((void));
|
||||
extern int rl_forced_update_display __P((void));
|
||||
extern int rl_clear_message __P((void));
|
||||
extern int rl_reset_line_state __P((void));
|
||||
extern int rl_crlf __P((void));
|
||||
extern void rl_redisplay PARAMS((void));
|
||||
extern int rl_on_new_line PARAMS((void));
|
||||
extern int rl_on_new_line_with_prompt PARAMS((void));
|
||||
extern int rl_forced_update_display PARAMS((void));
|
||||
extern int rl_clear_message PARAMS((void));
|
||||
extern int rl_reset_line_state PARAMS((void));
|
||||
extern int rl_crlf PARAMS((void));
|
||||
|
||||
#if (defined (__STDC__) || defined (__cplusplus)) && defined (USE_VARARGS) && defined (PREFER_STDARG)
|
||||
extern int rl_message (const char *, ...);
|
||||
extern int rl_message (const char *, ...) __attribute__((__format__ (printf, 1, 2)));
|
||||
#else
|
||||
extern int rl_message ();
|
||||
#endif
|
||||
|
||||
extern int rl_show_char __P((int));
|
||||
extern int rl_show_char PARAMS((int));
|
||||
|
||||
/* Undocumented in texinfo manual. */
|
||||
extern int rl_character_len __P((int, int));
|
||||
extern int rl_character_len PARAMS((int, int));
|
||||
|
||||
/* Save and restore internal prompt redisplay information. */
|
||||
extern void rl_save_prompt __P((void));
|
||||
extern void rl_restore_prompt __P((void));
|
||||
extern void rl_save_prompt PARAMS((void));
|
||||
extern void rl_restore_prompt PARAMS((void));
|
||||
|
||||
/* Modifying text. */
|
||||
extern int rl_insert_text __P((const char *));
|
||||
extern int rl_delete_text __P((int, int));
|
||||
extern int rl_kill_text __P((int, int));
|
||||
extern char *rl_copy_text __P((int, int));
|
||||
extern int rl_insert_text PARAMS((const char *));
|
||||
extern int rl_delete_text PARAMS((int, int));
|
||||
extern int rl_kill_text PARAMS((int, int));
|
||||
extern char *rl_copy_text PARAMS((int, int));
|
||||
|
||||
/* Terminal and tty mode management. */
|
||||
extern void rl_prep_terminal __P((int));
|
||||
extern void rl_deprep_terminal __P((void));
|
||||
extern void rl_tty_set_default_bindings __P((Keymap));
|
||||
extern void rl_prep_terminal PARAMS((int));
|
||||
extern void rl_deprep_terminal PARAMS((void));
|
||||
extern void rl_tty_set_default_bindings PARAMS((Keymap));
|
||||
|
||||
extern int rl_reset_terminal __P((const char *));
|
||||
extern void rl_resize_terminal __P((void));
|
||||
extern void rl_set_screen_size __P((int, int));
|
||||
extern void rl_get_screen_size __P((int *, int *));
|
||||
extern int rl_reset_terminal PARAMS((const char *));
|
||||
extern void rl_resize_terminal PARAMS((void));
|
||||
extern void rl_set_screen_size PARAMS((int, int));
|
||||
extern void rl_get_screen_size PARAMS((int *, int *));
|
||||
|
||||
extern char *rl_get_termcap PARAMS((const char *));
|
||||
|
||||
/* Functions for character input. */
|
||||
extern int rl_stuff_char __P((int));
|
||||
extern int rl_execute_next __P((int));
|
||||
extern int rl_clear_pending_input __P((void));
|
||||
extern int rl_read_key __P((void));
|
||||
extern int rl_getc __P((FILE *));
|
||||
extern int rl_set_keyboard_input_timeout __P((int));
|
||||
extern int rl_stuff_char PARAMS((int));
|
||||
extern int rl_execute_next PARAMS((int));
|
||||
extern int rl_clear_pending_input PARAMS((void));
|
||||
extern int rl_read_key PARAMS((void));
|
||||
extern int rl_getc PARAMS((FILE *));
|
||||
extern int rl_set_keyboard_input_timeout PARAMS((int));
|
||||
|
||||
/* `Public' utility functions . */
|
||||
extern void rl_extend_line_buffer __P((int));
|
||||
extern int rl_ding __P((void));
|
||||
extern int rl_alphabetic __P((int));
|
||||
extern void rl_extend_line_buffer PARAMS((int));
|
||||
extern int rl_ding PARAMS((void));
|
||||
extern int rl_alphabetic PARAMS((int));
|
||||
|
||||
/* Readline signal handling, from signals.c */
|
||||
extern int rl_set_signals __P((void));
|
||||
extern int rl_clear_signals __P((void));
|
||||
extern void rl_cleanup_after_signal __P((void));
|
||||
extern void rl_reset_after_signal __P((void));
|
||||
extern void rl_free_line_state __P((void));
|
||||
extern int rl_set_signals PARAMS((void));
|
||||
extern int rl_clear_signals PARAMS((void));
|
||||
extern void rl_cleanup_after_signal PARAMS((void));
|
||||
extern void rl_reset_after_signal PARAMS((void));
|
||||
extern void rl_free_line_state PARAMS((void));
|
||||
|
||||
/* Undocumented. */
|
||||
extern int rl_set_paren_blink_timeout __P((int));
|
||||
extern int rl_set_paren_blink_timeout PARAMS((int));
|
||||
|
||||
/* Undocumented. */
|
||||
extern int rl_maybe_save_line __P((void));
|
||||
extern int rl_maybe_unsave_line __P((void));
|
||||
extern int rl_maybe_replace_line __P((void));
|
||||
extern int rl_maybe_save_line PARAMS((void));
|
||||
extern int rl_maybe_unsave_line PARAMS((void));
|
||||
extern int rl_maybe_replace_line PARAMS((void));
|
||||
|
||||
/* Completion functions. */
|
||||
extern int rl_complete_internal __P((int));
|
||||
extern void rl_display_match_list __P((char **, int, int));
|
||||
extern int rl_complete_internal PARAMS((int));
|
||||
extern void rl_display_match_list PARAMS((char **, int, int));
|
||||
|
||||
extern char **rl_completion_matches __P((const char *, rl_compentry_func_t *));
|
||||
extern char *rl_username_completion_function __P((const char *, int));
|
||||
extern char *rl_filename_completion_function __P((const char *, int));
|
||||
extern char **rl_completion_matches PARAMS((const char *, rl_compentry_func_t *));
|
||||
extern char *rl_username_completion_function PARAMS((const char *, int));
|
||||
extern char *rl_filename_completion_function PARAMS((const char *, int));
|
||||
|
||||
#if 0
|
||||
/* Backwards compatibility (compat.c). These will go away sometime. */
|
||||
extern void free_undo_list __P((void));
|
||||
extern int maybe_save_line __P((void));
|
||||
extern int maybe_unsave_line __P((void));
|
||||
extern int maybe_replace_line __P((void));
|
||||
extern void free_undo_list PARAMS((void));
|
||||
extern int maybe_save_line PARAMS((void));
|
||||
extern int maybe_unsave_line PARAMS((void));
|
||||
extern int maybe_replace_line PARAMS((void));
|
||||
|
||||
extern int ding __P((void));
|
||||
extern int alphabetic __P((int));
|
||||
extern int crlf __P((void));
|
||||
extern int ding PARAMS((void));
|
||||
extern int alphabetic PARAMS((int));
|
||||
extern int crlf PARAMS((void));
|
||||
|
||||
extern char **completion_matches __P((char *, rl_compentry_func_t *));
|
||||
extern char *username_completion_function __P((const char *, int));
|
||||
extern char *filename_completion_function __P((const char *, int));
|
||||
extern char **completion_matches PARAMS((char *, rl_compentry_func_t *));
|
||||
extern char *username_completion_function PARAMS((const char *, int));
|
||||
extern char *filename_completion_function PARAMS((const char *, int));
|
||||
#endif
|
||||
|
||||
/* **************************************************************** */
|
||||
|
|
@ -434,7 +440,8 @@ extern char *filename_completion_function __P((const char *, int));
|
|||
/* **************************************************************** */
|
||||
|
||||
/* The version of this incarnation of the readline library. */
|
||||
extern const char *rl_library_version;
|
||||
extern const char *rl_library_version; /* e.g., "4.2" */
|
||||
extern int rl_readline_version; /* e.g., 0x0402 */
|
||||
|
||||
/* True if this is real GNU readline. */
|
||||
extern int rl_gnu_readline_p;
|
||||
|
|
@ -551,8 +558,8 @@ extern int rl_catch_sigwinch;
|
|||
|
||||
/* Completion variables. */
|
||||
/* Pointer to the generator function for completion_matches ().
|
||||
NULL means to use filename_entry_function (), the default filename
|
||||
completer. */
|
||||
NULL means to use rl_filename_completion_function (), the default
|
||||
filename completer. */
|
||||
extern rl_compentry_func_t *rl_completion_entry_function;
|
||||
|
||||
/* If rl_ignore_some_completions_function is non-NULL it is the address
|
||||
|
|
|
|||
|
|
@ -73,8 +73,14 @@ extern char *strchr (), *strrchr ();
|
|||
#define _rl_stricmp strcasecmp
|
||||
#define _rl_strnicmp strncasecmp
|
||||
#else
|
||||
extern int _rl_stricmp __P((char *, char *);
|
||||
extern int _rl_strnicmp __P((char *, char *));
|
||||
extern int _rl_stricmp PARAMS((char *, char *));
|
||||
extern int _rl_strnicmp PARAMS((char *, char *));
|
||||
#endif
|
||||
|
||||
#if defined (HAVE_STRPBRK)
|
||||
# define _rl_strpbrk(a,b) strpbrk((a),(b))
|
||||
#else
|
||||
extern char *_rl_strpbrk PARAMS((const char *, const char *));
|
||||
#endif
|
||||
|
||||
#if !defined (emacs_mode)
|
||||
|
|
@ -97,8 +103,7 @@ extern int _rl_strnicmp __P((char *, char *));
|
|||
#endif
|
||||
|
||||
#ifndef savestring
|
||||
extern char *xmalloc __P((int));
|
||||
#define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x))
|
||||
#define savestring(x) strcpy ((char *)xmalloc (1 + strlen (x)), (x))
|
||||
#endif
|
||||
|
||||
/* Possible values for _rl_bell_preference. */
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@
|
|||
|
||||
#include "rlconf.h" /* for VISIBLE_STATS */
|
||||
#include "rlstdc.h"
|
||||
#include "posixjmp.h" /* defines procenv_t */
|
||||
#include "posixjmp.h" /* defines procenv_t */
|
||||
|
||||
/*************************************************************************
|
||||
* *
|
||||
|
|
@ -34,9 +34,6 @@
|
|||
* *
|
||||
*************************************************************************/
|
||||
|
||||
/* terminal.c */
|
||||
extern char *rl_get_termcap __P((const char *));
|
||||
|
||||
/*************************************************************************
|
||||
* *
|
||||
* Global variables undocumented in texinfo manual and not in readline.h *
|
||||
|
|
@ -69,25 +66,25 @@ extern int rl_blink_matching_paren;
|
|||
*************************************************************************/
|
||||
|
||||
/* bind.c */
|
||||
extern char *rl_untranslate_keyseq __P((int));
|
||||
extern char *rl_untranslate_keyseq PARAMS((int));
|
||||
|
||||
/* kill.c */
|
||||
extern int rl_set_retained_kills __P((int));
|
||||
extern int rl_set_retained_kills PARAMS((int));
|
||||
|
||||
/* readline.c */
|
||||
extern int rl_discard_argument __P((void));
|
||||
extern int rl_discard_argument PARAMS((void));
|
||||
|
||||
/* rltty.c */
|
||||
extern int rl_stop_output __P((int, int));
|
||||
extern int rl_stop_output PARAMS((int, int));
|
||||
|
||||
/* terminal.c */
|
||||
extern void _rl_set_screen_size __P((int, int));
|
||||
extern void _rl_set_screen_size PARAMS((int, int));
|
||||
|
||||
/* undo.c */
|
||||
extern int _rl_fix_last_undo_of_type __P((int, int, int));
|
||||
extern int _rl_fix_last_undo_of_type PARAMS((int, int, int));
|
||||
|
||||
/* util.c */
|
||||
extern char *_rl_savestring __P((const char *));
|
||||
extern char *_rl_savestring PARAMS((const char *));
|
||||
|
||||
/*************************************************************************
|
||||
* *
|
||||
|
|
@ -107,98 +104,97 @@ extern char *_rl_savestring __P((const char *));
|
|||
#if defined(READLINE_CALLBACKS)
|
||||
|
||||
/* readline.c */
|
||||
extern void readline_internal_setup __P((void));
|
||||
extern char *readline_internal_teardown __P((int));
|
||||
extern int readline_internal_char __P((void));
|
||||
extern void readline_internal_setup PARAMS((void));
|
||||
extern char *readline_internal_teardown PARAMS((int));
|
||||
extern int readline_internal_char PARAMS((void));
|
||||
|
||||
#endif /* READLINE_CALLBACKS */
|
||||
|
||||
/* bind.c */
|
||||
extern void _rl_bind_if_unbound __P((const char *, rl_command_func_t *));
|
||||
extern void _rl_bind_if_unbound PARAMS((const char *, rl_command_func_t *));
|
||||
|
||||
/* display.c */
|
||||
extern char *_rl_strip_prompt __P((char *));
|
||||
extern void _rl_move_cursor_relative __P((int, const char *));
|
||||
extern void _rl_move_vert __P((int));
|
||||
extern void _rl_save_prompt __P((void));
|
||||
extern void _rl_restore_prompt __P((void));
|
||||
extern char *_rl_make_prompt_for_search __P((int));
|
||||
extern void _rl_erase_at_end_of_line __P((int));
|
||||
extern void _rl_clear_to_eol __P((int));
|
||||
extern void _rl_clear_screen __P((void));
|
||||
extern void _rl_update_final __P((void));
|
||||
extern void _rl_redisplay_after_sigwinch __P((void));
|
||||
extern void _rl_clean_up_for_exit __P((void));
|
||||
extern void _rl_erase_entire_line __P((void));
|
||||
extern int _rl_current_display_line __P((void));
|
||||
extern char *_rl_strip_prompt PARAMS((char *));
|
||||
extern void _rl_move_cursor_relative PARAMS((int, const char *));
|
||||
extern void _rl_move_vert PARAMS((int));
|
||||
extern void _rl_save_prompt PARAMS((void));
|
||||
extern void _rl_restore_prompt PARAMS((void));
|
||||
extern char *_rl_make_prompt_for_search PARAMS((int));
|
||||
extern void _rl_erase_at_end_of_line PARAMS((int));
|
||||
extern void _rl_clear_to_eol PARAMS((int));
|
||||
extern void _rl_clear_screen PARAMS((void));
|
||||
extern void _rl_update_final PARAMS((void));
|
||||
extern void _rl_redisplay_after_sigwinch PARAMS((void));
|
||||
extern void _rl_clean_up_for_exit PARAMS((void));
|
||||
extern void _rl_erase_entire_line PARAMS((void));
|
||||
extern int _rl_current_display_line PARAMS((void));
|
||||
|
||||
/* input.c */
|
||||
extern int _rl_any_typein __P((void));
|
||||
extern int _rl_input_available __P((void));
|
||||
extern void _rl_insert_typein __P((int));
|
||||
extern int _rl_any_typein PARAMS((void));
|
||||
extern int _rl_input_available PARAMS((void));
|
||||
extern void _rl_insert_typein PARAMS((int));
|
||||
|
||||
/* macro.c */
|
||||
extern void _rl_with_macro_input __P((char *));
|
||||
extern int _rl_next_macro_key __P((void));
|
||||
extern void _rl_push_executing_macro __P((void));
|
||||
extern void _rl_pop_executing_macro __P((void));
|
||||
extern void _rl_add_macro_char __P((int));
|
||||
extern void _rl_kill_kbd_macro __P((void));
|
||||
extern void _rl_with_macro_input PARAMS((char *));
|
||||
extern int _rl_next_macro_key PARAMS((void));
|
||||
extern void _rl_push_executing_macro PARAMS((void));
|
||||
extern void _rl_pop_executing_macro PARAMS((void));
|
||||
extern void _rl_add_macro_char PARAMS((int));
|
||||
extern void _rl_kill_kbd_macro PARAMS((void));
|
||||
|
||||
/* nls.c */
|
||||
extern int _rl_init_eightbit __P((void));
|
||||
extern int _rl_init_eightbit PARAMS((void));
|
||||
|
||||
/* parens.c */
|
||||
extern void _rl_enable_paren_matching __P((int));
|
||||
extern void _rl_enable_paren_matching PARAMS((int));
|
||||
|
||||
/* readline.c */
|
||||
extern void _rl_init_line_state __P((void));
|
||||
extern void _rl_set_the_line __P((void));
|
||||
extern int _rl_dispatch __P((int, Keymap));
|
||||
extern int _rl_init_argument __P((void));
|
||||
extern void _rl_fix_point __P((int));
|
||||
extern void _rl_replace_text __P((const char *, int, int));
|
||||
extern int _rl_char_search_internal __P((int, int, int));
|
||||
extern int _rl_set_mark_at_pos __P((int));
|
||||
extern int _rl_free_saved_history_line __P((void));
|
||||
extern void _rl_init_line_state PARAMS((void));
|
||||
extern void _rl_set_the_line PARAMS((void));
|
||||
extern int _rl_dispatch PARAMS((int, Keymap));
|
||||
extern int _rl_init_argument PARAMS((void));
|
||||
extern void _rl_fix_point PARAMS((int));
|
||||
extern void _rl_replace_text PARAMS((const char *, int, int));
|
||||
extern int _rl_char_search_internal PARAMS((int, int, int));
|
||||
extern int _rl_set_mark_at_pos PARAMS((int));
|
||||
extern int _rl_free_saved_history_line PARAMS((void));
|
||||
|
||||
/* rltty.c */
|
||||
extern int _rl_disable_tty_signals __P((void));
|
||||
extern int _rl_restore_tty_signals __P((void));
|
||||
extern int _rl_disable_tty_signals PARAMS((void));
|
||||
extern int _rl_restore_tty_signals PARAMS((void));
|
||||
|
||||
/* terminal.c */
|
||||
extern void _rl_get_screen_size __P((int, int));
|
||||
extern int _rl_init_terminal_io __P((const char *));
|
||||
extern void _rl_get_screen_size PARAMS((int, int));
|
||||
extern int _rl_init_terminal_io PARAMS((const char *));
|
||||
#ifdef _MINIX
|
||||
extern void _rl_output_character_function __P((int));
|
||||
extern void _rl_output_character_function PARAMS((int));
|
||||
#else
|
||||
extern int _rl_output_character_function __P((int));
|
||||
extern int _rl_output_character_function PARAMS((int));
|
||||
#endif
|
||||
extern void _rl_output_some_chars __P((const char *, int));
|
||||
extern int _rl_backspace __P((int));
|
||||
extern void _rl_enable_meta_key __P((void));
|
||||
extern void _rl_control_keypad __P((int));
|
||||
extern void _rl_output_some_chars PARAMS((const char *, int));
|
||||
extern int _rl_backspace PARAMS((int));
|
||||
extern void _rl_enable_meta_key PARAMS((void));
|
||||
extern void _rl_control_keypad PARAMS((int));
|
||||
|
||||
/* util.c */
|
||||
extern int rl_alphabetic __P((int));
|
||||
extern int _rl_abort_internal __P((void));
|
||||
extern char *_rl_strindex __P((const char *, const char *));
|
||||
extern char *_rl_strpbrk __P((const char *, const char *));
|
||||
extern int _rl_qsort_string_compare __P((char **, char **));
|
||||
extern int (_rl_uppercase_p) __P((int));
|
||||
extern int (_rl_lowercase_p) __P((int));
|
||||
extern int (_rl_pure_alphabetic) __P((int));
|
||||
extern int (_rl_digit_p) __P((int));
|
||||
extern int (_rl_to_lower) __P((int));
|
||||
extern int (_rl_to_upper) __P((int));
|
||||
extern int (_rl_digit_value) __P((int));
|
||||
extern int rl_alphabetic PARAMS((int));
|
||||
extern int _rl_abort_internal PARAMS((void));
|
||||
extern char *_rl_strindex PARAMS((const char *, const char *));
|
||||
extern int _rl_qsort_string_compare PARAMS((char **, char **));
|
||||
extern int (_rl_uppercase_p) PARAMS((int));
|
||||
extern int (_rl_lowercase_p) PARAMS((int));
|
||||
extern int (_rl_pure_alphabetic) PARAMS((int));
|
||||
extern int (_rl_digit_p) PARAMS((int));
|
||||
extern int (_rl_to_lower) PARAMS((int));
|
||||
extern int (_rl_to_upper) PARAMS((int));
|
||||
extern int (_rl_digit_value) PARAMS((int));
|
||||
|
||||
/* vi_mode.c */
|
||||
extern void _rl_vi_initialize_line __P((void));
|
||||
extern void _rl_vi_reset_last __P((void));
|
||||
extern void _rl_vi_set_last __P((int, int, int));
|
||||
extern int _rl_vi_textmod_command __P((int));
|
||||
extern void _rl_vi_done_inserting __P((void));
|
||||
extern void _rl_vi_initialize_line PARAMS((void));
|
||||
extern void _rl_vi_reset_last PARAMS((void));
|
||||
extern void _rl_vi_set_last PARAMS((int, int, int));
|
||||
extern int _rl_vi_textmod_command PARAMS((int));
|
||||
extern void _rl_vi_done_inserting PARAMS((void));
|
||||
|
||||
/*************************************************************************
|
||||
* Undocumented private variables *
|
||||
|
|
@ -213,6 +209,7 @@ extern int _rl_complete_show_all;
|
|||
extern int _rl_complete_mark_directories;
|
||||
extern int _rl_print_completions_horizontally;
|
||||
extern int _rl_completion_case_fold;
|
||||
extern int _rl_match_hidden_files;
|
||||
|
||||
/* display.c */
|
||||
extern int _rl_vis_botlin;
|
||||
|
|
@ -221,7 +218,7 @@ extern int _rl_suppress_redisplay;
|
|||
extern char *rl_display_prompt;
|
||||
|
||||
/* isearch.c */
|
||||
extern unsigned char *_rl_isearch_terminators;
|
||||
extern char *_rl_isearch_terminators;
|
||||
|
||||
/* macro.c */
|
||||
extern int _rl_defining_kbd_macro;
|
||||
|
|
@ -234,6 +231,7 @@ extern int _rl_bell_preference;
|
|||
extern int _rl_meta_flag;
|
||||
extern int _rl_convert_meta_chars_to_ascii;
|
||||
extern int _rl_output_meta_chars;
|
||||
extern int _rl_history_preserve_point;
|
||||
extern char *_rl_comment_begin;
|
||||
extern unsigned char _rl_parsing_conditionalized_out;
|
||||
extern Keymap _rl_keymap;
|
||||
|
|
|
|||
|
|
@ -25,10 +25,10 @@
|
|||
|
||||
#include "rlstdc.h"
|
||||
|
||||
extern char *sh_single_quote __P((char *));
|
||||
extern void sh_set_lines_and_columns __P((int, int));
|
||||
extern char *sh_get_env_value __P((const char *));
|
||||
extern char *sh_get_home_dir __P((void));
|
||||
extern int sh_unset_nodelay_mode __P((int));
|
||||
extern char *sh_single_quote PARAMS((char *));
|
||||
extern void sh_set_lines_and_columns PARAMS((int, int));
|
||||
extern char *sh_get_env_value PARAMS((const char *));
|
||||
extern char *sh_get_home_dir PARAMS((void));
|
||||
extern int sh_unset_nodelay_mode PARAMS((int));
|
||||
|
||||
#endif /* _RL_SHELL_H_ */
|
||||
|
|
|
|||
|
|
@ -26,26 +26,20 @@
|
|||
|
||||
/* A function can be defined using prototypes and compile on both ANSI C
|
||||
and traditional C compilers with something like this:
|
||||
extern char *func __P((char *, char *, int)); */
|
||||
extern char *func PARAMS((char *, char *, int)); */
|
||||
|
||||
#if !defined (__P)
|
||||
#if !defined (PARAMS)
|
||||
# if defined (__STDC__) || defined (__GNUC__) || defined (__cplusplus)
|
||||
# define __P(protos) protos
|
||||
# define PARAMS(protos) protos
|
||||
# else
|
||||
# define __P(protos) ()
|
||||
# define PARAMS(protos) ()
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined (__STDC__) && !defined (__cplusplus)
|
||||
# if defined (__GNUC__) /* gcc with -traditional */
|
||||
# if !defined (const)
|
||||
# define const __const
|
||||
# endif /* !const */
|
||||
# else /* !__GNUC__ */
|
||||
# if !defined (const)
|
||||
# define const
|
||||
# endif /* !const */
|
||||
# endif /* !__GNUC__ */
|
||||
#endif /* !__STDC__ && !__cplusplus */
|
||||
#ifndef __attribute__
|
||||
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8) || __STRICT_ANSI__
|
||||
# define __attribute__(x)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif /* !_RL_STDC_H_ */
|
||||
|
|
|
|||
|
|
@ -52,6 +52,11 @@ extern int errno;
|
|||
rl_vintfunc_t *rl_prep_term_function = rl_prep_terminal;
|
||||
rl_voidfunc_t *rl_deprep_term_function = rl_deprep_terminal;
|
||||
|
||||
static void block_sigint PARAMS((void));
|
||||
static void release_sigint PARAMS((void));
|
||||
|
||||
static void set_winsize PARAMS((int));
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
/* Signal Management */
|
||||
|
|
@ -173,6 +178,14 @@ struct bsdtty {
|
|||
|
||||
static TIOTYPE otio;
|
||||
|
||||
static void save_tty_chars PARAMS((TIOTYPE *));
|
||||
static int _get_tty_settings PARAMS((int, TIOTYPE *));
|
||||
static int get_tty_settings PARAMS((int, TIOTYPE *));
|
||||
static int _set_tty_settings PARAMS((int, TIOTYPE *));
|
||||
static int set_tty_settings PARAMS((int, TIOTYPE *));
|
||||
|
||||
static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
|
||||
|
||||
static void
|
||||
save_tty_chars (tiop)
|
||||
TIOTYPE *tiop;
|
||||
|
|
@ -379,6 +392,14 @@ prepare_terminal_settings (meta_flag, oldtio, tiop)
|
|||
|
||||
static TIOTYPE otio;
|
||||
|
||||
static void save_tty_chars PARAMS((TIOTYPE *));
|
||||
static int _get_tty_settings PARAMS((int, TIOTYPE *));
|
||||
static int get_tty_settings PARAMS((int, TIOTYPE *));
|
||||
static int _set_tty_settings PARAMS((int, TIOTYPE *));
|
||||
static int set_tty_settings PARAMS((int, TIOTYPE *));
|
||||
|
||||
static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
|
||||
|
||||
#if defined (FLUSHO)
|
||||
# define OUTPUT_BEING_FLUSHED(tp) (tp->c_lflag & FLUSHO)
|
||||
#else
|
||||
|
|
@ -626,6 +647,7 @@ rl_prep_terminal (meta_flag)
|
|||
if (get_tty_settings (tty, &tio) < 0)
|
||||
{
|
||||
release_sigint ();
|
||||
fprintf(stderr, "readline: warning: rl_prep_terminal: cannot get terminal settings");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -771,8 +793,8 @@ rltty_set_default_bindings (kmap)
|
|||
{ \
|
||||
int ic; \
|
||||
ic = sc; \
|
||||
if (ic != -1 && kmap[ic].type == ISFUNC) \
|
||||
kmap[ic].function = func; \
|
||||
if (ic != -1 && kmap[(unsigned char)ic].type == ISFUNC) \
|
||||
kmap[(unsigned char)ic].function = func; \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
|
|
@ -861,6 +883,7 @@ _rl_disable_tty_signals ()
|
|||
nosigstty = sigstty;
|
||||
|
||||
nosigstty.c_lflag &= ~ISIG;
|
||||
nosigstty.c_iflag &= ~IXON;
|
||||
|
||||
if (_set_tty_settings (fileno (rl_instream), &nosigstty) < 0)
|
||||
return (_set_tty_settings (fileno (rl_instream), &sigstty));
|
||||
|
|
@ -872,10 +895,17 @@ _rl_disable_tty_signals ()
|
|||
int
|
||||
_rl_restore_tty_signals ()
|
||||
{
|
||||
int r;
|
||||
|
||||
if (tty_sigs_disabled == 0)
|
||||
return 0;
|
||||
|
||||
return (_set_tty_settings (fileno (rl_instream), &sigstty));
|
||||
r = _set_tty_settings (fileno (rl_instream), &sigstty);
|
||||
|
||||
if (r == 0)
|
||||
tty_sigs_disabled = 0;
|
||||
|
||||
return r;
|
||||
}
|
||||
#endif /* !NEW_TTY_DRIVER */
|
||||
|
||||
|
|
|
|||
|
|
@ -45,40 +45,40 @@ typedef char **CPPFunction ();
|
|||
# define _RL_FUNCTION_TYPEDEF
|
||||
|
||||
/* Bindable functions */
|
||||
typedef int rl_command_func_t __P((int, int));
|
||||
typedef int rl_command_func_t PARAMS((int, int));
|
||||
|
||||
/* Typedefs for the completion system */
|
||||
typedef char *rl_compentry_func_t __P((const char *, int));
|
||||
typedef char **rl_completion_func_t __P((const char *, int, int));
|
||||
typedef char *rl_compentry_func_t PARAMS((const char *, int));
|
||||
typedef char **rl_completion_func_t PARAMS((const char *, int, int));
|
||||
|
||||
typedef char *rl_quote_func_t __P((char *, int, char *));
|
||||
typedef char *rl_dequote_func_t __P((char *, int));
|
||||
typedef char *rl_quote_func_t PARAMS((char *, int, char *));
|
||||
typedef char *rl_dequote_func_t PARAMS((char *, int));
|
||||
|
||||
typedef int rl_compignore_func_t __P((char **));
|
||||
typedef int rl_compignore_func_t PARAMS((char **));
|
||||
|
||||
typedef void rl_compdisp_func_t __P((char **, int, int));
|
||||
typedef void rl_compdisp_func_t PARAMS((char **, int, int));
|
||||
|
||||
/* Type for input and pre-read hook functions like rl_event_hook */
|
||||
typedef int rl_hook_func_t __P((void));
|
||||
typedef int rl_hook_func_t PARAMS((void));
|
||||
|
||||
/* Input function type */
|
||||
typedef int rl_getc_func_t __P((FILE *));
|
||||
typedef int rl_getc_func_t PARAMS((FILE *));
|
||||
|
||||
/* Generic function that takes a character buffer (which could be the readline
|
||||
line buffer) and an index into it (which could be rl_point) and returns
|
||||
an int. */
|
||||
typedef int rl_linebuf_func_t __P((char *, int));
|
||||
typedef int rl_linebuf_func_t PARAMS((char *, int));
|
||||
|
||||
/* `Generic' function pointer typedefs */
|
||||
typedef int rl_intfunc_t __P((int));
|
||||
typedef int rl_intfunc_t PARAMS((int));
|
||||
#define rl_ivoidfunc_t rl_hook_func_t
|
||||
typedef int rl_icpfunc_t __P((char *));
|
||||
typedef int rl_icppfunc_t __P((char **));
|
||||
typedef int rl_icpfunc_t PARAMS((char *));
|
||||
typedef int rl_icppfunc_t PARAMS((char **));
|
||||
|
||||
typedef void rl_voidfunc_t __P((void));
|
||||
typedef void rl_vintfunc_t __P((int));
|
||||
typedef void rl_vcpfunc_t __P((char *));
|
||||
typedef void rl_vcppfunc_t __P((char **));
|
||||
typedef void rl_voidfunc_t PARAMS((void));
|
||||
typedef void rl_vintfunc_t PARAMS((int));
|
||||
typedef void rl_vcpfunc_t PARAMS((char *));
|
||||
typedef void rl_vcppfunc_t PARAMS((char **));
|
||||
#endif /* _RL_FUNCTION_TYPEDEF */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -20,8 +20,11 @@
|
|||
have a copy of the license, write to the Free Software Foundation,
|
||||
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
||||
|
||||
extern char *strcpy ();
|
||||
extern char *xmalloc ();
|
||||
#include <config.h>
|
||||
#ifdef HAVE_STRING_H
|
||||
# include <string.h>
|
||||
#endif
|
||||
#include "xmalloc.h"
|
||||
|
||||
/* Backwards compatibility, now that savestring has been removed from
|
||||
all `public' readline header files. */
|
||||
|
|
@ -29,5 +32,5 @@ char *
|
|||
savestring (s)
|
||||
const char *s;
|
||||
{
|
||||
return ((char *)strcpy (xmalloc (1 + (int)strlen (s)), (s)));
|
||||
return ((char *)strcpy ((char *)xmalloc (1 + strlen (s)), (s)));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@
|
|||
extern HIST_ENTRY *_rl_saved_line_for_history;
|
||||
|
||||
/* Functions imported from the rest of the library. */
|
||||
extern int _rl_free_history_entry __P((HIST_ENTRY *));
|
||||
extern int _rl_free_history_entry PARAMS((HIST_ENTRY *));
|
||||
|
||||
static char *noninc_search_string = (char *) NULL;
|
||||
static int noninc_history_pos;
|
||||
|
|
@ -66,6 +66,13 @@ static int rl_history_search_pos;
|
|||
static char *history_search_string;
|
||||
static int history_string_size;
|
||||
|
||||
static void make_history_line_current PARAMS((HIST_ENTRY *));
|
||||
static int noninc_search_from_pos PARAMS((char *, int, int));
|
||||
static void noninc_dosearch PARAMS((char *, int));
|
||||
static void noninc_search PARAMS((int, int));
|
||||
static int rl_history_search_internal PARAMS((int, int));
|
||||
static void rl_history_search_reinit PARAMS((void));
|
||||
|
||||
/* Make the data from the history entry ENTRY be the contents of the
|
||||
current line. This doesn't do anything with rl_point; the caller
|
||||
must set it. */
|
||||
|
|
@ -391,7 +398,7 @@ rl_history_search_reinit ()
|
|||
if (rl_history_search_len >= history_string_size - 2)
|
||||
{
|
||||
history_string_size = rl_history_search_len + 2;
|
||||
history_search_string = xrealloc (history_search_string, history_string_size);
|
||||
history_search_string = (char *)xrealloc (history_search_string, history_string_size);
|
||||
}
|
||||
history_search_string[0] = '^';
|
||||
strncpy (history_search_string + 1, rl_line_buffer, rl_point);
|
||||
|
|
|
|||
|
|
@ -44,6 +44,10 @@
|
|||
# include <strings.h>
|
||||
#endif /* !HAVE_STRING_H */
|
||||
|
||||
#if defined (HAVE_LIMITS_H)
|
||||
# include <limits.h>
|
||||
#endif
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <pwd.h>
|
||||
|
||||
|
|
@ -54,13 +58,29 @@
|
|||
#include "xmalloc.h"
|
||||
|
||||
#if !defined (HAVE_GETPW_DECLS)
|
||||
extern struct passwd *getpwuid __P((uid_t));
|
||||
extern struct passwd *getpwuid PARAMS((uid_t));
|
||||
#endif /* !HAVE_GETPW_DECLS */
|
||||
|
||||
#ifndef NULL
|
||||
# define NULL 0
|
||||
#endif
|
||||
|
||||
#ifndef CHAR_BIT
|
||||
# define CHAR_BIT 8
|
||||
#endif
|
||||
|
||||
/* Nonzero if the integer type T is signed. */
|
||||
#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
|
||||
|
||||
/* Bound on length of the string representing an integer value of type T.
|
||||
Subtract one for the sign bit if T is signed;
|
||||
302 / 1000 is log10 (2) rounded up;
|
||||
add one for integer division truncation;
|
||||
add one more for a minus sign if t is signed. */
|
||||
#define INT_STRLEN_BOUND(t) \
|
||||
((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 \
|
||||
+ 1 + TYPE_SIGNED (t))
|
||||
|
||||
/* All of these functions are resolved from bash if we are linking readline
|
||||
as part of bash. */
|
||||
|
||||
|
|
@ -103,18 +123,18 @@ sh_set_lines_and_columns (lines, cols)
|
|||
char *b;
|
||||
|
||||
#if defined (HAVE_PUTENV)
|
||||
b = xmalloc (24);
|
||||
b = (char *)xmalloc (INT_STRLEN_BOUND (int) + sizeof ("LINES=") + 1);
|
||||
sprintf (b, "LINES=%d", lines);
|
||||
putenv (b);
|
||||
b = xmalloc (24);
|
||||
b = (char *)xmalloc (INT_STRLEN_BOUND (int) + sizeof ("COLUMNS=") + 1);
|
||||
sprintf (b, "COLUMNS=%d", cols);
|
||||
putenv (b);
|
||||
#else /* !HAVE_PUTENV */
|
||||
# if defined (HAVE_SETENV)
|
||||
b = xmalloc (8);
|
||||
b = (char *)xmalloc (INT_STRLEN_BOUND (int) + 1);
|
||||
sprintf (b, "%d", lines);
|
||||
setenv ("LINES", b, 1);
|
||||
b = xmalloc (8);
|
||||
b = (char *)xmalloc (INT_STRLEN_BOUND (int) + 1);
|
||||
sprintf (b, "%d", cols);
|
||||
setenv ("COLUMNS", b, 1);
|
||||
# endif /* HAVE_SETENV */
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt
|
|||
# define sigemptyset(m)
|
||||
#endif /* !HAVE_POSIX_SIGNALS */
|
||||
|
||||
static SigHandler *rl_set_sighandler __P((int, SigHandler *, sighandler_cxt *));
|
||||
static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
|
||||
|
||||
/* Exported variables for use by applications. */
|
||||
|
||||
|
|
|
|||
|
|
@ -64,6 +64,7 @@
|
|||
|
||||
#include "rlprivate.h"
|
||||
#include "rlshell.h"
|
||||
#include "xmalloc.h"
|
||||
|
||||
/* **************************************************************** */
|
||||
/* */
|
||||
|
|
@ -326,7 +327,11 @@ get_term_capabilities (bp)
|
|||
register int i;
|
||||
|
||||
for (i = 0; i < NUM_TC_STRINGS; i++)
|
||||
# ifdef __LCC__
|
||||
*(tc_strings[i].tc_value) = tgetstr ((char *)tc_strings[i].tc_var, bp);
|
||||
# else
|
||||
*(tc_strings[i].tc_value) = tgetstr (tc_strings[i].tc_var, bp);
|
||||
# endif
|
||||
#endif
|
||||
tcap_initialized = 1;
|
||||
}
|
||||
|
|
@ -361,10 +366,10 @@ _rl_init_terminal_io (terminal_name)
|
|||
else
|
||||
{
|
||||
if (term_string_buffer == 0)
|
||||
term_string_buffer = xmalloc(2032);
|
||||
term_string_buffer = (char *)xmalloc(2032);
|
||||
|
||||
if (term_buffer == 0)
|
||||
term_buffer = xmalloc(4080);
|
||||
term_buffer = (char *)xmalloc(4080);
|
||||
|
||||
buffer = term_string_buffer;
|
||||
|
||||
|
|
|
|||
|
|
@ -48,22 +48,21 @@
|
|||
#include "tilde.h"
|
||||
|
||||
#if defined (TEST) || defined (STATIC_MALLOC)
|
||||
static char *xmalloc (), *xrealloc ();
|
||||
static void *xmalloc (), *xrealloc ();
|
||||
#else
|
||||
extern char *xmalloc __P((int));
|
||||
extern char *xrealloc __P((void *, int));
|
||||
# include "xmalloc.h"
|
||||
#endif /* TEST || STATIC_MALLOC */
|
||||
|
||||
#if !defined (HAVE_GETPW_DECLS)
|
||||
extern struct passwd *getpwuid __P((uid_t));
|
||||
extern struct passwd *getpwnam __P((const char *));
|
||||
extern struct passwd *getpwuid PARAMS((uid_t));
|
||||
extern struct passwd *getpwnam PARAMS((const char *));
|
||||
#endif /* !HAVE_GETPW_DECLS */
|
||||
|
||||
#if !defined (savestring)
|
||||
# ifndef strcpy
|
||||
extern char *strcpy ();
|
||||
# endif
|
||||
#define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x))
|
||||
#define savestring(x) strcpy ((char *)xmalloc (1 + strlen (x)), (x))
|
||||
#endif /* !savestring */
|
||||
|
||||
#if !defined (NULL)
|
||||
|
|
@ -77,8 +76,8 @@ extern char *strcpy ();
|
|||
/* If being compiled as part of bash, these will be satisfied from
|
||||
variables.o. If being compiled as part of readline, they will
|
||||
be satisfied from shell.o. */
|
||||
extern char *sh_get_home_dir __P((void));
|
||||
extern char *sh_get_env_value __P((const char *));
|
||||
extern char *sh_get_home_dir PARAMS((void));
|
||||
extern char *sh_get_env_value PARAMS((const char *));
|
||||
|
||||
/* The default value of tilde_additional_prefixes. This is set to
|
||||
whitespace preceding a tilde so that simple programs which do not
|
||||
|
|
@ -114,12 +113,17 @@ char **tilde_additional_prefixes = (char **)default_prefixes;
|
|||
`:' and `=~'. */
|
||||
char **tilde_additional_suffixes = (char **)default_suffixes;
|
||||
|
||||
static int tilde_find_prefix PARAMS((const char *, int *));
|
||||
static int tilde_find_suffix PARAMS((const char *));
|
||||
static char *isolate_tilde_prefix PARAMS((const char *, int *));
|
||||
static char *glue_prefix_and_suffix PARAMS((char *, const char *, int));
|
||||
|
||||
/* Find the start of a tilde expansion in STRING, and return the index of
|
||||
the tilde which starts the expansion. Place the length of the text
|
||||
which identified this tilde starter in LEN, excluding the tilde itself. */
|
||||
static int
|
||||
tilde_find_prefix (string, len)
|
||||
char *string;
|
||||
const char *string;
|
||||
int *len;
|
||||
{
|
||||
register int i, j, string_len;
|
||||
|
|
@ -154,7 +158,7 @@ tilde_find_prefix (string, len)
|
|||
the character which ends the tilde definition. */
|
||||
static int
|
||||
tilde_find_suffix (string)
|
||||
char *string;
|
||||
const char *string;
|
||||
{
|
||||
register int i, j, string_len;
|
||||
register char **suffixes;
|
||||
|
|
@ -190,9 +194,9 @@ tilde_expand (string)
|
|||
|
||||
result_index = result_size = 0;
|
||||
if (result = strchr (string, '~'))
|
||||
result = xmalloc (result_size = (strlen (string) + 16));
|
||||
result = (char *)xmalloc (result_size = (strlen (string) + 16));
|
||||
else
|
||||
result = xmalloc (result_size = (strlen (string) + 1));
|
||||
result = (char *)xmalloc (result_size = (strlen (string) + 1));
|
||||
|
||||
/* Scan through STRING expanding tildes as we come to them. */
|
||||
while (1)
|
||||
|
|
@ -206,7 +210,7 @@ tilde_expand (string)
|
|||
|
||||
/* Copy the skipped text into the result. */
|
||||
if ((result_index + start + 1) > result_size)
|
||||
result = xrealloc (result, 1 + (result_size += (start + 20)));
|
||||
result = (char *)xrealloc (result, 1 + (result_size += (start + 20)));
|
||||
|
||||
strncpy (result + result_index, string, start);
|
||||
result_index += start;
|
||||
|
|
@ -223,7 +227,7 @@ tilde_expand (string)
|
|||
break;
|
||||
|
||||
/* Expand the entire tilde word, and copy it into RESULT. */
|
||||
tilde_word = xmalloc (1 + end);
|
||||
tilde_word = (char *)xmalloc (1 + end);
|
||||
strncpy (tilde_word, string, end);
|
||||
tilde_word[end] = '\0';
|
||||
string += end;
|
||||
|
|
@ -239,7 +243,7 @@ tilde_expand (string)
|
|||
#endif
|
||||
{
|
||||
if ((result_index + len + 1) > result_size)
|
||||
result = xrealloc (result, 1 + (result_size += (len + 20)));
|
||||
result = (char *)xrealloc (result, 1 + (result_size += (len + 20)));
|
||||
|
||||
strcpy (result + result_index, expansion);
|
||||
result_index += len;
|
||||
|
|
@ -257,13 +261,13 @@ tilde_expand (string)
|
|||
the location it points to. */
|
||||
static char *
|
||||
isolate_tilde_prefix (fname, lenp)
|
||||
char *fname;
|
||||
const char *fname;
|
||||
int *lenp;
|
||||
{
|
||||
char *ret;
|
||||
int i;
|
||||
|
||||
ret = xmalloc (strlen (fname));
|
||||
ret = (char *)xmalloc (strlen (fname));
|
||||
#if defined (__MSDOS__)
|
||||
for (i = 1; fname[i] && fname[i] != '/' && fname[i] != '\\'; i++)
|
||||
#else
|
||||
|
|
@ -280,7 +284,8 @@ isolate_tilde_prefix (fname, lenp)
|
|||
SUFFIND. */
|
||||
static char *
|
||||
glue_prefix_and_suffix (prefix, suffix, suffind)
|
||||
char *prefix, *suffix;
|
||||
char *prefix;
|
||||
const char *suffix;
|
||||
int suffind;
|
||||
{
|
||||
char *ret;
|
||||
|
|
@ -288,7 +293,7 @@ glue_prefix_and_suffix (prefix, suffix, suffind)
|
|||
|
||||
plen = (prefix && *prefix) ? strlen (prefix) : 0;
|
||||
slen = strlen (suffix + suffind);
|
||||
ret = xmalloc (plen + slen + 1);
|
||||
ret = (char *)xmalloc (plen + slen + 1);
|
||||
if (plen)
|
||||
strcpy (ret, prefix);
|
||||
strcpy (ret + plen, suffix + suffind);
|
||||
|
|
@ -412,28 +417,28 @@ main (argc, argv)
|
|||
|
||||
static void memory_error_and_abort ();
|
||||
|
||||
static char *
|
||||
static void *
|
||||
xmalloc (bytes)
|
||||
int bytes;
|
||||
size_t bytes;
|
||||
{
|
||||
char *temp = (char *)malloc (bytes);
|
||||
void *temp = (char *)malloc (bytes);
|
||||
|
||||
if (!temp)
|
||||
memory_error_and_abort ();
|
||||
return (temp);
|
||||
}
|
||||
|
||||
static char *
|
||||
static void *
|
||||
xrealloc (pointer, bytes)
|
||||
char *pointer;
|
||||
void *pointer;
|
||||
int bytes;
|
||||
{
|
||||
char *temp;
|
||||
void *temp;
|
||||
|
||||
if (!pointer)
|
||||
temp = (char *)malloc (bytes);
|
||||
temp = malloc (bytes);
|
||||
else
|
||||
temp = (char *)realloc (pointer, bytes);
|
||||
temp = realloc (pointer, bytes);
|
||||
|
||||
if (!temp)
|
||||
memory_error_and_abort ();
|
||||
|
|
|
|||
|
|
@ -24,35 +24,27 @@
|
|||
#if !defined (_TILDE_H_)
|
||||
# define _TILDE_H_
|
||||
|
||||
#if defined (HAVE_CONFIG_H)
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* A function can be defined using prototypes and compile on both ANSI C
|
||||
and traditional C compilers with something like this:
|
||||
extern char *func __P((char *, char *, int)); */
|
||||
extern char *func PARAMS((char *, char *, int)); */
|
||||
|
||||
#if !defined (__P)
|
||||
#if !defined (PARAMS)
|
||||
# if defined (__STDC__) || defined (__GNUC__) || defined (__cplusplus)
|
||||
# define __P(protos) protos
|
||||
# define PARAMS(protos) protos
|
||||
# else
|
||||
# define __P(protos) ()
|
||||
# define PARAMS(protos) ()
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined (__STDC__) && !defined (__cplusplus)
|
||||
# if defined (__GNUC__) /* gcc with -traditional */
|
||||
# if !defined (const)
|
||||
# define const __const
|
||||
# endif /* !const */
|
||||
# else /* !__GNUC__ */
|
||||
# if !defined (const)
|
||||
# define const
|
||||
# endif /* !const */
|
||||
# endif /* !__GNUC__ */
|
||||
#endif /* !__STDC__ && !__cplusplus */
|
||||
|
||||
typedef char *tilde_hook_func_t __P((char *));
|
||||
typedef char *tilde_hook_func_t PARAMS((char *));
|
||||
|
||||
/* If non-null, this contains the address of a function that the application
|
||||
wants called before trying the standard tilde expansions. The function
|
||||
|
|
@ -77,11 +69,11 @@ extern char **tilde_additional_prefixes;
|
|||
extern char **tilde_additional_suffixes;
|
||||
|
||||
/* Return a new string which is the result of tilde expanding STRING. */
|
||||
extern char *tilde_expand __P((const char *));
|
||||
extern char *tilde_expand PARAMS((const char *));
|
||||
|
||||
/* Do the work of tilde expansion on FILENAME. FILENAME starts with a
|
||||
tilde. If there is no expansion, call tilde_expansion_failure_hook. */
|
||||
extern char *tilde_expand_word __P((const char *));
|
||||
extern char *tilde_expand_word PARAMS((const char *));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,6 +48,7 @@
|
|||
#include "history.h"
|
||||
|
||||
#include "rlprivate.h"
|
||||
#include "xmalloc.h"
|
||||
|
||||
#define SWAP(s, e) do { int t; t = s; s = e; e = t; } while (0)
|
||||
|
||||
|
|
|
|||
|
|
@ -132,7 +132,7 @@ rl_copy_text (from, to)
|
|||
SWAP (from, to);
|
||||
|
||||
length = to - from;
|
||||
copy = xmalloc (1 + length);
|
||||
copy = (char *)xmalloc (1 + length);
|
||||
strncpy (copy, rl_line_buffer + from, length);
|
||||
copy[length] = '\0';
|
||||
return (copy);
|
||||
|
|
@ -147,7 +147,7 @@ rl_extend_line_buffer (len)
|
|||
while (len >= rl_line_buffer_len)
|
||||
{
|
||||
rl_line_buffer_len += DEFAULT_BUFFER_SIZE;
|
||||
rl_line_buffer = xrealloc (rl_line_buffer, rl_line_buffer_len);
|
||||
rl_line_buffer = (char *)xrealloc (rl_line_buffer, rl_line_buffer_len);
|
||||
}
|
||||
|
||||
_rl_set_the_line ();
|
||||
|
|
@ -193,7 +193,7 @@ rl_tilde_expand (ignore, key)
|
|||
if (rl_line_buffer[start] == '~')
|
||||
{
|
||||
len = end - start + 1;
|
||||
temp = xmalloc (len + 1);
|
||||
temp = (char *)xmalloc (len + 1);
|
||||
strncpy (temp, rl_line_buffer + start, len);
|
||||
temp[len] = '\0';
|
||||
homedir = tilde_expand (temp);
|
||||
|
|
@ -225,6 +225,7 @@ _rl_strindex (s1, s2)
|
|||
return ((char *)NULL);
|
||||
}
|
||||
|
||||
#ifndef HAVE_STRPBRK
|
||||
/* Find the first occurrence in STRING1 of any character from STRING2.
|
||||
Return a pointer to the character in STRING1. */
|
||||
char *
|
||||
|
|
@ -243,6 +244,7 @@ _rl_strpbrk (string1, string2)
|
|||
}
|
||||
return ((char *)NULL);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined (HAVE_STRCASECMP)
|
||||
/* Compare at most COUNT characters from string1 to string2. Case
|
||||
|
|
@ -302,62 +304,16 @@ _rl_qsort_string_compare (s1, s2)
|
|||
#endif
|
||||
}
|
||||
|
||||
/* Function equivalents for the macros defined in chartypes.h. */
|
||||
#undef _rl_uppercase_p
|
||||
int
|
||||
_rl_uppercase_p (c)
|
||||
int c;
|
||||
{
|
||||
return (isupper (c));
|
||||
}
|
||||
/* Function equivalents for the macros defined in chardefs.h. */
|
||||
#define FUNCTION_FOR_MACRO(f) int (f) (c) int c; { return f (c); }
|
||||
|
||||
#undef _rl_lowercase_p
|
||||
int
|
||||
_rl_lowercase_p (c)
|
||||
int c;
|
||||
{
|
||||
return (islower (c));
|
||||
}
|
||||
|
||||
#undef _rl_pure_alphabetic
|
||||
int
|
||||
_rl_pure_alphabetic (c)
|
||||
int c;
|
||||
{
|
||||
return (isupper (c) || islower (c));
|
||||
}
|
||||
|
||||
#undef _rl_digit_p
|
||||
int
|
||||
_rl_digit_p (c)
|
||||
int c;
|
||||
{
|
||||
return (isdigit (c));
|
||||
}
|
||||
|
||||
#undef _rl_to_lower
|
||||
int
|
||||
_rl_to_lower (c)
|
||||
int c;
|
||||
{
|
||||
return (isupper (c) ? tolower (c) : c);
|
||||
}
|
||||
|
||||
#undef _rl_to_upper
|
||||
int
|
||||
_rl_to_upper (c)
|
||||
int c;
|
||||
{
|
||||
return (islower (c) ? toupper (c) : c);
|
||||
}
|
||||
|
||||
#undef _rl_digit_value
|
||||
int
|
||||
_rl_digit_value (c)
|
||||
int c;
|
||||
{
|
||||
return (isdigit (c) ? c - '0' : c);
|
||||
}
|
||||
FUNCTION_FOR_MACRO (_rl_digit_p)
|
||||
FUNCTION_FOR_MACRO (_rl_digit_value)
|
||||
FUNCTION_FOR_MACRO (_rl_lowercase_p)
|
||||
FUNCTION_FOR_MACRO (_rl_pure_alphabetic)
|
||||
FUNCTION_FOR_MACRO (_rl_to_lower)
|
||||
FUNCTION_FOR_MACRO (_rl_to_upper)
|
||||
FUNCTION_FOR_MACRO (_rl_uppercase_p)
|
||||
|
||||
/* Backwards compatibility, now that savestring has been removed from
|
||||
all `public' readline header files. */
|
||||
|
|
@ -366,5 +322,5 @@ char *
|
|||
_rl_savestring (s)
|
||||
const char *s;
|
||||
{
|
||||
return (strcpy (xmalloc (1 + (int)strlen (s)), (s)));
|
||||
return (strcpy ((char *)xmalloc (1 + (int)strlen (s)), (s)));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,22 +57,10 @@
|
|||
#include "rlprivate.h"
|
||||
#include "xmalloc.h"
|
||||
|
||||
#ifndef _rl_digit_p
|
||||
#define _rl_digit_p(c) ((c) >= '0' && (c) <= '9')
|
||||
#endif
|
||||
|
||||
#ifndef _rl_digit_value
|
||||
#define _rl_digit_value(c) ((c) - '0')
|
||||
#endif
|
||||
|
||||
#ifndef member
|
||||
#define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0)
|
||||
#endif
|
||||
|
||||
#ifndef isident
|
||||
#define isident(c) ((_rl_pure_alphabetic (c) || _rl_digit_p (c) || c == '_'))
|
||||
#endif
|
||||
|
||||
#ifndef exchange
|
||||
#define exchange(x, y) do {int temp = x; x = y; y = temp;} while (0)
|
||||
#endif
|
||||
|
|
@ -81,7 +69,7 @@
|
|||
static int _rl_vi_doing_insert;
|
||||
|
||||
/* Command keys which do movement for xxx_to commands. */
|
||||
static const char *vi_motion = " hl^$0ftFt;,%wbeWBE|";
|
||||
static const char *vi_motion = " hl^$0ftFT;,%wbeWBE|";
|
||||
|
||||
/* Keymap used for vi replace characters. Created dynamically since
|
||||
rarely used. */
|
||||
|
|
@ -112,9 +100,11 @@ static int vi_redoing;
|
|||
static const char *vi_textmod = "_*\\AaIiCcDdPpYyRrSsXx~";
|
||||
|
||||
/* Arrays for the saved marks. */
|
||||
static int vi_mark_chars[27];
|
||||
static int vi_mark_chars['z' - 'a' + 1];
|
||||
|
||||
static int rl_digit_loop1 __P((void));
|
||||
static void _rl_vi_stuff_insert PARAMS((int));
|
||||
static void _rl_vi_save_insert PARAMS((UNDO_LIST *));
|
||||
static int rl_digit_loop1 PARAMS((void));
|
||||
|
||||
void
|
||||
_rl_vi_initialize_line ()
|
||||
|
|
@ -460,14 +450,14 @@ rl_vi_fword (count, ignore)
|
|||
while (count-- && rl_point < (rl_end - 1))
|
||||
{
|
||||
/* Move to white space (really non-identifer). */
|
||||
if (isident (rl_line_buffer[rl_point]))
|
||||
if (_rl_isident (rl_line_buffer[rl_point]))
|
||||
{
|
||||
while (isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
||||
while (_rl_isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
||||
rl_point++;
|
||||
}
|
||||
else /* if (!whitespace (rl_line_buffer[rl_point])) */
|
||||
{
|
||||
while (!isident (rl_line_buffer[rl_point]) &&
|
||||
while (!_rl_isident (rl_line_buffer[rl_point]) &&
|
||||
!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
||||
rl_point++;
|
||||
}
|
||||
|
|
@ -497,9 +487,9 @@ rl_vi_bword (count, ignore)
|
|||
back so we don't get messed up by the rl_point++ down there in
|
||||
the while loop. Without this code, words like `l;' screw up the
|
||||
function. */
|
||||
last_is_ident = isident (rl_line_buffer[rl_point - 1]);
|
||||
if ((isident (rl_line_buffer[rl_point]) && !last_is_ident) ||
|
||||
(!isident (rl_line_buffer[rl_point]) && last_is_ident))
|
||||
last_is_ident = _rl_isident (rl_line_buffer[rl_point - 1]);
|
||||
if ((_rl_isident (rl_line_buffer[rl_point]) && !last_is_ident) ||
|
||||
(!_rl_isident (rl_line_buffer[rl_point]) && last_is_ident))
|
||||
rl_point--;
|
||||
|
||||
while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
|
||||
|
|
@ -507,10 +497,10 @@ rl_vi_bword (count, ignore)
|
|||
|
||||
if (rl_point > 0)
|
||||
{
|
||||
if (isident (rl_line_buffer[rl_point]))
|
||||
while (--rl_point >= 0 && isident (rl_line_buffer[rl_point]));
|
||||
if (_rl_isident (rl_line_buffer[rl_point]))
|
||||
while (--rl_point >= 0 && _rl_isident (rl_line_buffer[rl_point]));
|
||||
else
|
||||
while (--rl_point >= 0 && !isident (rl_line_buffer[rl_point]) &&
|
||||
while (--rl_point >= 0 && !_rl_isident (rl_line_buffer[rl_point]) &&
|
||||
!whitespace (rl_line_buffer[rl_point]));
|
||||
rl_point++;
|
||||
}
|
||||
|
|
@ -532,10 +522,10 @@ rl_vi_eword (count, ignore)
|
|||
|
||||
if (rl_point < rl_end)
|
||||
{
|
||||
if (isident (rl_line_buffer[rl_point]))
|
||||
while (++rl_point < rl_end && isident (rl_line_buffer[rl_point]));
|
||||
if (_rl_isident (rl_line_buffer[rl_point]))
|
||||
while (++rl_point < rl_end && _rl_isident (rl_line_buffer[rl_point]));
|
||||
else
|
||||
while (++rl_point < rl_end && !isident (rl_line_buffer[rl_point])
|
||||
while (++rl_point < rl_end && !_rl_isident (rl_line_buffer[rl_point])
|
||||
&& !whitespace (rl_line_buffer[rl_point]));
|
||||
}
|
||||
rl_point--;
|
||||
|
|
@ -611,7 +601,7 @@ _rl_vi_save_insert (up)
|
|||
if (len >= vi_insert_buffer_size)
|
||||
{
|
||||
vi_insert_buffer_size += (len + 32) - (len % 32);
|
||||
vi_insert_buffer = xrealloc (vi_insert_buffer, vi_insert_buffer_size);
|
||||
vi_insert_buffer = (char *)xrealloc (vi_insert_buffer, vi_insert_buffer_size);
|
||||
}
|
||||
strncpy (vi_insert_buffer, rl_line_buffer + start, len - 1);
|
||||
vi_insert_buffer[len-1] = '\0';
|
||||
|
|
@ -847,12 +837,12 @@ rl_digit_loop1 ()
|
|||
RL_UNSETSTATE(RL_STATE_NUMERICARG);
|
||||
return 1;
|
||||
}
|
||||
rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg, 0);
|
||||
rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg);
|
||||
RL_SETSTATE(RL_STATE_MOREINPUT);
|
||||
key = c = rl_read_key ();
|
||||
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
||||
|
||||
if (_rl_keymap[c].type == ISFUNC &&
|
||||
if (c >= 0 && _rl_keymap[c].type == ISFUNC &&
|
||||
_rl_keymap[c].function == rl_universal_argument)
|
||||
{
|
||||
rl_numeric_arg *= 4;
|
||||
|
|
@ -1356,7 +1346,7 @@ rl_vi_set_mark (count, key)
|
|||
ch = rl_read_key ();
|
||||
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
||||
|
||||
if (_rl_lowercase_p (ch) == 0)
|
||||
if (ch < 'a' || ch > 'z')
|
||||
{
|
||||
rl_ding ();
|
||||
return -1;
|
||||
|
|
@ -1381,7 +1371,7 @@ rl_vi_goto_mark (count, key)
|
|||
rl_point = rl_mark;
|
||||
return 0;
|
||||
}
|
||||
else if (_rl_lowercase_p (ch) == 0)
|
||||
else if (ch < 'a' || ch > 'z')
|
||||
{
|
||||
rl_ding ();
|
||||
return -1;
|
||||
|
|
|
|||
|
|
@ -51,26 +51,26 @@ memory_error_and_abort (fname)
|
|||
/* Return a pointer to free()able block of memory large enough
|
||||
to hold BYTES number of bytes. If the memory cannot be allocated,
|
||||
print an error message and abort. */
|
||||
char *
|
||||
PTR_T
|
||||
xmalloc (bytes)
|
||||
int bytes;
|
||||
size_t bytes;
|
||||
{
|
||||
char *temp;
|
||||
PTR_T temp;
|
||||
|
||||
temp = (char *)malloc (bytes);
|
||||
temp = malloc (bytes);
|
||||
if (temp == 0)
|
||||
memory_error_and_abort ("xmalloc");
|
||||
return (temp);
|
||||
}
|
||||
|
||||
char *
|
||||
PTR_T
|
||||
xrealloc (pointer, bytes)
|
||||
PTR_T pointer;
|
||||
int bytes;
|
||||
size_t bytes;
|
||||
{
|
||||
char *temp;
|
||||
PTR_T temp;
|
||||
|
||||
temp = pointer ? (char *)realloc (pointer, bytes) : (char *)malloc (bytes);
|
||||
temp = pointer ? realloc (pointer, bytes) : malloc (bytes);
|
||||
|
||||
if (temp == 0)
|
||||
memory_error_and_abort ("xrealloc");
|
||||
|
|
|
|||
|
|
@ -39,8 +39,8 @@
|
|||
|
||||
#endif /* !PTR_T */
|
||||
|
||||
extern char *xmalloc __P((int));
|
||||
extern char *xrealloc __P((void *, int));
|
||||
extern void xfree __P((void *));
|
||||
extern PTR_T xmalloc PARAMS((size_t));
|
||||
extern PTR_T xrealloc PARAMS((void *, size_t));
|
||||
extern void xfree PARAMS((void *));
|
||||
|
||||
#endif /* _XMALLOC_H_ */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue