embedaddon/readline/bind.c - diff

Return to bind.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline

Diff for /embedaddon/readline/bind.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2014/07/30 08:16:45	version 1.1.1.2, 2021/03/17 01:01:01
Line 1	Line 1
/* bind.c -- key binding and startup file support for the readline library. */	/* bind.c -- key binding and startup file support for the readline library. */

/* Copyright (C) 1987-2012 Free Software Foundation, Inc.	/* Copyright (C) 1987-2020 Free Software Foundation, Inc.

This file is part of the GNU Readline Library (Readline), a library	This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.	for reading lines of text with interactive input and history editing.
Line 74 Keymap rl_binding_keymap;	Line 74 Keymap rl_binding_keymap;

static int _rl_skip_to_delim PARAMS((char *, int, int));	static int _rl_skip_to_delim PARAMS((char *, int, int));

	#if defined (USE_VARARGS) && defined (PREFER_STDARG)
	static void _rl_init_file_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));
	#else
	static void _rl_init_file_error ();
	#endif

	static rl_command_func_t _rl_function_of_keyseq_internal PARAMS((const char , size_t, Keymap, int *));

static char _rl_read_file PARAMS((char , size_t *));	static char _rl_read_file PARAMS((char , size_t *));
static void _rl_init_file_error PARAMS((const char *));
static int _rl_read_init_file PARAMS((const char *, int));	static int _rl_read_init_file PARAMS((const char *, int));
static int glean_key_from_name PARAMS((char *));	static int glean_key_from_name PARAMS((char *));

static int find_boolean_var PARAMS((const char *));	static int find_boolean_var PARAMS((const char *));
static int find_string_var PARAMS((const char *));	static int find_string_var PARAMS((const char *));

	static const char *boolean_varname PARAMS((int));
	static const char *string_varname PARAMS((int));

static char _rl_get_string_variable_value PARAMS((const char ));	static char _rl_get_string_variable_value PARAMS((const char ));
static int substring_member_of_array PARAMS((const char , const char const *));	static int substring_member_of_array PARAMS((const char , const char const *));

	static int _rl_get_keymap_by_name PARAMS((const char *));
	static int _rl_get_keymap_by_map PARAMS((Keymap));

static int currently_reading_init_file;	static int currently_reading_init_file;

/* used only in this file */	/* used only in this file */
static int _rl_prefer_visible_bell = 1;	static int _rl_prefer_visible_bell = 1;

	#define OP_EQ 1
	#define OP_NE 2
	#define OP_GT 3
	#define OP_GE 4
	#define OP_LT 5
	#define OP_LE 6

	#define OPSTART(c) ((c) == '=' \|\| (c) == '!' \|\| (c) == '<' \|\| (c) == '>')
	#define CMPSTART(c) ((c) == '=' \|\| (c) == '!')

/* **************************************************************** */	/* **************************************************************** */
/* */	/* */
/* Binding keys */	/* Binding keys */
Line 100 static int _rl_prefer_visible_bell = 1;	Line 123 static int _rl_prefer_visible_bell = 1;
Add NAME to the list of named functions. Make FUNCTION be the function	Add NAME to the list of named functions. Make FUNCTION be the function
that gets called. If KEY is not -1, then bind it. */	that gets called. If KEY is not -1, then bind it. */
int	int
rl_add_defun (name, function, key)	rl_add_defun (const char name, rl_command_func_t function, int key)
const char *name;
rl_command_func_t *function;
int key;
{	{
if (key != -1)	if (key != -1)
rl_bind_key (key, function);	rl_bind_key (key, function);
Line 113 rl_add_defun (name, function, key)	Line 133 rl_add_defun (name, function, key)

/* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */	/* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */
int	int
rl_bind_key (key, function)	rl_bind_key (int key, rl_command_func_t *function)
int key;
rl_command_func_t *function;
{	{
if (key < 0)	char keyseq[4];
	int l;

	if (key < 0 \|\| key > largest_char)
return (key);	return (key);

	/* Want to make this a multi-character key sequence with an ESC prefix */
if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)	if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
{	{
if (_rl_keymap[ESC].type == ISKMAP)	if (_rl_keymap[ESC].type == ISKMAP)
Line 132 rl_bind_key (key, function)	Line 154 rl_bind_key (key, function)
escmap[key].function = function;	escmap[key].function = function;
return (0);	return (0);
}	}
return (key);
	/* Otherwise, let's just let rl_generic_bind handle the key sequence.
	We start it off with ESC here and let the code below add the rest
	of the sequence. */
	keyseq[0] = ESC;
	l = 1;
	key = UNMETA(key);
	goto bind_keyseq;
}	}

_rl_keymap[key].type = ISFUNC;	/* If it's bound to a function or macro, just overwrite. Otherwise we have
_rl_keymap[key].function = function;	to treat it as a key sequence so rl_generic_bind handles shadow keymaps
	for us. If we are binding '\' or \C-@ (NUL) make sure to escape it so
	it makes it through the call to rl_translate_keyseq. */
	if (_rl_keymap[key].type != ISKMAP)
	{
	if (_rl_keymap[key].type == ISMACR)
	xfree ((char *)_rl_keymap[key].function);
	_rl_keymap[key].type = ISFUNC;
	_rl_keymap[key].function = function;
	}
	else
	{
	l = 0;
	bind_keyseq:
	if (key == '\\')
	{
	keyseq[l++] = '\\';
	keyseq[l++] = '\\';
	}
	else if (key == '\0')
	{
	keyseq[l++] = '\\';
	keyseq[l++] = '0';
	}
	else
	keyseq[l++] = key;
	keyseq[l] = '\0';
	rl_bind_keyseq (keyseq, function);
	}
rl_binding_keymap = _rl_keymap;	rl_binding_keymap = _rl_keymap;
return (0);	return (0);
}	}
Line 144 rl_bind_key (key, function)	Line 201 rl_bind_key (key, function)
/* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid	/* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid
KEY. */	KEY. */
int	int
rl_bind_key_in_map (key, function, map)	rl_bind_key_in_map (int key, rl_command_func_t *function, Keymap map)
int key;
rl_command_func_t *function;
Keymap map;
{	{
int result;	int result;
Keymap oldmap;	Keymap oldmap;
Line 160 rl_bind_key_in_map (key, function, map)	Line 214 rl_bind_key_in_map (key, function, map)
}	}

/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right	/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
now, this is always used to attempt to bind the arrow keys, hence the	now, this is always used to attempt to bind the arrow keys. */
check for rl_vi_movement_mode. */
int	int
rl_bind_key_if_unbound_in_map (key, default_func, kmap)	rl_bind_key_if_unbound_in_map (int key, rl_command_func_t *default_func, Keymap kmap)
int key;
rl_command_func_t *default_func;
Keymap kmap;
{	{
char keyseq[2];	char *keyseq;

keyseq[0] = (unsigned char)key;	keyseq = rl_untranslate_keyseq ((unsigned char)key);
keyseq[1] = '\0';
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap));	return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap));
}	}

int	int
rl_bind_key_if_unbound (key, default_func)	rl_bind_key_if_unbound (int key, rl_command_func_t *default_func)
int key;
rl_command_func_t *default_func;
{	{
char keyseq[2];	char *keyseq;

keyseq[0] = (unsigned char)key;	keyseq = rl_untranslate_keyseq ((unsigned char)key);
keyseq[1] = '\0';
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));	return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
}	}

/* Make KEY do nothing in the currently selected keymap.	/* Make KEY do nothing in the currently selected keymap.
Returns non-zero in case of error. */	Returns non-zero in case of error. This is not the same as self-insert;
	this makes it a dead key. */
int	int
rl_unbind_key (key)	rl_unbind_key (int key)
int key;
{	{
return (rl_bind_key (key, (rl_command_func_t *)NULL));	return (rl_bind_key (key, (rl_command_func_t *)NULL));
}	}

/* Make KEY do nothing in MAP.	/* Make KEY do nothing in MAP. Returns non-zero in case of error. */
Returns non-zero in case of error. */
int	int
rl_unbind_key_in_map (key, map)	rl_unbind_key_in_map (int key, Keymap map)
int key;
Keymap map;
{	{
return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));	return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));
}	}

/* Unbind all keys bound to FUNCTION in MAP. */	/* Unbind all keys bound to FUNCTION in MAP. */
int	int
rl_unbind_function_in_map (func, map)	rl_unbind_function_in_map (rl_command_func_t *func, Keymap map)
rl_command_func_t *func;
Keymap map;
{	{
register int i, rval;	register int i, rval;

Line 221 rl_unbind_function_in_map (func, map)	Line 262 rl_unbind_function_in_map (func, map)
map[i].function = (rl_command_func_t *)NULL;	map[i].function = (rl_command_func_t *)NULL;
rval = 1;	rval = 1;
}	}
	else if (map[i].type == ISKMAP) /* TAG:readline-8.1 */
	{
	int r;
	r = rl_unbind_function_in_map (func, FUNCTION_TO_KEYMAP (map, i));
	if (r == 1)
	rval = 1;
	}
}	}
return rval;	return rval;
}	}

	/* Unbind all keys bound to COMMAND, which is a bindable command name, in MAP */
