/* bind.c -- key binding and startup file support for the readline library. */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
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 int _rl_read_init_file PARAMS((const char *, int));
static int glean_key_from_name PARAMS((char *));
static int find_boolean_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 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;
/* used only in this file */
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 */
Add NAME to the list of named functions. Make FUNCTION be the function
that gets called. If KEY is not -1, then bind it. */
int
-rl_add_defun (name, function, key)
- const char *name;
- rl_command_func_t *function;
- int key;
+rl_add_defun (const char *name, rl_command_func_t *function, int key)
{
if (key != -1)
rl_bind_key (key, function);
/* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */
int
-rl_bind_key (key, function)
- int key;
- rl_command_func_t *function;
+rl_bind_key (int key, rl_command_func_t *function)
{
char keyseq[3];
int l;
/* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid
KEY. */
int
-rl_bind_key_in_map (key, function, map)
- int key;
- rl_command_func_t *function;
- Keymap map;
+rl_bind_key_in_map (int key, rl_command_func_t *function, Keymap map)
{
int result;
Keymap oldmap;
}
/* 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
- check for rl_vi_movement_mode. */
+ now, this is always used to attempt to bind the arrow keys. */
int
-rl_bind_key_if_unbound_in_map (key, default_func, kmap)
- int key;
- rl_command_func_t *default_func;
- Keymap kmap;
+rl_bind_key_if_unbound_in_map (int key, rl_command_func_t *default_func, Keymap kmap)
{
- char keyseq[2];
+ char *keyseq;
- keyseq[0] = (unsigned char)key;
- keyseq[1] = '\0';
+ keyseq = rl_untranslate_keyseq ((unsigned char)key);
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap));
}
int
-rl_bind_key_if_unbound (key, default_func)
- int key;
- rl_command_func_t *default_func;
+rl_bind_key_if_unbound (int key, rl_command_func_t *default_func)
{
- char keyseq[2];
+ char *keyseq;
- keyseq[0] = (unsigned char)key;
- keyseq[1] = '\0';
+ keyseq = rl_untranslate_keyseq ((unsigned char)key);
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_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
-rl_unbind_key (key)
- int key;
+rl_unbind_key (int key)
{
return (rl_bind_key (key, (rl_command_func_t *)NULL));
}
-/* Make KEY do nothing in MAP.
- Returns non-zero in case of error. */
+/* Make KEY do nothing in MAP. Returns non-zero in case of error. */
int
-rl_unbind_key_in_map (key, map)
- int key;
- Keymap map;
+rl_unbind_key_in_map (int key, Keymap map)
{
return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));
}
/* Unbind all keys bound to FUNCTION in MAP. */
int
-rl_unbind_function_in_map (func, map)
- rl_command_func_t *func;
- Keymap map;
+rl_unbind_function_in_map (rl_command_func_t *func, Keymap map)
{
register int i, rval;
return rval;
}
+/* Unbind all keys bound to COMMAND, which is a bindable command name, in MAP */
int
-rl_unbind_command_in_map (command, map)
- const char *command;
- Keymap map;
+rl_unbind_command_in_map (const char *command, Keymap map)
{
rl_command_func_t *func;
FUNCTION, starting in the current keymap. This makes new
keymaps as necessary. */
int
-rl_bind_keyseq (keyseq, function)
- const char *keyseq;
- rl_command_func_t *function;
+rl_bind_keyseq (const char *keyseq, rl_command_func_t *function)
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));
}
FUNCTION. This makes new keymaps as necessary. The initial
place to do bindings is in MAP. */
int
-rl_bind_keyseq_in_map (keyseq, function, map)
- const char *keyseq;
- rl_command_func_t *function;
- Keymap map;
+rl_bind_keyseq_in_map (const char *keyseq, rl_command_func_t *function, Keymap map)
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}
/* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
int
-rl_set_key (keyseq, function, map)
- const char *keyseq;
- rl_command_func_t *function;
- Keymap map;
+rl_set_key (const char *keyseq, rl_command_func_t *function, Keymap map)
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}
now, this is always used to attempt to bind the arrow keys, hence the
check for rl_vi_movement_mode. */
int
-rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap)
- const char *keyseq;
- rl_command_func_t *default_func;
- Keymap kmap;
+rl_bind_keyseq_if_unbound_in_map (const char *keyseq, rl_command_func_t *default_func, Keymap kmap)
{
rl_command_func_t *func;
+ char *keys;
+ int keys_len;
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 (!func || func == rl_do_lowercase_version || func == rl_vi_movement_mode)
#else
}
int
-rl_bind_keyseq_if_unbound (keyseq, default_func)
- const char *keyseq;
- rl_command_func_t *default_func;
+rl_bind_keyseq_if_unbound (const char *keyseq, rl_command_func_t *default_func)
{
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
}
the string of characters MACRO. This makes new keymaps as
necessary. The initial place to do bindings is in MAP. */
int
-rl_macro_bind (keyseq, macro, map)
- const char *keyseq, *macro;
- Keymap map;
+rl_macro_bind (const char *keyseq, const char *macro, Keymap map)
{
char *macro_keys;
int macro_keys_len;
a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps
as necessary. The initial place to do bindings is in MAP. */
int
-rl_generic_bind (type, keyseq, data, map)
- int type;
- const char *keyseq;
- char *data;
- Keymap map;
+rl_generic_bind (int type, const char *keyseq, char *data, Keymap map)
{
char *keys;
- int keys_len;
+ int keys_len, prevkey;
register int i;
KEYMAP_ENTRY k;
+ Keymap prevmap;
k.function = 0;
return -1;
}
+ prevmap = map;
+ prevkey = keys[0];
+
/* Bind keys, making new keymaps as necessary. */
for (i = 0; i < keys_len; i++)
{
unsigned char uc = keys[i];
int ic;
+ if (i > 0)
+ prevkey = ic;
+
ic = uc;
if (ic < 0 || ic >= KEYMAP_SIZE)
{
{
ic = UNMETA (ic);
if (map[ESC].type == ISKMAP)
- map = FUNCTION_TO_KEYMAP (map, ESC);
+ {
+ prevmap = map;
+ map = FUNCTION_TO_KEYMAP (map, ESC);
+ }
}
if ((i + 1) < keys_len)
map[ic].type = ISKMAP;
map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
}
+ prevmap = map;
map = FUNCTION_TO_KEYMAP (map, ic);
/* The dispatch code will return this function if no matching
key sequence is found in the keymap. This (with a little
xfree ((char *)map[ic].function);
else if (map[ic].type == ISKMAP)
{
+ prevmap = map;
map = FUNCTION_TO_KEYMAP (map, ic);
ic = ANYOTHERKEY;
/* If we're trying to override a keymap with a null function
}
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);
return 0;
}
an array of characters. LEN gets the final length of ARRAY. Return
non-zero if there was an error parsing SEQ. */
int
-rl_translate_keyseq (seq, array, len)
- const char *seq;
- char *array;
- int *len;
+rl_translate_keyseq (const char *seq, char *array, int *len)
{
register int i, c, l, temp;
c = seq[++i];
if (c == 0)
- break;
+ {
+ array[l++] = '\\'; /* preserve trailing backslash */
+ break;
+ }
/* Handle \C- and \M- prefixes. */
if ((c == 'C' || c == 'M') && seq[i + 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')
{
/* Special hack for C-?... */
array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
}
+ if (seq[i] == '\0')
+ break;
continue;
}
}
static int
-_rl_isescape (c)
- int c;
+_rl_isescape (int c)
{
switch (c)
{
}
static int
-_rl_escchar (c)
- int c;
+_rl_escchar (int c)
{
switch (c)
{
}
char *
-rl_untranslate_keyseq (seq)
- int seq;
+rl_untranslate_keyseq (int seq)
{
static char kseq[16];
int i, c;
}
char *
-_rl_untranslate_macro_value (seq, use_escapes)
- char *seq;
- int use_escapes;
+_rl_untranslate_macro_value (char *seq, int use_escapes)
{
char *ret, *r, *s;
int c;
If STRING doesn't have a matching function, then a NULL pointer
is returned. */
rl_command_func_t *
-rl_named_function (string)
- const char *string;
+rl_named_function (const char *string)
{
register int i;
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),
or ISMACR (macro). */
-rl_command_func_t *
-rl_function_of_keyseq (keyseq, map, type)
- const char *keyseq;
- Keymap map;
- int *type;
+static rl_command_func_t *
+_rl_function_of_keyseq_internal (const char *keyseq, size_t len, Keymap map, int *type)
{
register int i;
if (map == 0)
map = _rl_keymap;
- for (i = 0; keyseq && keyseq[i]; i++)
+ for (i = 0; keyseq && i < len; i++)
{
unsigned char ic = keyseq[i];
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. */
static char *last_readline_init_file = (char *)NULL;
The size of the buffer is returned in *SIZEP. Returns NULL if any
errors were encountered. */
static char *
-_rl_read_file (filename, sizep)
- char *filename;
- size_t *sizep;
+_rl_read_file (char *filename, size_t *sizep)
{
struct stat finfo;
size_t file_size;
char *buffer;
int i, file;
- if ((stat (filename, &finfo) < 0) || (file = open (filename, O_RDONLY, 0666)) < 0)
- return ((char *)NULL);
+ file = -1;
+ 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;
/* Re-read the current keybindings file. */
int
-rl_re_read_init_file (count, ignore)
- int count, ignore;
+rl_re_read_init_file (int count, int ignore)
{
int r;
r = rl_read_init_file ((const char *)NULL);
If the file existed and could be opened and read, 0 is returned,
otherwise errno is returned. */
int
-rl_read_init_file (filename)
- const char *filename;
+rl_read_init_file (const char *filename)
{
/* Default the filename. */
if (filename == 0)
}
static int
-_rl_read_init_file (filename, include_level)
- const char *filename;
- int include_level;
+_rl_read_init_file (const char *filename, int include_level)
{
register int i;
char *buffer, *openname, *line, *end;
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 */
/* Push _rl_parsing_conditionalized_out, and set parser state based
on ARGS. */
static int
-parser_if (args)
- char *args;
+parser_if (char *args)
{
- register int i;
+ int i, llen, boolvar, strvar;
+
+ boolvar = strvar = -1;
/* Push parser state. */
if (if_stack_depth + 1 >= if_stack_size)
if (_rl_parsing_conditionalized_out)
return 0;
+ llen = strlen (args);
+
/* Isolate first argument. */
for (i = 0; args[i] && !whitespace (args[i]); i++);
_rl_parsing_conditionalized_out = mode != rl_editing_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
value stored in rl_readline_name. */
else if (_rl_stricmp (args, rl_readline_name) == 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
_rl_parsing_conditionalized_out = 1;
return 0;
/* Invert the current parser state if there is anything on the stack. */
static int
-parser_else (args)
- char *args;
+parser_else (char *args)
{
register int i;
/* Terminate a conditional, popping the value of
_rl_parsing_conditionalized_out from the stack. */
static int
-parser_endif (args)
- char *args;
+parser_endif (char *args)
{
if (if_stack_depth)
_rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
}
static int
-parser_include (args)
- char *args;
+parser_include (char *args)
{
const char *old_init_file;
char *e;
/* Handle a parser directive. STATEMENT is the line of the directive
without any leading `$'. */
static int
-handle_parser_directive (statement)
- char *statement;
+handle_parser_directive (char *statement)
{
register int i;
char *directive, *args;
/* Start at STRING[START] and look for DELIM. Return I where STRING[I] ==
DELIM or STRING[I] == 0. DELIM is usually a double quote. */
static int
-_rl_skip_to_delim (string, start, delim)
- char *string;
- int start, delim;
+_rl_skip_to_delim (char *string, int start, int delim)
{
int i, c, passc;
a variable binding command looks like: set variable value.
A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
int
-rl_parse_and_bind (string)
- char *string;
+rl_parse_and_bind (char *string)
{
char *funname, *kname;
register int c, i;
/* Advance to the colon (:) or whitespace which separates the two objects. */
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] == '=');
foundsep = c != 0;
i = _rl_skip_to_delim (string, i+1, *funname);
if (string[i])
i++;
+ else
+ {
+ _rl_init_file_error ("`%s': missing closing quote for macro", funname);
+ return 1;
+ }
}
/* Advance to the end of the string. */
};
static int
-find_boolean_var (name)
- const char *name;
+find_boolean_var (const char *name)
{
register int i;
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
function needs to be called or another variable needs
to be changed when they're changed. */
static void
-hack_special_boolean_var (i)
- int i;
+hack_special_boolean_var (int i)
{
const char *name;
};
static int
-find_string_var (name)
- const char *name;
+find_string_var (const char *name)
{
register int i;
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
the value is null or empty, `on' (case-insensitive), or "1". Any other
values result in 0 (false). */
static int
-bool_to_int (value)
- const char *value;
+bool_to_int (const char *value)
{
return (value == 0 || *value == '\0' ||
(_rl_stricmp (value, "on") == 0) ||
}
char *
-rl_variable_value (name)
- const char *name;
+rl_variable_value (const char *name)
{
register int i;
}
int
-rl_variable_bind (name, value)
- const char *name, *value;
+rl_variable_bind (const char *name, const char *value)
{
register int i;
int v;
}
static int
-sv_editmode (value)
- const char *value;
+sv_editmode (const char *value)
{
if (_rl_strnicmp (value, "vi", 2) == 0)
{
}
static int
-sv_combegin (value)
- const char *value;
+sv_combegin (const char *value)
{
if (value && *value)
{
}
static int
-sv_dispprefix (value)
- const char *value;
+sv_dispprefix (const char *value)
{
int nval = 0;
}
static int
-sv_compquery (value)
- const char *value;
+sv_compquery (const char *value)
{
int nval = 100;
}
static int
-sv_compwidth (value)
- const char *value;
+sv_compwidth (const char *value)
{
int nval = -1;
}
static int
-sv_histsize (value)
- const char *value;
+sv_histsize (const char *value)
{
int nval;
}
static int
-sv_keymap (value)
- const char *value;
+sv_keymap (const char *value)
{
Keymap kmap;
}
static int
-sv_seqtimeout (value)
- const char *value;
+sv_seqtimeout (const char *value)
{
int nval;
}
static int
-sv_bell_style (value)
- const char *value;
+sv_bell_style (const char *value)
{
if (value == 0 || *value == '\0')
_rl_bell_preference = AUDIBLE_BELL;
}
static int
-sv_isrchterm (value)
- const char *value;
+sv_isrchterm (const char *value)
{
int beg, end, delim;
char *v;
extern char *_rl_emacs_mode_str;
static int
-sv_emacs_modestr (value)
- const char *value;
+sv_emacs_modestr (const char *value)
{
if (value && *value)
{
}
static int
-sv_viins_modestr (value)
- const char *value;
+sv_viins_modestr (const char *value)
{
if (value && *value)
{
}
static int
-sv_vicmd_modestr (value)
- const char *value;
+sv_vicmd_modestr (const char *value)
{
if (value && *value)
{
};
static int
-glean_key_from_name (name)
- char *name;
+glean_key_from_name (char *name)
{
register int i;
}
/* Auxiliary functions to manage keymaps. */
-static const struct {
- const char * const name;
+struct name_and_keymap {
+ char *name;
Keymap map;
-} keymap_names[] = {
+};
+
+static struct name_and_keymap builtin_keymap_names[] = {
{ "emacs", emacs_standard_keymap },
{ "emacs-standard", emacs_standard_keymap },
{ "emacs-meta", emacs_meta_keymap },
{ (char *)0x0, (Keymap)0x0 }
};
-Keymap
-rl_get_keymap_by_name (name)
- const char *name;
+/* -1 for NULL entry */
+#define NUM_BUILTIN_KEYMAPS (sizeof (builtin_keymap_names) / sizeof (builtin_keymap_names[0]) - 1)
+
+static struct name_and_keymap *keymap_names = builtin_keymap_names;
+
+static int
+_rl_get_keymap_by_name (const char *name)
{
register int i;
for (i = 0; keymap_names[i].name; i++)
if (_rl_stricmp (name, keymap_names[i].name) == 0)
- return (keymap_names[i].map);
- return ((Keymap) NULL);
+ return (i);
+ return -1;
}
-char *
-rl_get_keymap_name (map)
- Keymap map;
+Keymap
+rl_get_keymap_by_name (const char *name)
+{
+ 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;
+
for (i = 0; keymap_names[i].name; i++)
if (map == keymap_names[i].map)
- return ((char *)keymap_names[i].name);
- return ((char *)NULL);
+ return (i);
+ 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
-rl_set_keymap (map)
- Keymap map;
+rl_set_keymap (Keymap map)
{
if (map)
_rl_keymap = map;
}
Keymap
-rl_get_keymap ()
+rl_get_keymap (void)
{
return (_rl_keymap);
}
void
-rl_set_keymap_from_edit_mode ()
+rl_set_keymap_from_edit_mode (void)
{
if (rl_editing_mode == emacs_mode)
_rl_keymap = emacs_standard_keymap;
}
char *
-rl_get_keymap_name_from_edit_mode ()
+rl_get_keymap_name_from_edit_mode (void)
{
if (rl_editing_mode == emacs_mode)
return "emacs";
/* Print the names of functions known to Readline. */
void
-rl_list_funmap_names ()
+rl_list_funmap_names (void)
{
register int i;
const char **funmap_names;
}
static char *
-_rl_get_keyname (key)
- int key;
+_rl_get_keyname (int key)
{
char *keyname;
int i, c;
/* Return a NULL terminated array of strings which represent the key
sequences that are used to invoke FUNCTION in MAP. */
char **
-rl_invoking_keyseqs_in_map (function, map)
- rl_command_func_t *function;
- Keymap map;
+rl_invoking_keyseqs_in_map (rl_command_func_t *function, Keymap map)
{
register int key;
char **result;
/* Return a NULL terminated array of strings which represent the key
sequences that can be used to invoke FUNCTION using the current keymap. */
char **
-rl_invoking_keyseqs (function)
- rl_command_func_t *function;
+rl_invoking_keyseqs (rl_command_func_t *function)
{
return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
}
PRINT_READABLY is non-zero, then print the output in such a way
that it can be read back in. */
void
-rl_function_dumper (print_readably)
- int print_readably;
+rl_function_dumper (int print_readably)
{
register int i;
const char **names;
rl_outstream. If an explicit argument is given, then print
the output in such a way that it can be read back in. */
int
-rl_dump_functions (count, key)
- int count, key;
+rl_dump_functions (int count, int key)
{
if (rl_dispatching)
fprintf (rl_outstream, "\r\n");
}
static void
-_rl_macro_dumper_internal (print_readably, map, prefix)
- int print_readably;
- Keymap map;
- char *prefix;
+_rl_macro_dumper_internal (int print_readably, Keymap map, char *prefix)
{
register int key;
char *keyname, *out;
}
void
-rl_macro_dumper (print_readably)
- int print_readably;
+rl_macro_dumper (int print_readably)
{
_rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
}
int
-rl_dump_macros (count, key)
- int count, key;
+rl_dump_macros (int count, int key)
{
if (rl_dispatching)
fprintf (rl_outstream, "\r\n");
}
static char *
-_rl_get_string_variable_value (name)
- const char *name;
+_rl_get_string_variable_value (const char *name)
{
static char numbuf[32];
char *ret;
}
void
-rl_variable_dumper (print_readably)
- int print_readably;
+rl_variable_dumper (int print_readably)
{
int i;
char *v;
rl_outstream. If an explicit argument is given, then print
the output in such a way that it can be read back in. */
int
-rl_dump_variables (count, key)
- int count, key;
+rl_dump_variables (int count, int key)
{
if (rl_dispatching)
fprintf (rl_outstream, "\r\n");
/* Return non-zero if any members of ARRAY are a substring in STRING. */
static int
-substring_member_of_array (string, array)
- const char *string;
- const char * const *array;
+substring_member_of_array (const char *string, const char * const *array)
{
while (*array)
{
projects / deliverable / binutils-gdb.git / blobdiff