int	int
rl_unbind_command_in_map (command, map)	rl_unbind_command_in_map (const char *command, Keymap map)
const char *command;
Keymap map;
{	{
rl_command_func_t *func;	rl_command_func_t *func;

Line 242 rl_unbind_command_in_map (command, map)	Line 289 rl_unbind_command_in_map (command, map)
FUNCTION, starting in the current keymap. This makes new	FUNCTION, starting in the current keymap. This makes new
keymaps as necessary. */	keymaps as necessary. */
int	int
rl_bind_keyseq (keyseq, function)	rl_bind_keyseq (const char keyseq, rl_command_func_t function)
const char *keyseq;
rl_command_func_t *function;
{	{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));	return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));
}	}
Line 253 rl_bind_keyseq (keyseq, function)	Line 298 rl_bind_keyseq (keyseq, function)
FUNCTION. This makes new keymaps as necessary. The initial	FUNCTION. This makes new keymaps as necessary. The initial
place to do bindings is in MAP. */	place to do bindings is in MAP. */
int	int
rl_bind_keyseq_in_map (keyseq, function, map)	rl_bind_keyseq_in_map (const char keyseq, rl_command_func_t function, Keymap map)
const char *keyseq;
rl_command_func_t *function;
Keymap map;
{	{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));	return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}	}

/* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */	/* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
int	int
rl_set_key (keyseq, function, map)	rl_set_key (const char keyseq, rl_command_func_t function, Keymap map)
const char *keyseq;
rl_command_func_t *function;
Keymap map;
{	{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));	return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}	}
Line 275 rl_set_key (keyseq, function, map)	Line 314 rl_set_key (keyseq, function, map)
now, this is always used to attempt to bind the arrow keys, hence the	now, this is always used to attempt to bind the arrow keys, hence the
check for rl_vi_movement_mode. */	check for rl_vi_movement_mode. */
int	int
rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap)	rl_bind_keyseq_if_unbound_in_map (const char keyseq, rl_command_func_t default_func, Keymap kmap)
const char *keyseq;
rl_command_func_t *default_func;
Keymap kmap;
{	{
rl_command_func_t *func;	rl_command_func_t *func;
	char *keys;
	int keys_len;

if (keyseq)	if (keyseq)
{	{
func = rl_function_of_keyseq (keyseq, kmap, (int *)NULL);	/* Handle key sequences that require translations and `raw' ones that
	don't. This might be a problem with backslashes. */
	keys = (char )xmalloc (1 + (2 strlen (keyseq)));
	if (rl_translate_keyseq (keyseq, keys, &keys_len))
	{
	xfree (keys);
	return -1;
	}
	func = rl_function_of_keyseq_len (keys, keys_len, kmap, (int *)NULL);
	xfree (keys);
#if defined (VI_MODE)	#if defined (VI_MODE)
if (!func \|\| func == rl_do_lowercase_version \|\| func == rl_vi_movement_mode)	if (!func \|\| func == rl_do_lowercase_version \|\| func == rl_vi_movement_mode)
#else	#else
Line 298 rl_bind_keyseq_if_unbound_in_map (keyseq, default_func	Line 345 rl_bind_keyseq_if_unbound_in_map (keyseq, default_func
}	}

int	int
rl_bind_keyseq_if_unbound (keyseq, default_func)	rl_bind_keyseq_if_unbound (const char keyseq, rl_command_func_t default_func)
const char *keyseq;
rl_command_func_t *default_func;
{	{
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));	return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
}	}
Line 309 rl_bind_keyseq_if_unbound (keyseq, default_func)	Line 354 rl_bind_keyseq_if_unbound (keyseq, default_func)
the string of characters MACRO. This makes new keymaps as	the string of characters MACRO. This makes new keymaps as
necessary. The initial place to do bindings is in MAP. */	necessary. The initial place to do bindings is in MAP. */
int	int
rl_macro_bind (keyseq, macro, map)	rl_macro_bind (const char keyseq, const char macro, Keymap map)
const char keyseq, macro;
Keymap map;
{	{
char *macro_keys;	char *macro_keys;
int macro_keys_len;	int macro_keys_len;
Line 333 rl_macro_bind (keyseq, macro, map)	Line 376 rl_macro_bind (keyseq, macro, map)
a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps	a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps
as necessary. The initial place to do bindings is in MAP. */	as necessary. The initial place to do bindings is in MAP. */
int	int
rl_generic_bind (type, keyseq, data, map)	rl_generic_bind (int type, const char keyseq, char data, Keymap map)
int type;
const char *keyseq;
char *data;
Keymap map;
{	{
char *keys;	char *keys;
int keys_len;	int keys_len, prevkey, ic;
register int i;	register int i;
KEYMAP_ENTRY k;	KEYMAP_ENTRY k;
	Keymap prevmap;

k.function = 0;	k.function = 0;

Line 365 rl_generic_bind (type, keyseq, data, map)	Line 405 rl_generic_bind (type, keyseq, data, map)
return -1;	return -1;
}	}

	prevmap = map;
	prevkey = keys[0];

/* Bind keys, making new keymaps as necessary. */	/* Bind keys, making new keymaps as necessary. */
for (i = 0; i < keys_len; i++)	for (i = 0; i < keys_len; i++)
{	{
unsigned char uc = keys[i];	unsigned char uc = keys[i];
int ic;

	if (i > 0)
	prevkey = ic;

ic = uc;	ic = uc;
if (ic < 0 \|\| ic >= KEYMAP_SIZE)	if (ic < 0 \|\| ic >= KEYMAP_SIZE)
{	{
Line 378 rl_generic_bind (type, keyseq, data, map)	Line 423 rl_generic_bind (type, keyseq, data, map)
return -1;	return -1;
}	}

	/* We now rely on rl_translate_keyseq to do this conversion, so this
	check is superfluous. */
	#if 0
if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)	if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
{	{
ic = UNMETA (ic);	ic = UNMETA (ic);
if (map[ESC].type == ISKMAP)	if (map[ESC].type == ISKMAP)
map = FUNCTION_TO_KEYMAP (map, ESC);	{
	prevmap = map;
	map = FUNCTION_TO_KEYMAP (map, ESC);
	}
}	}
	#endif

if ((i + 1) < keys_len)	if ((i + 1) < keys_len)
{	{
Line 401 rl_generic_bind (type, keyseq, data, map)	Line 453 rl_generic_bind (type, keyseq, data, map)
map[ic].type = ISKMAP;	map[ic].type = ISKMAP;
map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());	map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
}	}
	prevmap = map;
map = FUNCTION_TO_KEYMAP (map, ic);	map = FUNCTION_TO_KEYMAP (map, ic);
/* The dispatch code will return this function if no matching	/* The dispatch code will return this function if no matching
key sequence is found in the keymap. This (with a little	key sequence is found in the keymap. This (with a little
Line 416 rl_generic_bind (type, keyseq, data, map)	Line 469 rl_generic_bind (type, keyseq, data, map)
}	}
else	else
{	{
if (map[ic].type == ISMACR)	if (map[ic].type == ISKMAP)
xfree ((char *)map[ic].function);
else if (map[ic].type == ISKMAP)
{	{
	prevmap = map;
map = FUNCTION_TO_KEYMAP (map, ic);	map = FUNCTION_TO_KEYMAP (map, ic);
ic = ANYOTHERKEY;	ic = ANYOTHERKEY;
/* If we're trying to override a keymap with a null function	/* If we're trying to override a keymap with a null function
Line 430 rl_generic_bind (type, keyseq, data, map)	Line 482 rl_generic_bind (type, keyseq, data, map)
if (type == ISFUNC && data == 0)	if (type == ISFUNC && data == 0)
data = (char *)_rl_null_function;	data = (char *)_rl_null_function;
}	}
	if (map[ic].type == ISMACR)
	xfree ((char *)map[ic].function);

map[ic].function = KEYMAP_TO_FUNCTION (data);	map[ic].function = KEYMAP_TO_FUNCTION (data);
map[ic].type = type;	map[ic].type = type;
}	}

rl_binding_keymap = map;	rl_binding_keymap = map;

}	}

	/* If we unbound a key (type == ISFUNC, data == 0), and the prev keymap
	points to the keymap where we unbound the key (sanity check), and the
	current binding keymap is empty (rl_empty_keymap() returns non-zero),
	and the binding keymap has ANYOTHERKEY set with type == ISFUNC
	(overridden function), delete the now-empty keymap, take the previously-
	overridden function and remove the override. */
	/* Right now, this only works one level back. */
	if (type == ISFUNC && data == 0 &&
	prevmap[prevkey].type == ISKMAP &&
	(FUNCTION_TO_KEYMAP(prevmap, prevkey) == rl_binding_keymap) &&
	rl_binding_keymap[ANYOTHERKEY].type == ISFUNC &&
	rl_empty_keymap (rl_binding_keymap))
	{
	prevmap[prevkey].type = rl_binding_keymap[ANYOTHERKEY].type;
	prevmap[prevkey].function = rl_binding_keymap[ANYOTHERKEY].function;
	rl_discard_keymap (rl_binding_keymap);
	rl_binding_keymap = prevmap;
	}

xfree (keys);	xfree (keys);
return 0;	return 0;
}	}
Line 445 rl_generic_bind (type, keyseq, data, map)	Line 520 rl_generic_bind (type, keyseq, data, map)
an array of characters. LEN gets the final length of ARRAY. Return	an array of characters. LEN gets the final length of ARRAY. Return
non-zero if there was an error parsing SEQ. */	non-zero if there was an error parsing SEQ. */
int	int
rl_translate_keyseq (seq, array, len)	rl_translate_keyseq (const char seq, char array, int *len)
const char *seq;
char *array;
int *len;
{	{
register int i, c, l, temp;	register int i, l, temp;
	int has_control, has_meta;
	unsigned char c;

for (i = l = 0; c = seq[i]; i++)	has_control = 0;
	has_meta = 0;

	/* When there are incomplete prefixes \C- or \M- (has_control \|\| has_meta)
	without base character at the end of SEQ, they are processed as the
	prefixes for '\0'.
	*/
	for (i = l = 0; (c = seq[i]) \|\| has_control \|\| has_meta; i++)
{	{
if (c == '\\')	/* Only backslashes followed by a non-null character are handled
	specially. Trailing backslash (backslash followed by '\0') is
	processed as a normal character.
	*/
	if (c == '\\' && seq[i + 1] != '\0')
{	{
c = seq[++i];	c = seq[++i];

if (c == 0)
break;

/* Handle \C- and \M- prefixes. */	/* Handle \C- and \M- prefixes. */
if ((c == 'C' \|\| c == 'M') && seq[i + 1] == '-')	if (c == 'C' && seq[i + 1] == '-')
{	{
/* Handle special case of backwards define. */	i++;
if (strncmp (&seq[i], "C-\\M-", 5) == 0)	has_control = 1;
{
array[l++] = ESC; /* ESC is meta-prefix */
i += 5;
array[l++] = CTRL (_rl_to_upper (seq[i]));
if (seq[i] == '\0')
i--;
}
else if (c == 'M')
{
i++; /* seq[i] == '-' */
/* XXX - obey convert-meta setting */
if (_rl_convert_meta_chars_to_ascii && _rl_keymap[ESC].type == ISKMAP)
array[l++] = ESC; /* ESC is meta-prefix */
else if (seq[i+1] == '\\' && seq[i+2] == 'C' && seq[i+3] == '-')
{
i += 4;
temp = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
array[l++] = META (temp);
}
else
{
/* This doesn't yet handle things like \M-\a, which may
or may not have any reasonable meaning. You're
probably better off using straight octal or hex. */
i++;
array[l++] = META (seq[i]);
}
}
else if (c == 'C')
{
i += 2;
/* Special hack for C-?... */
array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
}
continue;	continue;
	}
	else if (c == 'M' && seq[i + 1] == '-')
	{
	i++;
	has_meta = 1;
	continue;
}	}

/* Translate other backslash-escaped characters. These are the	/* Translate other backslash-escaped characters. These are the
Line 510 rl_translate_keyseq (seq, array, len)	Line 564 rl_translate_keyseq (seq, array, len)
switch (c)	switch (c)
{	{
case 'a':	case 'a':
array[l++] = '\007';	c = '\007';
break;	break;
case 'b':	case 'b':
array[l++] = '\b';	c = '\b';
break;	break;
case 'd':	case 'd':
array[l++] = RUBOUT; /* readline-specific */	c = RUBOUT; /* readline-specific */
break;	break;
case 'e':	case 'e':
array[l++] = ESC;	c = ESC;
break;	break;
case 'f':	case 'f':
array[l++] = '\f';	c = '\f';
break;	break;
case 'n':	case 'n':
array[l++] = NEWLINE;	c = NEWLINE;
break;	break;
case 'r':	case 'r':
array[l++] = RETURN;	c = RETURN;
break;	break;
case 't':	case 't':
array[l++] = TAB;	c = TAB;
break;	break;
case 'v':	case 'v':
array[l++] = 0x0B;	c = 0x0B;
break;	break;
case '\\':	case '\\':
array[l++] = '\\';	c = '\\';
break;	break;
case '0': case '1': case '2': case '3':	case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':	case '4': case '5': case '6': case '7':
i++;	i++;
for (temp = 2, c -= '0'; ISOCTAL (seq[i]) && temp--; i++)	for (temp = 2, c -= '0'; ISOCTAL ((unsigned char)seq[i]) && temp--; i++)
c = (c * 8) + OCTVALUE (seq[i]);	c = (c * 8) + OCTVALUE (seq[i]);
i--; /* auto-increment in for loop */	i--; /* auto-increment in for loop */
array[l++] = c & largest_char;	c &= largest_char;
break;	break;
case 'x':	case 'x':
i++;	i++;
Line 554 rl_translate_keyseq (seq, array, len)	Line 608 rl_translate_keyseq (seq, array, len)
if (temp == 2)	if (temp == 2)
c = 'x';	c = 'x';
i--; /* auto-increment in for loop */	i--; /* auto-increment in for loop */
array[l++] = c & largest_char;	c &= largest_char;
break;	break;
default: /* backslashes before non-special chars just add the char */	default: /* backslashes before non-special chars just add the char */
array[l++] = c;	c &= largest_char;
break; /* the backslash is stripped */	break; /* the backslash is stripped */
}	}
continue;
}	}

array[l++] = c;	/* Process \C- and \M- flags */
	if (has_control)
	{
	/* Special treatment for C-? */
	c = (c == '?') ? RUBOUT : CTRL (_rl_to_upper (c));
	has_control = 0;
	}
	if (has_meta)
	{
	c = META (c);
	has_meta = 0;
	}

	/* If convert-meta is turned on, convert a meta char to a key sequence */
	if (META_CHAR (c) && _rl_convert_meta_chars_to_ascii)
	{
	array[l++] = ESC; /* ESC is meta-prefix */
	array[l++] = UNMETA (c);
	}
	else
	array[l++] = (c);

	/* Null characters may be processed for incomplete prefixes at the end of
	sequence */
	if (seq[i] == '\0')
	break;
}	}

*len = l;	*len = l;
Line 572 rl_translate_keyseq (seq, array, len)	Line 650 rl_translate_keyseq (seq, array, len)
}	}

static int	static int
_rl_isescape (c)	_rl_isescape (int c)
int c;
{	{
switch (c)	switch (c)
{	{
Line 589 _rl_isescape (c)	Line 666 _rl_isescape (c)
}	}

static int	static int
_rl_escchar (c)	_rl_escchar (int c)
int c;
{	{
switch (c)	switch (c)
{	{
Line 606 _rl_escchar (c)	Line 682 _rl_escchar (c)
}	}

char *	char *
rl_untranslate_keyseq (seq)	rl_untranslate_keyseq (int seq)
int seq;
{	{
static char kseq[16];	static char kseq[16];
int i, c;	int i, c;
Line 657 rl_untranslate_keyseq (seq)	Line 732 rl_untranslate_keyseq (seq)
}	}

char *	char *
_rl_untranslate_macro_value (seq, use_escapes)	_rl_untranslate_macro_value (char *seq, int use_escapes)
char *seq;
int use_escapes;
{	{
char ret, r, *s;	char ret, r, *s;
int c;	int c;
Line 716 _rl_untranslate_macro_value (seq, use_escapes)	Line 789 _rl_untranslate_macro_value (seq, use_escapes)

/* Return a pointer to the function that STRING represents.	/* Return a pointer to the function that STRING represents.
If STRING doesn't have a matching function, then a NULL pointer	If STRING doesn't have a matching function, then a NULL pointer
is returned. */	is returned. The string match is case-insensitive. */
rl_command_func_t *	rl_command_func_t *
rl_named_function (string)	rl_named_function (const char *string)
const char *string;
{	{
register int i;	register int i;

Line 736 rl_named_function (string)	Line 808 rl_named_function (string)
used. TYPE, if non-NULL, is a pointer to an int which will receive the	used. TYPE, if non-NULL, is a pointer to an int which will receive the
type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),	type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),
or ISMACR (macro). */	or ISMACR (macro). */
rl_command_func_t *	static rl_command_func_t *
rl_function_of_keyseq (keyseq, map, type)	_rl_function_of_keyseq_internal (const char keyseq, size_t len, Keymap map, int type)
const char *keyseq;
Keymap map;
int *type;
{	{
register int i;	register int i;

if (map == 0)	if (map == 0)
map = _rl_keymap;	map = _rl_keymap;

for (i = 0; keyseq && keyseq[i]; i++)	for (i = 0; keyseq && i < len; i++)
{	{
unsigned char ic = keyseq[i];	unsigned char ic = keyseq[i];

Line 773 rl_function_of_keyseq (keyseq, map, type)	Line 842 rl_function_of_keyseq (keyseq, map, type)
{	{
/* If this is the last key in the key sequence, return the	/* If this is the last key in the key sequence, return the
map. */	map. */
if (keyseq[i + 1] == '\0')	if (i + 1 == len)
{	{
if (type)	if (type)
*type = ISKMAP;	*type = ISKMAP;
Line 786 rl_function_of_keyseq (keyseq, map, type)	Line 855 rl_function_of_keyseq (keyseq, map, type)
/* If we're not at the end of the key sequence, and the current key	/* If we're not at the end of the key sequence, and the current key
is bound to something other than a keymap, then the entire key	is bound to something other than a keymap, then the entire key
sequence is not bound. */	sequence is not bound. */
else if (map[ic].type != ISKMAP && keyseq[i+1])	else if (map[ic].type != ISKMAP && i+1 < len)
return ((rl_command_func_t *)NULL);	return ((rl_command_func_t *)NULL);
else /* map[ic].type != ISKMAP && keyseq[i+1] == 0 */	else /* map[ic].type != ISKMAP && i+1 == len */
{	{
if (type)	if (type)
*type = map[ic].type;	*type = map[ic].type;
Line 799 rl_function_of_keyseq (keyseq, map, type)	Line 868 rl_function_of_keyseq (keyseq, map, type)
return ((rl_command_func_t *) NULL);	return ((rl_command_func_t *) NULL);
}	}

	rl_command_func_t *
	rl_function_of_keyseq (const char keyseq, Keymap map, int type)
	{
	return _rl_function_of_keyseq_internal (keyseq, strlen (keyseq), map, type);
	}

	rl_command_func_t *
	rl_function_of_keyseq_len (const char keyseq, size_t len, Keymap map, int type)
	{
	return _rl_function_of_keyseq_internal (keyseq, len, map, type);
	}

/* The last key bindings file read. */	/* The last key bindings file read. */
static char last_readline_init_file = (char )NULL;	static char last_readline_init_file = (char )NULL;

Line 811 static int current_readline_init_lineno;	Line 892 static int current_readline_init_lineno;
The size of the buffer is returned in *SIZEP. Returns NULL if any	The size of the buffer is returned in *SIZEP. Returns NULL if any
errors were encountered. */	errors were encountered. */
static char *	static char *
_rl_read_file (filename, sizep)	_rl_read_file (char filename, size_t sizep)
char *filename;
size_t *sizep;
{	{
struct stat finfo;	struct stat finfo;
size_t file_size;	size_t file_size;
char *buffer;	char *buffer;
int i, file;	int i, file;

if ((stat (filename, &finfo) < 0) \|\| (file = open (filename, O_RDONLY, 0666)) < 0)	file = -1;
return ((char *)NULL);	if (((file = open (filename, O_RDONLY, 0666)) < 0) \|\| (fstat (file, &finfo) < 0))
	{
	if (file >= 0)
	close (file);
	return ((char *)NULL);
	}

file_size = (size_t)finfo.st_size;	file_size = (size_t)finfo.st_size;

Line 858 _rl_read_file (filename, sizep)	Line 942 _rl_read_file (filename, sizep)

/* Re-read the current keybindings file. */	/* Re-read the current keybindings file. */
int	int
rl_re_read_init_file (count, ignore)	rl_re_read_init_file (int count, int ignore)
int count, ignore;
{	{
int r;	int r;
r = rl_read_init_file ((const char *)NULL);	r = rl_read_init_file ((const char *)NULL);
Line 876 rl_re_read_init_file (count, ignore)	Line 959 rl_re_read_init_file (count, ignore)
If the file existed and could be opened and read, 0 is returned,	If the file existed and could be opened and read, 0 is returned,
otherwise errno is returned. */	otherwise errno is returned. */
int	int
rl_read_init_file (filename)	rl_read_init_file (const char *filename)
const char *filename;
{	{
/* Default the filename. */	/* Default the filename. */
if (filename == 0)	if (filename == 0)
Line 902 rl_read_init_file (filename)	Line 984 rl_read_init_file (filename)
}	}

static int	static int
_rl_read_init_file (filename, include_level)	_rl_read_init_file (const char *filename, int include_level)
const char *filename;
int include_level;
{	{
register int i;	register int i;
char buffer, openname, line, end;	char buffer, openname, line, end;
Line 970 _rl_read_init_file (filename, include_level)	Line 1050 _rl_read_init_file (filename, include_level)
}	}

static void	static void
_rl_init_file_error (msg)	#if defined (PREFER_STDARG)
const char *msg;	_rl_init_file_error (const char *format, ...)
	#else
	_rl_init_file_error (va_alist)
	va_dcl
	#endif
{	{
	va_list args;
	#if defined (PREFER_VARARGS)
	char *format;
	#endif

	#if defined (PREFER_STDARG)
	va_start (args, format);
	#else
	va_start (args);
	format = va_arg (args, char *);
	#endif

	fprintf (stderr, "readline: ");
if (currently_reading_init_file)	if (currently_reading_init_file)
_rl_errmsg ("%s: line %d: %s\n", current_readline_init_file,	fprintf (stderr, "%s: line %d: ", current_readline_init_file,
current_readline_init_lineno, msg);	current_readline_init_lineno);
else
_rl_errmsg ("%s", msg);	vfprintf (stderr, format, args);
	fprintf (stderr, "\n");
	fflush (stderr);

	va_end (args);
}	}

/* **************************************************************** */	/* **************************************************************** */
/* */	/* */
	/* Parser Helper Functions */
	/* */
	/* **************************************************************** */

	static int
	parse_comparison_op (s, indp)
	const char *s;
	int *indp;
	{
	int i, peekc, op;

	if (OPSTART (s[*indp]) == 0)
	return -1;
	i = *indp;
	peekc = s[i] ? s[i+1] : 0;
	op = -1;

	if (s[i] == '=')
	{
	op = OP_EQ;
	if (peekc == '=')
	i++;
	i++;
	}
	else if (s[i] == '!' && peekc == '=')
	{
	op = OP_NE;
	i += 2;
	}
	else if (s[i] == '<' && peekc == '=')
	{
	op = OP_LE;
	i += 2;
	}
	else if (s[i] == '>' && peekc == '=')
	{
	op = OP_GE;
	i += 2;
	}
	else if (s[i] == '<')
	{
	op = OP_LT;
	i += 1;
	}
	else if (s[i] == '>')
	{
	op = OP_GT;
	i += 1;
	}

	*indp = i;
	return op;
	}

	/* **************************************************************** */
	/* */
/* Parser Directives */	/* Parser Directives */
/* */	/* */
/* **************************************************************** */	/* **************************************************************** */
Line 1010 static int if_stack_size;	Line 1167 static int if_stack_size;
/* Push _rl_parsing_conditionalized_out, and set parser state based	/* Push _rl_parsing_conditionalized_out, and set parser state based
on ARGS. */	on ARGS. */
static int	static int
parser_if (args)	parser_if (char *args)
char *args;
{	{
register int i;	int i, llen, boolvar, strvar;

	boolvar = strvar = -1;

/* Push parser state. */	/* Push parser state. */
if (if_stack_depth + 1 >= if_stack_size)	if (if_stack_depth + 1 >= if_stack_size)
{	{
Line 1030 parser_if (args)	Line 1188 parser_if (args)
if (_rl_parsing_conditionalized_out)	if (_rl_parsing_conditionalized_out)
return 0;	return 0;

	llen = strlen (args);

/* Isolate first argument. */	/* Isolate first argument. */
for (i = 0; args[i] && !whitespace (args[i]); i++);	for (i = 0; args[i] && !whitespace (args[i]); i++);

Line 1072 parser_if (args)	Line 1232 parser_if (args)
_rl_parsing_conditionalized_out = mode != rl_editing_mode;	_rl_parsing_conditionalized_out = mode != rl_editing_mode;
}	}
#endif /* VI_MODE */	#endif /* VI_MODE */
	else if (_rl_strnicmp (args, "version", 7) == 0)
	{
	int rlversion, versionarg, op, previ, major, minor;

	_rl_parsing_conditionalized_out = 1;
	rlversion = RL_VERSION_MAJOR*10 + RL_VERSION_MINOR;
	/* if "version" is separated from the operator by whitespace, or the
	operand is separated from the operator by whitespace, restore it.
	We're more liberal with allowed whitespace for this variable. */
	if (i > 0 && i <= llen && args[i-1] == '\0')
	args[i-1] = ' ';
	args[llen] = '\0'; /* just in case */
	for (i = 7; whitespace (args[i]); i++)
	;
	if (OPSTART(args[i]) == 0)
	{
	_rl_init_file_error ("comparison operator expected, found `%s'", args[i] ? args + i : "end-of-line");
	return 0;
	}
	previ = i;
	op = parse_comparison_op (args, &i);
	if (op <= 0)
	{
	_rl_init_file_error ("comparison operator expected, found `%s'", args+previ);
	return 0;
	}
	for ( ; args[i] && whitespace (args[i]); i++)
	;
	if (args[i] == 0 \|\| _rl_digit_p (args[i]) == 0)
	{
	_rl_init_file_error ("numeric argument expected, found `%s'", args+i);
	return 0;
	}
	major = minor = 0;
	previ = i;
	for ( ; args[i] && _rl_digit_p (args[i]); i++)
	major = major*10 + _rl_digit_value (args[i]);
	if (args[i] == '.')
	{
	if (args[i + 1] && _rl_digit_p (args [i + 1]) == 0)
	{
	_rl_init_file_error ("numeric argument expected, found `%s'", args+previ);
	return 0;
	}
	for (++i; args[i] && _rl_digit_p (args[i]); i++)
	minor = minor*10 + _rl_digit_value (args[i]);
	}
	/* optional - check for trailing garbage on the line, allow whitespace
	and a trailing comment */
	previ = i;
	for ( ; args[i] && whitespace (args[i]); i++)
	;
	if (args[i] && args[i] != '#')
	{
	_rl_init_file_error ("trailing garbage on line: `%s'", args+previ);
	return 0;
	}
	versionarg = major*10 + minor;

	switch (op)
	{
	case OP_EQ:
	_rl_parsing_conditionalized_out = rlversion == versionarg;
	break;
	case OP_NE:
	_rl_parsing_conditionalized_out = rlversion != versionarg;
	break;
	case OP_GT:
	_rl_parsing_conditionalized_out = rlversion > versionarg;
	break;
	case OP_GE:
	_rl_parsing_conditionalized_out = rlversion >= versionarg;
	break;
	case OP_LT:
	_rl_parsing_conditionalized_out = rlversion < versionarg;
	break;
	case OP_LE:
	_rl_parsing_conditionalized_out = rlversion <= versionarg;
	break;
	}
	}
/* Check to see if the first word in ARGS is the same as the	/* Check to see if the first word in ARGS is the same as the
value stored in rl_readline_name. */	value stored in rl_readline_name. */
else if (_rl_stricmp (args, rl_readline_name) == 0)	else if (_rl_stricmp (args, rl_readline_name) == 0)
_rl_parsing_conditionalized_out = 0;	_rl_parsing_conditionalized_out = 0;
	else if ((boolvar = find_boolean_var (args)) >= 0 \|\| (strvar = find_string_var (args)) >= 0)
	{
	int op, previ;
	size_t vlen;
	const char *vname;
	char valuearg, vval, prevc;

	_rl_parsing_conditionalized_out = 1;
	vname = (boolvar >= 0) ? boolean_varname (boolvar) : string_varname (strvar);
	vlen = strlen (vname);
	if (i > 0 && i <= llen && args[i-1] == '\0')
	args[i-1] = ' ';
	args[llen] = '\0'; /* just in case */
	for (i = vlen; whitespace (args[i]); i++)
	;
	if (CMPSTART(args[i]) == 0)
	{
	_rl_init_file_error ("equality comparison operator expected, found `%s'", args[i] ? args + i : "end-of-line");
	return 0;
	}
	previ = i;
	op = parse_comparison_op (args, &i);
	if (op != OP_EQ && op != OP_NE)
	{
	_rl_init_file_error ("equality comparison operator expected, found `%s'", args+previ);
	return 0;
	}
	for ( ; args[i] && whitespace (args[i]); i++)
	;
	if (args[i] == 0)
	{
	_rl_init_file_error ("argument expected, found `%s'", args+i);
	return 0;
	}
	previ = i;
	valuearg = args + i;
	for ( ; args[i] && whitespace (args[i]) == 0; i++)
	;
	prevc = args[i];
	args[i] = '\0'; /* null-terminate valuearg */
	vval = rl_variable_value (vname);
	if (op == OP_EQ)
	_rl_parsing_conditionalized_out = _rl_stricmp (vval, valuearg) != 0;
	else if (op == OP_NE)
	_rl_parsing_conditionalized_out = _rl_stricmp (vval, valuearg) == 0;
	args[i] = prevc;
	}
else	else
_rl_parsing_conditionalized_out = 1;	_rl_parsing_conditionalized_out = 1;
return 0;	return 0;
Line 1083 parser_if (args)	Line 1371 parser_if (args)

/* Invert the current parser state if there is anything on the stack. */	/* Invert the current parser state if there is anything on the stack. */
static int	static int
parser_else (args)	parser_else (char *args)
char *args;
{	{
register int i;	register int i;

Line 1114 parser_else (args)	Line 1401 parser_else (args)
/* Terminate a conditional, popping the value of	/* Terminate a conditional, popping the value of
_rl_parsing_conditionalized_out from the stack. */	_rl_parsing_conditionalized_out from the stack. */
static int	static int
parser_endif (args)	parser_endif (char *args)
char *args;
{	{
if (if_stack_depth)	if (if_stack_depth)
_rl_parsing_conditionalized_out = if_stack[--if_stack_depth];	_rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
Line 1125 parser_endif (args)	Line 1411 parser_endif (args)
}	}

static int	static int
parser_include (args)	parser_include (char *args)
char *args;
{	{
const char *old_init_file;	const char *old_init_file;
char *e;	char *e;
Line 1166 static const struct {	Line 1451 static const struct {
/* Handle a parser directive. STATEMENT is the line of the directive	/* Handle a parser directive. STATEMENT is the line of the directive
without any leading `$'. */	without any leading `$'. */
static int	static int
handle_parser_directive (statement)	handle_parser_directive (char *statement)
char *statement;
{	{
register int i;	register int i;
char directive, args;	char directive, args;
Line 1197 handle_parser_directive (statement)	Line 1481 handle_parser_directive (statement)
}	}

/* display an error message about the unknown parser directive */	/* display an error message about the unknown parser directive */
_rl_init_file_error ("unknown parser directive");	_rl_init_file_error ("%s: unknown parser directive", directive);
return (1);	return (1);
}	}

/* Start at STRING[START] and look for DELIM. Return I where STRING[I] ==	/* Start at STRING[START] and look for DELIM. Return I where STRING[I] ==
DELIM or STRING[I] == 0. DELIM is usually a double quote. */	DELIM or STRING[I] == 0. DELIM is usually a double quote. */
static int	static int
_rl_skip_to_delim (string, start, delim)	_rl_skip_to_delim (char *string, int start, int delim)
char *string;
int start, delim;
{	{
int i, c, passc;	int i, c, passc;

Line 1238 _rl_skip_to_delim (string, start, delim)	Line 1520 _rl_skip_to_delim (string, start, delim)
a variable binding command looks like: set variable value.	a variable binding command looks like: set variable value.
A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */	A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
int	int
rl_parse_and_bind (string)	rl_parse_and_bind (char *string)
char *string;
{	{
char funname, kname;	char funname, kname;
register int c, i;	register int c, i;
int key, equivalency;	int key, equivalency, foundmod, foundsep;

while (string && whitespace (*string))	while (string && whitespace (*string))
string++;	string++;
Line 1273 rl_parse_and_bind (string)	Line 1554 rl_parse_and_bind (string)
/* If we didn't find a closing quote, abort the line. */	/* If we didn't find a closing quote, abort the line. */
if (string[i] == '\0')	if (string[i] == '\0')
{	{
_rl_init_file_error ("no closing `\"' in key binding");	_rl_init_file_error ("%s: no closing `\"' in key binding", string);
return 1;	return 1;
}	}
else	else
Line 1283 rl_parse_and_bind (string)	Line 1564 rl_parse_and_bind (string)
/* Advance to the colon (:) or whitespace which separates the two objects. */	/* Advance to the colon (:) or whitespace which separates the two objects. */
for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );	for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );

	if (i == 0)
	{
	_rl_init_file_error ("`%s': invalid key binding: missing key sequence", string);
	return 1;
	}

equivalency = (c == ':' && string[i + 1] == '=');	equivalency = (c == ':' && string[i + 1] == '=');

	foundsep = c != 0;

/* Mark the end of the command (or keyname). */	/* Mark the end of the command (or keyname). */
if (string[i])	if (string[i])
string[i++] = '\0';	string[i++] = '\0';
Line 1313 rl_parse_and_bind (string)	Line 1602 rl_parse_and_bind (string)
/* Strip trailing whitespace from values of boolean variables. */	/* Strip trailing whitespace from values of boolean variables. */
if (find_boolean_var (var) >= 0)	if (find_boolean_var (var) >= 0)
{	{
/* remove trailing whitespace */	/* just read a whitespace-delimited word or empty string */
remove_trailing:	for (e = value; e && whitespace (e) == 0; e++)
e = value + strlen (value) - 1;	;
while (e >= value && whitespace (*e))	if (e > value)
e--;	e = '\0'; / cut off everything trailing */
e++; /* skip back to whitespace or EOS */

if (*e && e >= value)
*e = '\0';
}	}
else if ((i = find_string_var (var)) >= 0)	else if ((i = find_string_var (var)) >= 0)
{	{
Line 1333 remove_trailing:	Line 1618 remove_trailing:
value++; /* skip past the quote */	value++; /* skip past the quote */
}	}
else	else
goto remove_trailing;	{
	/* remove trailing whitespace */
	e = value + strlen (value) - 1;
	while (e >= value && whitespace (*e))
	e--;
	e++; /* skip back to whitespace or EOS */

	if (*e && e >= value)
	*e = '\0';
	}
}	}
	else
	{
	/* avoid calling rl_variable_bind just to find this out */
	_rl_init_file_error ("%s: unknown variable name", var);
	return 1;
	}

rl_variable_bind (var, value);	rl_variable_bind (var, value);
return 0;	return 0;
}	}
Line 1359 remove_trailing:	Line 1659 remove_trailing:
i = _rl_skip_to_delim (string, i+1, *funname);	i = _rl_skip_to_delim (string, i+1, *funname);
if (string[i])	if (string[i])
i++;	i++;
	else
	{
	_rl_init_file_error ("`%s': missing closing quote for macro", funname);
	return 1;
	}
}	}

/* Advance to the end of the string. */	/* Advance to the end of the string. */
Line 1374 remove_trailing:	Line 1679 remove_trailing:
return 0;	return 0;
}	}

	if (foundsep == 0)
	{
	_rl_init_file_error ("%s: no key sequence terminator", string);
	return 1;
	}

/* If this is a new-style key-binding, then do the binding with	/* If this is a new-style key-binding, then do the binding with
rl_bind_keyseq (). Otherwise, let the older code deal with it. */	rl_bind_keyseq (). Otherwise, let the older code deal with it. */
if (*string == '"')	if (*string == '"')
Line 1430 remove_trailing:	Line 1741 remove_trailing:
key = glean_key_from_name (kname);	key = glean_key_from_name (kname);

/* Add in control and meta bits. */	/* Add in control and meta bits. */
	foundmod = 0;
if (substring_member_of_array (string, _rl_possible_control_prefixes))	if (substring_member_of_array (string, _rl_possible_control_prefixes))
key = CTRL (_rl_to_upper (key));	{
	key = CTRL (_rl_to_upper (key));
	foundmod = 1;
	}

if (substring_member_of_array (string, _rl_possible_meta_prefixes))	if (substring_member_of_array (string, _rl_possible_meta_prefixes))
key = META (key);	{
	key = META (key);
	foundmod = 1;
	}

	if (foundmod == 0 && kname != string)
	{
	_rl_init_file_error ("%s: unknown key modifier", string);
	return 1;
	}

/* Temporary. Handle old-style keyname with macro-binding. */	/* Temporary. Handle old-style keyname with macro-binding. */
if (funname == '\'' \|\| funname == '"')	if (funname == '\'' \|\| funname == '"')
{	{
Line 1461 remove_trailing:	Line 1785 remove_trailing:
#endif /* PREFIX_META_HACK */	#endif /* PREFIX_META_HACK */
else	else
rl_bind_key (key, rl_named_function (funname));	rl_bind_key (key, rl_named_function (funname));

return 0;	return 0;
}	}

Line 1479 static const struct {	Line 1804 static const struct {
{ "blink-matching-paren", &rl_blink_matching_paren, V_SPECIAL },	{ "blink-matching-paren", &rl_blink_matching_paren, V_SPECIAL },
{ "byte-oriented", &rl_byte_oriented, 0 },	{ "byte-oriented", &rl_byte_oriented, 0 },
#if defined (COLOR_SUPPORT)	#if defined (COLOR_SUPPORT)
	{ "colored-completion-prefix",&_rl_colored_completion_prefix, 0 },
{ "colored-stats", &_rl_colored_stats, 0 },	{ "colored-stats", &_rl_colored_stats, 0 },
#endif	#endif
{ "completion-ignore-case", &_rl_completion_case_fold, 0 },	{ "completion-ignore-case", &_rl_completion_case_fold, 0 },
Line 1486 static const struct {	Line 1812 static const struct {
{ "convert-meta", &_rl_convert_meta_chars_to_ascii, 0 },	{ "convert-meta", &_rl_convert_meta_chars_to_ascii, 0 },
{ "disable-completion", &rl_inhibit_completion, 0 },	{ "disable-completion", &rl_inhibit_completion, 0 },
{ "echo-control-characters", &_rl_echo_control_chars, 0 },	{ "echo-control-characters", &_rl_echo_control_chars, 0 },
	{ "enable-bracketed-paste", &_rl_enable_bracketed_paste, V_SPECIAL },
{ "enable-keypad", &_rl_enable_keypad, 0 },	{ "enable-keypad", &_rl_enable_keypad, 0 },
{ "enable-meta-key", &_rl_enable_meta, 0 },	{ "enable-meta-key", &_rl_enable_meta, 0 },
{ "expand-tilde", &rl_complete_with_tilde_expansion, 0 },	{ "expand-tilde", &rl_complete_with_tilde_expansion, 0 },
Line 1514 static const struct {	Line 1841 static const struct {
};	};

static int	static int
find_boolean_var (name)	find_boolean_var (const char *name)
const char *name;
{	{
register int i;	register int i;

Line 1525 find_boolean_var (name)	Line 1851 find_boolean_var (name)
return -1;	return -1;
}	}

	static const char *
	boolean_varname (int i)
	{
	return ((i >= 0) ? boolean_varlist[i].name : (char *)NULL);
	}

/* Hooks for handling special boolean variables, where a	/* Hooks for handling special boolean variables, where a
function needs to be called or another variable needs	function needs to be called or another variable needs
to be changed when they're changed. */	to be changed when they're changed. */
static void	static void
hack_special_boolean_var (i)	hack_special_boolean_var (int i)
int i;
{	{
const char *name;	const char *name;

Line 1547 hack_special_boolean_var (i)	Line 1878 hack_special_boolean_var (i)
}	}
else if (_rl_stricmp (name, "show-mode-in-prompt") == 0)	else if (_rl_stricmp (name, "show-mode-in-prompt") == 0)
_rl_reset_prompt ();	_rl_reset_prompt ();
	else if (_rl_stricmp (name, "enable-bracketed-paste") == 0)
	_rl_enable_active_region = _rl_enable_bracketed_paste;
}	}

typedef int _rl_sv_func_t PARAMS((const char *));	typedef int _rl_sv_func_t PARAMS((const char *));
Line 1569 static int sv_dispprefix PARAMS((const char *));	Line 1902 static int sv_dispprefix PARAMS((const char *));
static int sv_compquery PARAMS((const char *));	static int sv_compquery PARAMS((const char *));
static int sv_compwidth PARAMS((const char *));	static int sv_compwidth PARAMS((const char *));
static int sv_editmode PARAMS((const char *));	static int sv_editmode PARAMS((const char *));
	static int sv_emacs_modestr PARAMS((const char *));
static int sv_histsize PARAMS((const char *));	static int sv_histsize PARAMS((const char *));
static int sv_isrchterm PARAMS((const char *));	static int sv_isrchterm PARAMS((const char *));
static int sv_keymap PARAMS((const char *));	static int sv_keymap PARAMS((const char *));
static int sv_seqtimeout PARAMS((const char *));	static int sv_seqtimeout PARAMS((const char *));
	static int sv_viins_modestr PARAMS((const char *));
	static int sv_vicmd_modestr PARAMS((const char *));

static const struct {	static const struct {
const char * const name;	const char * const name;
Line 1585 static const struct {	Line 1921 static const struct {
{ "completion-prefix-display-length", V_INT, sv_dispprefix },	{ "completion-prefix-display-length", V_INT, sv_dispprefix },
{ "completion-query-items", V_INT, sv_compquery },	{ "completion-query-items", V_INT, sv_compquery },
{ "editing-mode", V_STRING, sv_editmode },	{ "editing-mode", V_STRING, sv_editmode },
	{ "emacs-mode-string", V_STRING, sv_emacs_modestr },
{ "history-size", V_INT, sv_histsize },	{ "history-size", V_INT, sv_histsize },
{ "isearch-terminators", V_STRING, sv_isrchterm },	{ "isearch-terminators", V_STRING, sv_isrchterm },
{ "keymap", V_STRING, sv_keymap },	{ "keymap", V_STRING, sv_keymap },
{ "keyseq-timeout", V_INT, sv_seqtimeout },	{ "keyseq-timeout", V_INT, sv_seqtimeout },
	{ "vi-cmd-mode-string", V_STRING, sv_vicmd_modestr },
	{ "vi-ins-mode-string", V_STRING, sv_viins_modestr },
{ (char )NULL, 0, (_rl_sv_func_t )0 }	{ (char )NULL, 0, (_rl_sv_func_t )0 }
};	};

static int	static int
find_string_var (name)	find_string_var (const char *name)
const char *name;
{	{
register int i;	register int i;

Line 1604 find_string_var (name)	Line 1942 find_string_var (name)
return -1;	return -1;
}	}

	static const char *
	string_varname (int i)
	{
	return ((i >= 0) ? string_varlist[i].name : (char *)NULL);
	}

/* A boolean value that can appear in a `set variable' command is true if	/* A boolean value that can appear in a `set variable' command is true if
the value is null or empty, `on' (case-insenstive), or "1". Any other	the value is null or empty, `on' (case-insensitive), or "1". All other
values result in 0 (false). */	values result in 0 (false). */
static int	static int
bool_to_int (value)	bool_to_int (const char *value)
const char *value;
{	{
return (value == 0 \|\| *value == '\0' \|\|	return (value == 0 \|\| *value == '\0' \|\|
(_rl_stricmp (value, "on") == 0) \|\|	(_rl_stricmp (value, "on") == 0) \|\|
Line 1617 bool_to_int (value)	Line 1960 bool_to_int (value)
}	}

char *	char *
rl_variable_value (name)	rl_variable_value (const char *name)
const char *name;
{	{
register int i;	register int i;

Line 1632 rl_variable_value (name)	Line 1974 rl_variable_value (name)
return (_rl_get_string_variable_value (string_varlist[i].name));	return (_rl_get_string_variable_value (string_varlist[i].name));

/* Unknown variable names return NULL. */	/* Unknown variable names return NULL. */
return 0;	return (char *)NULL;
}	}

int	int
rl_variable_bind (name, value)	rl_variable_bind (const char name, const char value)
const char name, value;
{	{
register int i;	register int i;
int v;	int v;
Line 1654 rl_variable_bind (name, value)	Line 1995 rl_variable_bind (name, value)

i = find_string_var (name);	i = find_string_var (name);

/* For the time being, unknown variable names or string names without a	/* For the time being, string names without a handler function are simply
handler function are simply ignored. */	ignored. */
if (i < 0 \|\| string_varlist[i].set_func == 0)	if (i < 0 \|\| string_varlist[i].set_func == 0)
return 0;	{
	if (i < 0)
	_rl_init_file_error ("%s: unknown variable name", name);
	return 0;
	}

v = (*string_varlist[i].set_func) (value);	v = (*string_varlist[i].set_func) (value);
	if (v != 0)
	_rl_init_file_error ("%s: could not set value to `%s'", name, value);
return v;	return v;
}	}

static int	static int
sv_editmode (value)	sv_editmode (const char *value)
const char *value;
{	{
if (_rl_strnicmp (value, "vi", 2) == 0)	if (_rl_strnicmp (value, "vi", 2) == 0)
{	{
Line 1685 sv_editmode (value)	Line 2031 sv_editmode (value)
}	}

static int	static int
sv_combegin (value)	sv_combegin (const char *value)
const char *value;
{	{
if (value && *value)	if (value && *value)
{	{
Line 1698 sv_combegin (value)	Line 2043 sv_combegin (value)
}	}

static int	static int
sv_dispprefix (value)	sv_dispprefix (const char *value)
const char *value;
{	{
int nval = 0;	int nval = 0;

Line 1714 sv_dispprefix (value)	Line 2058 sv_dispprefix (value)
}	}

static int	static int
sv_compquery (value)	sv_compquery (const char *value)
const char *value;
{	{
int nval = 100;	int nval = 100;

Line 1730 sv_compquery (value)	Line 2073 sv_compquery (value)
}	}

static int	static int
sv_compwidth (value)	sv_compwidth (const char *value)
const char *value;
{	{
int nval = -1;	int nval = -1;

Line 1743 sv_compwidth (value)	Line 2085 sv_compwidth (value)
}	}

static int	static int
sv_histsize (value)	sv_histsize (const char *value)
const char *value;
{	{
int nval;	int nval;

Line 1763 sv_histsize (value)	Line 2104 sv_histsize (value)
}	}

static int	static int
sv_keymap (value)	sv_keymap (const char *value)
const char *value;
{	{
Keymap kmap;	Keymap kmap;

Line 1778 sv_keymap (value)	Line 2118 sv_keymap (value)
}	}

static int	static int
sv_seqtimeout (value)	sv_seqtimeout (const char *value)
const char *value;
{	{
int nval;	int nval;

Line 1795 sv_seqtimeout (value)	Line 2134 sv_seqtimeout (value)
}	}

static int	static int
sv_bell_style (value)	sv_bell_style (const char *value)
const char *value;
{	{
if (value == 0 \|\| *value == '\0')	if (value == 0 \|\| *value == '\0')
_rl_bell_preference = AUDIBLE_BELL;	_rl_bell_preference = AUDIBLE_BELL;
Line 1812 sv_bell_style (value)	Line 2150 sv_bell_style (value)
}	}

static int	static int
sv_isrchterm (value)	sv_isrchterm (const char *value)
const char *value;
{	{
int beg, end, delim;	int beg, end, delim;
char *v;	char *v;
Line 1832 sv_isrchterm (value)	Line 2169 sv_isrchterm (value)
}	}
else	else
{	{
for (beg = end = 0; whitespace (v[end]) == 0; end++)	for (beg = end = 0; v[end] && whitespace (v[end]) == 0; end++)
;	;
}	}

Line 1846 sv_isrchterm (value)	Line 2183 sv_isrchterm (value)
xfree (v);	xfree (v);
return 0;	return 0;
}	}

	extern char *_rl_emacs_mode_str;

	static int
	sv_emacs_modestr (const char *value)
	{
	if (value && *value)
	{
	FREE (_rl_emacs_mode_str);
	_rl_emacs_mode_str = (char )xmalloc (2 strlen (value) + 1);
	rl_translate_keyseq (value, _rl_emacs_mode_str, &_rl_emacs_modestr_len);
	_rl_emacs_mode_str[_rl_emacs_modestr_len] = '\0';
	return 0;
	}
	else if (value)
	{
	FREE (_rl_emacs_mode_str);
	_rl_emacs_mode_str = (char *)xmalloc (1);
	_rl_emacs_mode_str[_rl_emacs_modestr_len = 0] = '\0';
	return 0;
	}
	else if (value == 0)
	{
	FREE (_rl_emacs_mode_str);
	_rl_emacs_mode_str = 0; /* prompt_modestr does the right thing */
	_rl_emacs_modestr_len = 0;
	return 0;
	}
	return 1;
	}

	static int
	sv_viins_modestr (const char *value)
	{
	if (value && *value)
	{
	FREE (_rl_vi_ins_mode_str);
	_rl_vi_ins_mode_str = (char )xmalloc (2 strlen (value) + 1);
	rl_translate_keyseq (value, _rl_vi_ins_mode_str, &_rl_vi_ins_modestr_len);
	_rl_vi_ins_mode_str[_rl_vi_ins_modestr_len] = '\0';
	return 0;
	}
	else if (value)
	{
	FREE (_rl_vi_ins_mode_str);
	_rl_vi_ins_mode_str = (char *)xmalloc (1);
	_rl_vi_ins_mode_str[_rl_vi_ins_modestr_len = 0] = '\0';
	return 0;
	}
	else if (value == 0)
	{
	FREE (_rl_vi_ins_mode_str);
	_rl_vi_ins_mode_str = 0; /* prompt_modestr does the right thing */
	_rl_vi_ins_modestr_len = 0;
	return 0;
	}
	return 1;
	}

	static int
	sv_vicmd_modestr (const char *value)
	{
	if (value && *value)
	{
	FREE (_rl_vi_cmd_mode_str);
	_rl_vi_cmd_mode_str = (char )xmalloc (2 strlen (value) + 1);
	rl_translate_keyseq (value, _rl_vi_cmd_mode_str, &_rl_vi_cmd_modestr_len);
	_rl_vi_cmd_mode_str[_rl_vi_cmd_modestr_len] = '\0';
	return 0;
	}
	else if (value)
	{
	FREE (_rl_vi_cmd_mode_str);
	_rl_vi_cmd_mode_str = (char *)xmalloc (1);
	_rl_vi_cmd_mode_str[_rl_vi_cmd_modestr_len = 0] = '\0';
	return 0;
	}
	else if (value == 0)
	{
	FREE (_rl_vi_cmd_mode_str);
	_rl_vi_cmd_mode_str = 0; /* prompt_modestr does the right thing */
	_rl_vi_cmd_modestr_len = 0;
	return 0;
	}
	return 1;
	}

/* Return the character which matches NAME.	/* Return the character which matches NAME.
For example, `Space' returns ' '. */	For example, `Space' returns ' '. */

Line 1871 static const assoc_list name_key_alist[] = {	Line 2294 static const assoc_list name_key_alist[] = {
};	};

static int	static int
glean_key_from_name (name)	glean_key_from_name (char *name)
char *name;
{	{
register int i;	register int i;

Line 1884 glean_key_from_name (name)	Line 2306 glean_key_from_name (name)
}	}

/* Auxiliary functions to manage keymaps. */	/* Auxiliary functions to manage keymaps. */
static const struct {	struct name_and_keymap {
const char * const name;	char *name;
Keymap map;	Keymap map;
} keymap_names[] = {	};

	static struct name_and_keymap builtin_keymap_names[] = {
{ "emacs", emacs_standard_keymap },	{ "emacs", emacs_standard_keymap },
{ "emacs-standard", emacs_standard_keymap },	{ "emacs-standard", emacs_standard_keymap },
{ "emacs-meta", emacs_meta_keymap },	{ "emacs-meta", emacs_meta_keymap },
Line 1901 static const struct {	Line 2325 static const struct {
{ (char *)0x0, (Keymap)0x0 }	{ (char *)0x0, (Keymap)0x0 }
};	};

Keymap	/* -1 for NULL entry */
rl_get_keymap_by_name (name)	#define NUM_BUILTIN_KEYMAPS (sizeof (builtin_keymap_names) / sizeof (builtin_keymap_names[0]) - 1)
const char *name;
	static struct name_and_keymap *keymap_names = builtin_keymap_names;

	static int
	_rl_get_keymap_by_name (const char *name)
{	{
register int i;	register int i;

for (i = 0; keymap_names[i].name; i++)	for (i = 0; keymap_names[i].name; i++)
if (_rl_stricmp (name, keymap_names[i].name) == 0)	if (_rl_stricmp (name, keymap_names[i].name) == 0)
return (keymap_names[i].map);	return (i);
return ((Keymap) NULL);	return -1;
}	}

char *	Keymap
rl_get_keymap_name (map)	rl_get_keymap_by_name (const char *name)
Keymap map;
{	{
	int i;

	i = _rl_get_keymap_by_name (name);
	return ((i >= 0) ? keymap_names[i].map : (Keymap) NULL);
	}

	static int
	_rl_get_keymap_by_map (Keymap map)
	{
register int i;	register int i;

for (i = 0; keymap_names[i].name; i++)	for (i = 0; keymap_names[i].name; i++)
if (map == keymap_names[i].map)	if (map == keymap_names[i].map)
return ((char *)keymap_names[i].name);	return (i);
return ((char *)NULL);	return -1;
}	}

	char *
	rl_get_keymap_name (Keymap map)
	{
	int i;

	i = _rl_get_keymap_by_map (map);
	return ((i >= 0) ? keymap_names[i].name : (char *)NULL);
	}

	int
	rl_set_keymap_name (const char *name, Keymap map)
	{
	int i, ni, mi;

	/* First check whether or not we're trying to rename a builtin keymap */
	mi = _rl_get_keymap_by_map (map);
	if (mi >= 0 && mi < NUM_BUILTIN_KEYMAPS)
	return -1;

	/* Then reject attempts to set one of the builtin names to a new map */
	ni = _rl_get_keymap_by_name (name);
	if (ni >= 0 && ni < NUM_BUILTIN_KEYMAPS)
	return -1;

	/* Renaming a keymap we already added */
	if (mi >= 0) /* XXX - could be >= NUM_BUILTIN_KEYMAPS */
	{
	xfree (keymap_names[mi].name);
	keymap_names[mi].name = savestring (name);
	return mi;
	}

	/* Associating new keymap with existing name */
	if (ni >= 0)
	{
	keymap_names[ni].map = map;
	return ni;
	}

	for (i = 0; keymap_names[i].name; i++)
	;

	if (keymap_names == builtin_keymap_names)
	{
	keymap_names = xmalloc ((i + 2) * sizeof (struct name_and_keymap));
	memcpy (keymap_names, builtin_keymap_names, i * sizeof (struct name_and_keymap));
	}
	else
	keymap_names = xrealloc (keymap_names, (i + 2) * sizeof (struct name_and_keymap));

	keymap_names[i].name = savestring (name);
	keymap_names[i].map = map;

	keymap_names[i+1].name = NULL;
	keymap_names[i+1].map = NULL;

	return i;
	}

void	void
rl_set_keymap (map)	rl_set_keymap (Keymap map)
Keymap map;
{	{
if (map)	if (map)
_rl_keymap = map;	_rl_keymap = map;
}	}

Keymap	Keymap
rl_get_keymap ()	rl_get_keymap (void)
{	{
return (_rl_keymap);	return (_rl_keymap);
}	}

void	void
rl_set_keymap_from_edit_mode ()	rl_set_keymap_from_edit_mode (void)
{	{
if (rl_editing_mode == emacs_mode)	if (rl_editing_mode == emacs_mode)
_rl_keymap = emacs_standard_keymap;	_rl_keymap = emacs_standard_keymap;
Line 1950 rl_set_keymap_from_edit_mode ()	Line 2445 rl_set_keymap_from_edit_mode ()
}	}

char *	char *
rl_get_keymap_name_from_edit_mode ()	rl_get_keymap_name_from_edit_mode (void)
{	{
if (rl_editing_mode == emacs_mode)	if (rl_editing_mode == emacs_mode)
return "emacs";	return "emacs";
Line 1975 rl_get_keymap_name_from_edit_mode ()	Line 2470 rl_get_keymap_name_from_edit_mode ()

/* Print the names of functions known to Readline. */	/* Print the names of functions known to Readline. */
void	void
rl_list_funmap_names ()	rl_list_funmap_names (void)
{	{
register int i;	register int i;
const char **funmap_names;	const char **funmap_names;
Line 1992 rl_list_funmap_names ()	Line 2487 rl_list_funmap_names ()
}	}

static char *	static char *
_rl_get_keyname (key)	_rl_get_keyname (int key)
int key;
{	{
char *keyname;	char *keyname;
int i, c;	int i, c;
Line 2068 _rl_get_keyname (key)	Line 2562 _rl_get_keyname (key)
/* Return a NULL terminated array of strings which represent the key	/* Return a NULL terminated array of strings which represent the key
sequences that are used to invoke FUNCTION in MAP. */	sequences that are used to invoke FUNCTION in MAP. */
char **	char **
rl_invoking_keyseqs_in_map (function, map)	rl_invoking_keyseqs_in_map (rl_command_func_t *function, Keymap map)
rl_command_func_t *function;
Keymap map;
{	{
register int key;	register int key;
char **result;	char **result;
Line 2137 rl_invoking_keyseqs_in_map (function, map)	Line 2629 rl_invoking_keyseqs_in_map (function, map)
else	else
sprintf (keyname, "\\e");	sprintf (keyname, "\\e");
}	}
else if (CTRL_CHAR (key))
sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
else if (key == RUBOUT)
sprintf (keyname, "\\C-?");
else if (key == '\\' \|\| key == '"')
{
keyname[0] = '\\';
keyname[1] = (char) key;
keyname[2] = '\0';
}
else	else
{	{
keyname[0] = (char) key;	int c = key, l = 0;
keyname[1] = '\0';	if (CTRL_CHAR (c) \|\| c == RUBOUT)
	{
	keyname[l++] = '\\';
	keyname[l++] = 'C';
	keyname[l++] = '-';
	c = (c == RUBOUT) ? '?' : _rl_to_lower (UNCTRL (c));
	}

	if (c == '\\' \|\| c == '"')
	keyname[l++] = '\\';

	keyname[l++] = (char) c;
	keyname[l++] = '\0';
}	}

strcat (keyname, seqs[i]);	strcat (keyname, seqs[i]);
Line 2177 rl_invoking_keyseqs_in_map (function, map)	Line 2671 rl_invoking_keyseqs_in_map (function, map)
/* Return a NULL terminated array of strings which represent the key	/* Return a NULL terminated array of strings which represent the key
sequences that can be used to invoke FUNCTION using the current keymap. */	sequences that can be used to invoke FUNCTION using the current keymap. */
char **	char **
rl_invoking_keyseqs (function)	rl_invoking_keyseqs (rl_command_func_t *function)
rl_command_func_t *function;
{	{
return (rl_invoking_keyseqs_in_map (function, _rl_keymap));	return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
}	}
Line 2187 rl_invoking_keyseqs (function)	Line 2680 rl_invoking_keyseqs (function)
PRINT_READABLY is non-zero, then print the output in such a way	PRINT_READABLY is non-zero, then print the output in such a way
that it can be read back in. */	that it can be read back in. */
void	void
rl_function_dumper (print_readably)	rl_function_dumper (int print_readably)
int print_readably;
{	{
register int i;	register int i;
const char **names;	const char **names;
Line 2259 rl_function_dumper (print_readably)	Line 2751 rl_function_dumper (print_readably)
rl_outstream. If an explicit argument is given, then print	rl_outstream. If an explicit argument is given, then print
the output in such a way that it can be read back in. */	the output in such a way that it can be read back in. */
int	int
rl_dump_functions (count, key)	rl_dump_functions (int count, int key)
int count, key;
{	{
if (rl_dispatching)	if (rl_dispatching)
fprintf (rl_outstream, "\r\n");	fprintf (rl_outstream, "\r\n");
Line 2270 rl_dump_functions (count, key)	Line 2761 rl_dump_functions (count, key)
}	}

static void	static void
_rl_macro_dumper_internal (print_readably, map, prefix)	_rl_macro_dumper_internal (int print_readably, Keymap map, char *prefix)
int print_readably;
Keymap map;
char *prefix;
{	{
register int key;	register int key;
char keyname, out;	char keyname, out;
Line 2332 _rl_macro_dumper_internal (print_readably, map, prefix	Line 2820 _rl_macro_dumper_internal (print_readably, map, prefix
}	}

void	void
rl_macro_dumper (print_readably)	rl_macro_dumper (int print_readably)
int print_readably;
{	{
_rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);	_rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
}	}

int	int
rl_dump_macros (count, key)	rl_dump_macros (int count, int key)
int count, key;
{	{
if (rl_dispatching)	if (rl_dispatching)
fprintf (rl_outstream, "\r\n");	fprintf (rl_outstream, "\r\n");
Line 2350 rl_dump_macros (count, key)	Line 2836 rl_dump_macros (count, key)
}	}

static char *	static char *
_rl_get_string_variable_value (name)	_rl_get_string_variable_value (const char *name)
const char *name;
{	{
static char numbuf[32];	static char numbuf[32];
char *ret;	char *ret;
Line 2420 _rl_get_string_variable_value (name)	Line 2905 _rl_get_string_variable_value (name)
sprintf (numbuf, "%d", _rl_keyseq_timeout);	sprintf (numbuf, "%d", _rl_keyseq_timeout);
return (numbuf);	return (numbuf);
}	}
	else if (_rl_stricmp (name, "emacs-mode-string") == 0)
	return (_rl_emacs_mode_str ? _rl_emacs_mode_str : RL_EMACS_MODESTR_DEFAULT);
	else if (_rl_stricmp (name, "vi-cmd-mode-string") == 0)
	return (_rl_vi_cmd_mode_str ? _rl_vi_cmd_mode_str : RL_VI_CMD_MODESTR_DEFAULT);
	else if (_rl_stricmp (name, "vi-ins-mode-string") == 0)
	return (_rl_vi_ins_mode_str ? _rl_vi_ins_mode_str : RL_VI_INS_MODESTR_DEFAULT);
else	else
return (0);	return (0);
}	}

void	void
rl_variable_dumper (print_readably)	rl_variable_dumper (int print_readably)
int print_readably;
{	{
int i;	int i;
char *v;	char *v;
Line 2457 rl_variable_dumper (print_readably)	Line 2947 rl_variable_dumper (print_readably)
rl_outstream. If an explicit argument is given, then print	rl_outstream. If an explicit argument is given, then print
the output in such a way that it can be read back in. */	the output in such a way that it can be read back in. */
int	int
rl_dump_variables (count, key)	rl_dump_variables (int count, int key)
int count, key;
{	{
if (rl_dispatching)	if (rl_dispatching)
fprintf (rl_outstream, "\r\n");	fprintf (rl_outstream, "\r\n");
Line 2469 rl_dump_variables (count, key)	Line 2958 rl_dump_variables (count, key)

/* Return non-zero if any members of ARRAY are a substring in STRING. */	/* Return non-zero if any members of ARRAY are a substring in STRING. */
static int	static int
substring_member_of_array (string, array)	substring_member_of_array (const char string, const char const *array)
const char *string;
const char * const *array;
{	{
while (*array)	while (*array)
{	{

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.1
changed lines
	Added in v.1.1.1.2