/* 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-2005 Free Software Foundation, Inc.
|
/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
|
|
|
This file is part of the GNU Readline Library, a library for
|
This file is part of the GNU Readline Library, a library for
|
reading lines of text with interactive input and history editing.
|
reading lines of text with interactive input and history editing.
|
|
|
The GNU Readline Library is free software; you can redistribute it
|
The GNU Readline Library is free software; you can redistribute it
|
and/or modify it under the terms of the GNU General Public License
|
and/or modify it under the terms of the GNU General Public License
|
as published by the Free Software Foundation; either version 2, or
|
as published by the Free Software Foundation; either version 2, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
The GNU Readline Library is distributed in the hope that it will be
|
The GNU Readline Library is distributed in the hope that it will be
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
The GNU General Public License is often shipped with GNU software, and
|
The GNU General Public License is often shipped with GNU software, and
|
is generally kept in a file called COPYING or LICENSE. If you do not
|
is generally kept in a file called COPYING or LICENSE. If you do not
|
have a copy of the license, write to the Free Software Foundation,
|
have a copy of the license, write to the Free Software Foundation,
|
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
|
|
#define READLINE_LIBRARY
|
#define READLINE_LIBRARY
|
|
|
#if defined (__TANDEM)
|
#if defined (__TANDEM)
|
# include <floss.h>
|
# include <floss.h>
|
#endif
|
#endif
|
|
|
#if defined (HAVE_CONFIG_H)
|
#if defined (HAVE_CONFIG_H)
|
# include <config.h>
|
# include <config.h>
|
#endif
|
#endif
|
|
|
#include <stdio.h>
|
#include <stdio.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#if defined (HAVE_SYS_FILE_H)
|
#if defined (HAVE_SYS_FILE_H)
|
# include <sys/file.h>
|
# include <sys/file.h>
|
#endif /* HAVE_SYS_FILE_H */
|
#endif /* HAVE_SYS_FILE_H */
|
|
|
#if defined (HAVE_UNISTD_H)
|
#if defined (HAVE_UNISTD_H)
|
# include <unistd.h>
|
# include <unistd.h>
|
#endif /* HAVE_UNISTD_H */
|
#endif /* HAVE_UNISTD_H */
|
|
|
#if defined (HAVE_STDLIB_H)
|
#if defined (HAVE_STDLIB_H)
|
# include <stdlib.h>
|
# include <stdlib.h>
|
#else
|
#else
|
# include "ansi_stdlib.h"
|
# include "ansi_stdlib.h"
|
#endif /* HAVE_STDLIB_H */
|
#endif /* HAVE_STDLIB_H */
|
|
|
#include <errno.h>
|
#include <errno.h>
|
|
|
#if !defined (errno)
|
#if !defined (errno)
|
extern int errno;
|
extern int errno;
|
#endif /* !errno */
|
#endif /* !errno */
|
|
|
#include "posixstat.h"
|
#include "posixstat.h"
|
|
|
/* System-specific feature definitions and include files. */
|
/* System-specific feature definitions and include files. */
|
#include "rldefs.h"
|
#include "rldefs.h"
|
|
|
/* Some standard library routines. */
|
/* Some standard library routines. */
|
#include "readline.h"
|
#include "readline.h"
|
#include "history.h"
|
#include "history.h"
|
|
|
#include "rlprivate.h"
|
#include "rlprivate.h"
|
#include "rlshell.h"
|
#include "rlshell.h"
|
#include "xmalloc.h"
|
#include "xmalloc.h"
|
|
|
#if !defined (strchr) && !defined (__STDC__)
|
#if !defined (strchr) && !defined (__STDC__)
|
extern char *strchr (), *strrchr ();
|
extern char *strchr (), *strrchr ();
|
#endif /* !strchr && !__STDC__ */
|
#endif /* !strchr && !__STDC__ */
|
|
|
/* Variables exported by this file. */
|
/* Variables exported by this file. */
|
Keymap rl_binding_keymap;
|
Keymap rl_binding_keymap;
|
|
|
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 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 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((char *, const char **));
|
static int substring_member_of_array PARAMS((char *, const char **));
|
|
|
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;
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Binding keys */
|
/* Binding keys */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* rl_add_defun (char *name, rl_command_func_t *function, int key)
|
/* rl_add_defun (char *name, rl_command_func_t *function, int key)
|
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 (name, function, key)
|
const char *name;
|
const char *name;
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
int key;
|
int key;
|
{
|
{
|
if (key != -1)
|
if (key != -1)
|
rl_bind_key (key, function);
|
rl_bind_key (key, function);
|
rl_add_funmap_entry (name, function);
|
rl_add_funmap_entry (name, function);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* 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 (key, function)
|
int key;
|
int key;
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
{
|
{
|
if (key < 0)
|
if (key < 0)
|
return (key);
|
return (key);
|
|
|
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)
|
{
|
{
|
Keymap escmap;
|
Keymap escmap;
|
|
|
escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC);
|
escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC);
|
key = UNMETA (key);
|
key = UNMETA (key);
|
escmap[key].type = ISFUNC;
|
escmap[key].type = ISFUNC;
|
escmap[key].function = function;
|
escmap[key].function = function;
|
return (0);
|
return (0);
|
}
|
}
|
return (key);
|
return (key);
|
}
|
}
|
|
|
_rl_keymap[key].type = ISFUNC;
|
_rl_keymap[key].type = ISFUNC;
|
_rl_keymap[key].function = function;
|
_rl_keymap[key].function = function;
|
rl_binding_keymap = _rl_keymap;
|
rl_binding_keymap = _rl_keymap;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* 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 (key, function, map)
|
int key;
|
int key;
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
int result;
|
int result;
|
Keymap oldmap;
|
Keymap oldmap;
|
|
|
oldmap = _rl_keymap;
|
oldmap = _rl_keymap;
|
_rl_keymap = map;
|
_rl_keymap = map;
|
result = rl_bind_key (key, function);
|
result = rl_bind_key (key, function);
|
_rl_keymap = oldmap;
|
_rl_keymap = oldmap;
|
return (result);
|
return (result);
|
}
|
}
|
|
|
/* 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, hence the
|
check for rl_vi_movement_mode. */
|
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 (key, default_func, kmap)
|
int key;
|
int key;
|
rl_command_func_t *default_func;
|
rl_command_func_t *default_func;
|
Keymap kmap;
|
Keymap kmap;
|
{
|
{
|
char keyseq[2];
|
char keyseq[2];
|
|
|
keyseq[0] = (unsigned char)key;
|
keyseq[0] = (unsigned char)key;
|
keyseq[1] = '\0';
|
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 (key, default_func)
|
int key;
|
int key;
|
rl_command_func_t *default_func;
|
rl_command_func_t *default_func;
|
{
|
{
|
char keyseq[2];
|
char keyseq[2];
|
|
|
keyseq[0] = (unsigned char)key;
|
keyseq[0] = (unsigned char)key;
|
keyseq[1] = '\0';
|
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. */
|
int
|
int
|
rl_unbind_key (key)
|
rl_unbind_key (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 (key, map)
|
int key;
|
int key;
|
Keymap map;
|
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 (func, map)
|
rl_command_func_t *func;
|
rl_command_func_t *func;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
register int i, rval;
|
register int i, rval;
|
|
|
for (i = rval = 0; i < KEYMAP_SIZE; i++)
|
for (i = rval = 0; i < KEYMAP_SIZE; i++)
|
{
|
{
|
if (map[i].type == ISFUNC && map[i].function == func)
|
if (map[i].type == ISFUNC && map[i].function == func)
|
{
|
{
|
map[i].function = (rl_command_func_t *)NULL;
|
map[i].function = (rl_command_func_t *)NULL;
|
rval = 1;
|
rval = 1;
|
}
|
}
|
}
|
}
|
return rval;
|
return rval;
|
}
|
}
|
|
|
int
|
int
|
rl_unbind_command_in_map (command, map)
|
rl_unbind_command_in_map (command, map)
|
const char *command;
|
const char *command;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
rl_command_func_t *func;
|
rl_command_func_t *func;
|
|
|
func = rl_named_function (command);
|
func = rl_named_function (command);
|
if (func == 0)
|
if (func == 0)
|
return 0;
|
return 0;
|
return (rl_unbind_function_in_map (func, map));
|
return (rl_unbind_function_in_map (func, map));
|
}
|
}
|
|
|
/* Bind the key sequence represented by the string KEYSEQ to
|
/* Bind the key sequence represented by the string KEYSEQ to
|
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 (keyseq, function)
|
const char *keyseq;
|
const char *keyseq;
|
rl_command_func_t *function;
|
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));
|
}
|
}
|
|
|
/* Bind the key sequence represented by the string KEYSEQ to
|
/* Bind the key sequence represented by the string KEYSEQ to
|
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 (keyseq, function, map)
|
const char *keyseq;
|
const char *keyseq;
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
Keymap map;
|
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 (keyseq, function, map)
|
const char *keyseq;
|
const char *keyseq;
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
|
return (rl_generic_bind (ISFUNC, keyseq, (char *)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, 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 (keyseq, default_func, kmap)
|
const char *keyseq;
|
const char *keyseq;
|
rl_command_func_t *default_func;
|
rl_command_func_t *default_func;
|
Keymap kmap;
|
Keymap kmap;
|
{
|
{
|
rl_command_func_t *func;
|
rl_command_func_t *func;
|
|
|
if (keyseq)
|
if (keyseq)
|
{
|
{
|
func = rl_function_of_keyseq (keyseq, kmap, (int *)NULL);
|
func = rl_function_of_keyseq (keyseq, kmap, (int *)NULL);
|
#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
|
if (!func || func == rl_do_lowercase_version)
|
if (!func || func == rl_do_lowercase_version)
|
#endif
|
#endif
|
return (rl_bind_keyseq_in_map (keyseq, default_func, kmap));
|
return (rl_bind_keyseq_in_map (keyseq, default_func, kmap));
|
else
|
else
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
rl_bind_keyseq_if_unbound (keyseq, default_func)
|
rl_bind_keyseq_if_unbound (keyseq, default_func)
|
const char *keyseq;
|
const char *keyseq;
|
rl_command_func_t *default_func;
|
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));
|
}
|
}
|
|
|
/* Bind the key sequence represented by the string KEYSEQ to
|
/* Bind the key sequence represented by the string KEYSEQ to
|
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 (keyseq, macro, map)
|
const char *keyseq, *macro;
|
const char *keyseq, *macro;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
char *macro_keys;
|
char *macro_keys;
|
int macro_keys_len;
|
int macro_keys_len;
|
|
|
macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);
|
macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);
|
|
|
if (rl_translate_keyseq (macro, macro_keys, ¯o_keys_len))
|
if (rl_translate_keyseq (macro, macro_keys, ¯o_keys_len))
|
{
|
{
|
free (macro_keys);
|
free (macro_keys);
|
return -1;
|
return -1;
|
}
|
}
|
rl_generic_bind (ISMACR, keyseq, macro_keys, map);
|
rl_generic_bind (ISMACR, keyseq, macro_keys, map);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Bind the key sequence represented by the string KEYSEQ to
|
/* Bind the key sequence represented by the string KEYSEQ to
|
the arbitrary pointer DATA. TYPE says what kind of data is
|
the arbitrary pointer DATA. TYPE says what kind of data is
|
pointed to by DATA, right now this can be a function (ISFUNC),
|
pointed to by DATA, right now this can be a function (ISFUNC),
|
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 (type, keyseq, data, map)
|
int type;
|
int type;
|
const char *keyseq;
|
const char *keyseq;
|
char *data;
|
char *data;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
char *keys;
|
char *keys;
|
int keys_len;
|
int keys_len;
|
register int i;
|
register int i;
|
KEYMAP_ENTRY k;
|
KEYMAP_ENTRY k;
|
|
|
k.function = 0;
|
k.function = 0;
|
|
|
/* If no keys to bind to, exit right away. */
|
/* If no keys to bind to, exit right away. */
|
if (keyseq == 0 || *keyseq == 0)
|
if (keyseq == 0 || *keyseq == 0)
|
{
|
{
|
if (type == ISMACR)
|
if (type == ISMACR)
|
free (data);
|
free (data);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
keys = (char *)xmalloc (1 + (2 * strlen (keyseq)));
|
keys = (char *)xmalloc (1 + (2 * strlen (keyseq)));
|
|
|
/* Translate the ASCII representation of KEYSEQ into an array of
|
/* Translate the ASCII representation of KEYSEQ into an array of
|
characters. Stuff the characters into KEYS, and the length of
|
characters. Stuff the characters into KEYS, and the length of
|
KEYS into KEYS_LEN. */
|
KEYS into KEYS_LEN. */
|
if (rl_translate_keyseq (keyseq, keys, &keys_len))
|
if (rl_translate_keyseq (keyseq, keys, &keys_len))
|
{
|
{
|
free (keys);
|
free (keys);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* 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;
|
int ic;
|
|
|
ic = uc;
|
ic = uc;
|
if (ic < 0 || ic >= KEYMAP_SIZE)
|
if (ic < 0 || ic >= KEYMAP_SIZE)
|
return -1;
|
return -1;
|
|
|
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);
|
map = FUNCTION_TO_KEYMAP (map, ESC);
|
}
|
}
|
|
|
if ((i + 1) < keys_len)
|
if ((i + 1) < keys_len)
|
{
|
{
|
if (map[ic].type != ISKMAP)
|
if (map[ic].type != ISKMAP)
|
{
|
{
|
/* We allow subsequences of keys. If a keymap is being
|
/* We allow subsequences of keys. If a keymap is being
|
created that will `shadow' an existing function or macro
|
created that will `shadow' an existing function or macro
|
key binding, we save that keybinding into the ANYOTHERKEY
|
key binding, we save that keybinding into the ANYOTHERKEY
|
index in the new map. The dispatch code will look there
|
index in the new map. The dispatch code will look there
|
to find the function to execute if the subsequence is not
|
to find the function to execute if the subsequence is not
|
matched. ANYOTHERKEY was chosen to be greater than
|
matched. ANYOTHERKEY was chosen to be greater than
|
UCHAR_MAX. */
|
UCHAR_MAX. */
|
k = map[ic];
|
k = map[ic];
|
|
|
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());
|
}
|
}
|
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
|
help from the dispatch code in readline.c) allows `a' to be
|
help from the dispatch code in readline.c) allows `a' to be
|
mapped to something, `abc' to be mapped to something else,
|
mapped to something, `abc' to be mapped to something else,
|
and the function bound to `a' to be executed when the user
|
and the function bound to `a' to be executed when the user
|
types `abx', leaving `bx' in the input queue. */
|
types `abx', leaving `bx' in the input queue. */
|
if (k.function && ((k.type == ISFUNC && k.function != rl_do_lowercase_version) || k.type == ISMACR))
|
if (k.function && ((k.type == ISFUNC && k.function != rl_do_lowercase_version) || k.type == ISMACR))
|
{
|
{
|
map[ANYOTHERKEY] = k;
|
map[ANYOTHERKEY] = k;
|
k.function = 0;
|
k.function = 0;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (map[ic].type == ISMACR)
|
if (map[ic].type == ISMACR)
|
free ((char *)map[ic].function);
|
free ((char *)map[ic].function);
|
else if (map[ic].type == ISKMAP)
|
else if (map[ic].type == ISKMAP)
|
{
|
{
|
map = FUNCTION_TO_KEYMAP (map, ic);
|
map = FUNCTION_TO_KEYMAP (map, ic);
|
ic = ANYOTHERKEY;
|
ic = ANYOTHERKEY;
|
}
|
}
|
|
|
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;
|
}
|
}
|
free (keys);
|
free (keys);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
|
/* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
|
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 (seq, array, len)
|
const char *seq;
|
const char *seq;
|
char *array;
|
char *array;
|
int *len;
|
int *len;
|
{
|
{
|
register int i, c, l, temp;
|
register int i, c, l, temp;
|
|
|
for (i = l = 0; c = seq[i]; i++)
|
for (i = l = 0; c = seq[i]; i++)
|
{
|
{
|
if (c == '\\')
|
if (c == '\\')
|
{
|
{
|
c = seq[++i];
|
c = seq[++i];
|
|
|
if (c == 0)
|
if (c == 0)
|
break;
|
break;
|
|
|
/* Handle \C- and \M- prefixes. */
|
/* Handle \C- and \M- prefixes. */
|
if ((c == 'C' || c == 'M') && seq[i + 1] == '-')
|
if ((c == 'C' || c == 'M') && seq[i + 1] == '-')
|
{
|
{
|
/* Handle special case of backwards define. */
|
/* Handle special case of backwards define. */
|
if (strncmp (&seq[i], "C-\\M-", 5) == 0)
|
if (strncmp (&seq[i], "C-\\M-", 5) == 0)
|
{
|
{
|
array[l++] = ESC; /* ESC is meta-prefix */
|
array[l++] = ESC; /* ESC is meta-prefix */
|
i += 5;
|
i += 5;
|
array[l++] = CTRL (_rl_to_upper (seq[i]));
|
array[l++] = CTRL (_rl_to_upper (seq[i]));
|
if (seq[i] == '\0')
|
if (seq[i] == '\0')
|
i--;
|
i--;
|
}
|
}
|
else if (c == 'M')
|
else if (c == 'M')
|
{
|
{
|
i++;
|
i++;
|
/* XXX - should obey convert-meta setting? */
|
/* XXX - should obey convert-meta setting? */
|
if (_rl_convert_meta_chars_to_ascii && _rl_keymap[ESC].type == ISKMAP)
|
if (_rl_convert_meta_chars_to_ascii && _rl_keymap[ESC].type == ISKMAP)
|
array[l++] = ESC; /* ESC is meta-prefix */
|
array[l++] = ESC; /* ESC is meta-prefix */
|
else
|
else
|
{
|
{
|
i++;
|
i++;
|
array[l++] = META (seq[i]);
|
array[l++] = META (seq[i]);
|
}
|
}
|
}
|
}
|
else if (c == 'C')
|
else if (c == 'C')
|
{
|
{
|
i += 2;
|
i += 2;
|
/* Special hack for C-?... */
|
/* Special hack for C-?... */
|
array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
|
array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
|
}
|
}
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Translate other backslash-escaped characters. These are the
|
/* Translate other backslash-escaped characters. These are the
|
same escape sequences that bash's `echo' and `printf' builtins
|
same escape sequences that bash's `echo' and `printf' builtins
|
handle, with the addition of \d -> RUBOUT. A backslash
|
handle, with the addition of \d -> RUBOUT. A backslash
|
preceding a character that is not special is stripped. */
|
preceding a character that is not special is stripped. */
|
switch (c)
|
switch (c)
|
{
|
{
|
case 'a':
|
case 'a':
|
array[l++] = '\007';
|
array[l++] = '\007';
|
break;
|
break;
|
case 'b':
|
case 'b':
|
array[l++] = '\b';
|
array[l++] = '\b';
|
break;
|
break;
|
case 'd':
|
case 'd':
|
array[l++] = RUBOUT; /* readline-specific */
|
array[l++] = RUBOUT; /* readline-specific */
|
break;
|
break;
|
case 'e':
|
case 'e':
|
array[l++] = ESC;
|
array[l++] = ESC;
|
break;
|
break;
|
case 'f':
|
case 'f':
|
array[l++] = '\f';
|
array[l++] = '\f';
|
break;
|
break;
|
case 'n':
|
case 'n':
|
array[l++] = NEWLINE;
|
array[l++] = NEWLINE;
|
break;
|
break;
|
case 'r':
|
case 'r':
|
array[l++] = RETURN;
|
array[l++] = RETURN;
|
break;
|
break;
|
case 't':
|
case 't':
|
array[l++] = TAB;
|
array[l++] = TAB;
|
break;
|
break;
|
case 'v':
|
case 'v':
|
array[l++] = 0x0B;
|
array[l++] = 0x0B;
|
break;
|
break;
|
case '\\':
|
case '\\':
|
array[l++] = '\\';
|
array[l++] = '\\';
|
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 (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;
|
array[l++] = c & largest_char;
|
break;
|
break;
|
case 'x':
|
case 'x':
|
i++;
|
i++;
|
for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i]) && temp--; i++)
|
for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i]) && temp--; i++)
|
c = (c * 16) + HEXVALUE (seq[i]);
|
c = (c * 16) + HEXVALUE (seq[i]);
|
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;
|
array[l++] = 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;
|
array[l++] = c;
|
break; /* the backslash is stripped */
|
break; /* the backslash is stripped */
|
}
|
}
|
continue;
|
continue;
|
}
|
}
|
|
|
array[l++] = c;
|
array[l++] = c;
|
}
|
}
|
|
|
*len = l;
|
*len = l;
|
array[l] = '\0';
|
array[l] = '\0';
|
return (0);
|
return (0);
|
}
|
}
|
|
|
char *
|
char *
|
rl_untranslate_keyseq (seq)
|
rl_untranslate_keyseq (seq)
|
int seq;
|
int seq;
|
{
|
{
|
static char kseq[16];
|
static char kseq[16];
|
int i, c;
|
int i, c;
|
|
|
i = 0;
|
i = 0;
|
c = seq;
|
c = seq;
|
if (META_CHAR (c))
|
if (META_CHAR (c))
|
{
|
{
|
kseq[i++] = '\\';
|
kseq[i++] = '\\';
|
kseq[i++] = 'M';
|
kseq[i++] = 'M';
|
kseq[i++] = '-';
|
kseq[i++] = '-';
|
c = UNMETA (c);
|
c = UNMETA (c);
|
}
|
}
|
else if (CTRL_CHAR (c))
|
else if (CTRL_CHAR (c))
|
{
|
{
|
kseq[i++] = '\\';
|
kseq[i++] = '\\';
|
kseq[i++] = 'C';
|
kseq[i++] = 'C';
|
kseq[i++] = '-';
|
kseq[i++] = '-';
|
c = _rl_to_lower (UNCTRL (c));
|
c = _rl_to_lower (UNCTRL (c));
|
}
|
}
|
else if (c == RUBOUT)
|
else if (c == RUBOUT)
|
{
|
{
|
kseq[i++] = '\\';
|
kseq[i++] = '\\';
|
kseq[i++] = 'C';
|
kseq[i++] = 'C';
|
kseq[i++] = '-';
|
kseq[i++] = '-';
|
c = '?';
|
c = '?';
|
}
|
}
|
|
|
if (c == ESC)
|
if (c == ESC)
|
{
|
{
|
kseq[i++] = '\\';
|
kseq[i++] = '\\';
|
c = 'e';
|
c = 'e';
|
}
|
}
|
else if (c == '\\' || c == '"')
|
else if (c == '\\' || c == '"')
|
{
|
{
|
kseq[i++] = '\\';
|
kseq[i++] = '\\';
|
}
|
}
|
|
|
kseq[i++] = (unsigned char) c;
|
kseq[i++] = (unsigned char) c;
|
kseq[i] = '\0';
|
kseq[i] = '\0';
|
return kseq;
|
return kseq;
|
}
|
}
|
|
|
static char *
|
static char *
|
_rl_untranslate_macro_value (seq)
|
_rl_untranslate_macro_value (seq)
|
char *seq;
|
char *seq;
|
{
|
{
|
char *ret, *r, *s;
|
char *ret, *r, *s;
|
int c;
|
int c;
|
|
|
r = ret = (char *)xmalloc (7 * strlen (seq) + 1);
|
r = ret = (char *)xmalloc (7 * strlen (seq) + 1);
|
for (s = seq; *s; s++)
|
for (s = seq; *s; s++)
|
{
|
{
|
c = *s;
|
c = *s;
|
if (META_CHAR (c))
|
if (META_CHAR (c))
|
{
|
{
|
*r++ = '\\';
|
*r++ = '\\';
|
*r++ = 'M';
|
*r++ = 'M';
|
*r++ = '-';
|
*r++ = '-';
|
c = UNMETA (c);
|
c = UNMETA (c);
|
}
|
}
|
else if (CTRL_CHAR (c) && c != ESC)
|
else if (CTRL_CHAR (c) && c != ESC)
|
{
|
{
|
*r++ = '\\';
|
*r++ = '\\';
|
*r++ = 'C';
|
*r++ = 'C';
|
*r++ = '-';
|
*r++ = '-';
|
c = _rl_to_lower (UNCTRL (c));
|
c = _rl_to_lower (UNCTRL (c));
|
}
|
}
|
else if (c == RUBOUT)
|
else if (c == RUBOUT)
|
{
|
{
|
*r++ = '\\';
|
*r++ = '\\';
|
*r++ = 'C';
|
*r++ = 'C';
|
*r++ = '-';
|
*r++ = '-';
|
c = '?';
|
c = '?';
|
}
|
}
|
|
|
if (c == ESC)
|
if (c == ESC)
|
{
|
{
|
*r++ = '\\';
|
*r++ = '\\';
|
c = 'e';
|
c = 'e';
|
}
|
}
|
else if (c == '\\' || c == '"')
|
else if (c == '\\' || c == '"')
|
*r++ = '\\';
|
*r++ = '\\';
|
|
|
*r++ = (unsigned char)c;
|
*r++ = (unsigned char)c;
|
}
|
}
|
*r = '\0';
|
*r = '\0';
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* 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. */
|
rl_command_func_t *
|
rl_command_func_t *
|
rl_named_function (string)
|
rl_named_function (string)
|
const char *string;
|
const char *string;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
rl_initialize_funmap ();
|
rl_initialize_funmap ();
|
|
|
for (i = 0; funmap[i]; i++)
|
for (i = 0; funmap[i]; i++)
|
if (_rl_stricmp (funmap[i]->name, string) == 0)
|
if (_rl_stricmp (funmap[i]->name, string) == 0)
|
return (funmap[i]->function);
|
return (funmap[i]->function);
|
return ((rl_command_func_t *)NULL);
|
return ((rl_command_func_t *)NULL);
|
}
|
}
|
|
|
/* Return the function (or macro) definition which would be invoked via
|
/* Return the function (or macro) definition which would be invoked via
|
KEYSEQ if executed in MAP. If MAP is NULL, then the current keymap is
|
KEYSEQ if executed in MAP. If MAP is NULL, then the current keymap is
|
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 *
|
rl_command_func_t *
|
rl_function_of_keyseq (keyseq, map, type)
|
rl_function_of_keyseq (keyseq, map, type)
|
const char *keyseq;
|
const char *keyseq;
|
Keymap map;
|
Keymap map;
|
int *type;
|
int *type;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
if (!map)
|
if (!map)
|
map = _rl_keymap;
|
map = _rl_keymap;
|
|
|
for (i = 0; keyseq && keyseq[i]; i++)
|
for (i = 0; keyseq && keyseq[i]; i++)
|
{
|
{
|
unsigned char ic = keyseq[i];
|
unsigned char ic = keyseq[i];
|
|
|
if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
|
if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
|
{
|
{
|
if (map[ESC].type != ISKMAP)
|
if (map[ESC].type != ISKMAP)
|
{
|
{
|
if (type)
|
if (type)
|
*type = map[ESC].type;
|
*type = map[ESC].type;
|
|
|
return (map[ESC].function);
|
return (map[ESC].function);
|
}
|
}
|
else
|
else
|
{
|
{
|
map = FUNCTION_TO_KEYMAP (map, ESC);
|
map = FUNCTION_TO_KEYMAP (map, ESC);
|
ic = UNMETA (ic);
|
ic = UNMETA (ic);
|
}
|
}
|
}
|
}
|
|
|
if (map[ic].type == ISKMAP)
|
if (map[ic].type == ISKMAP)
|
{
|
{
|
/* 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])
|
if (!keyseq[i + 1])
|
{
|
{
|
if (type)
|
if (type)
|
*type = ISKMAP;
|
*type = ISKMAP;
|
|
|
return (map[ic].function);
|
return (map[ic].function);
|
}
|
}
|
else
|
else
|
map = FUNCTION_TO_KEYMAP (map, ic);
|
map = FUNCTION_TO_KEYMAP (map, ic);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (type)
|
if (type)
|
*type = map[ic].type;
|
*type = map[ic].type;
|
|
|
return (map[ic].function);
|
return (map[ic].function);
|
}
|
}
|
}
|
}
|
return ((rl_command_func_t *) NULL);
|
return ((rl_command_func_t *) NULL);
|
}
|
}
|
|
|
/* 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;
|
|
|
/* The file we're currently reading key bindings from. */
|
/* The file we're currently reading key bindings from. */
|
static const char *current_readline_init_file;
|
static const char *current_readline_init_file;
|
static int current_readline_init_include_level;
|
static int current_readline_init_include_level;
|
static int current_readline_init_lineno;
|
static int current_readline_init_lineno;
|
|
|
/* Read FILENAME into a locally-allocated buffer and return the buffer.
|
/* Read FILENAME into a locally-allocated buffer and return the buffer.
|
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 (filename, sizep)
|
char *filename;
|
char *filename;
|
size_t *sizep;
|
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)
|
if ((stat (filename, &finfo) < 0) || (file = open (filename, O_RDONLY, 0666)) < 0)
|
return ((char *)NULL);
|
return ((char *)NULL);
|
|
|
file_size = (size_t)finfo.st_size;
|
file_size = (size_t)finfo.st_size;
|
|
|
/* check for overflow on very large files */
|
/* check for overflow on very large files */
|
if (file_size != finfo.st_size || file_size + 1 < file_size)
|
if (file_size != finfo.st_size || file_size + 1 < file_size)
|
{
|
{
|
if (file >= 0)
|
if (file >= 0)
|
close (file);
|
close (file);
|
#if defined (EFBIG)
|
#if defined (EFBIG)
|
errno = EFBIG;
|
errno = EFBIG;
|
#endif
|
#endif
|
return ((char *)NULL);
|
return ((char *)NULL);
|
}
|
}
|
|
|
/* Read the file into BUFFER. */
|
/* Read the file into BUFFER. */
|
buffer = (char *)xmalloc (file_size + 1);
|
buffer = (char *)xmalloc (file_size + 1);
|
i = read (file, buffer, file_size);
|
i = read (file, buffer, file_size);
|
close (file);
|
close (file);
|
|
|
if (i < 0)
|
if (i < 0)
|
{
|
{
|
free (buffer);
|
free (buffer);
|
return ((char *)NULL);
|
return ((char *)NULL);
|
}
|
}
|
|
|
buffer[i] = '\0';
|
buffer[i] = '\0';
|
if (sizep)
|
if (sizep)
|
*sizep = i;
|
*sizep = i;
|
|
|
return (buffer);
|
return (buffer);
|
}
|
}
|
|
|
/* 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 (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
int r;
|
int r;
|
r = rl_read_init_file ((const char *)NULL);
|
r = rl_read_init_file ((const char *)NULL);
|
rl_set_keymap_from_edit_mode ();
|
rl_set_keymap_from_edit_mode ();
|
return r;
|
return r;
|
}
|
}
|
|
|
/* Do key bindings from a file. If FILENAME is NULL it defaults
|
/* Do key bindings from a file. If FILENAME is NULL it defaults
|
to the first non-null filename from this list:
|
to the first non-null filename from this list:
|
1. the filename used for the previous call
|
1. the filename used for the previous call
|
2. the value of the shell variable `INPUTRC'
|
2. the value of the shell variable `INPUTRC'
|
3. ~/.inputrc
|
3. ~/.inputrc
|
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 (filename)
|
const char *filename;
|
const char *filename;
|
{
|
{
|
/* Default the filename. */
|
/* Default the filename. */
|
if (filename == 0)
|
if (filename == 0)
|
{
|
{
|
filename = last_readline_init_file;
|
filename = last_readline_init_file;
|
if (filename == 0)
|
if (filename == 0)
|
filename = sh_get_env_value ("INPUTRC");
|
filename = sh_get_env_value ("INPUTRC");
|
if (filename == 0)
|
if (filename == 0)
|
filename = DEFAULT_INPUTRC;
|
filename = DEFAULT_INPUTRC;
|
}
|
}
|
|
|
if (*filename == 0)
|
if (*filename == 0)
|
filename = DEFAULT_INPUTRC;
|
filename = DEFAULT_INPUTRC;
|
|
|
#if defined (__MSDOS__)
|
#if defined (__MSDOS__)
|
if (_rl_read_init_file (filename, 0) == 0)
|
if (_rl_read_init_file (filename, 0) == 0)
|
return 0;
|
return 0;
|
filename = "~/_inputrc";
|
filename = "~/_inputrc";
|
#endif
|
#endif
|
return (_rl_read_init_file (filename, 0));
|
return (_rl_read_init_file (filename, 0));
|
}
|
}
|
|
|
static int
|
static int
|
_rl_read_init_file (filename, include_level)
|
_rl_read_init_file (filename, include_level)
|
const char *filename;
|
const char *filename;
|
int include_level;
|
int include_level;
|
{
|
{
|
register int i;
|
register int i;
|
char *buffer, *openname, *line, *end;
|
char *buffer, *openname, *line, *end;
|
size_t file_size;
|
size_t file_size;
|
|
|
current_readline_init_file = filename;
|
current_readline_init_file = filename;
|
current_readline_init_include_level = include_level;
|
current_readline_init_include_level = include_level;
|
|
|
openname = tilde_expand (filename);
|
openname = tilde_expand (filename);
|
buffer = _rl_read_file (openname, &file_size);
|
buffer = _rl_read_file (openname, &file_size);
|
free (openname);
|
free (openname);
|
|
|
if (buffer == 0)
|
if (buffer == 0)
|
return (errno);
|
return (errno);
|
|
|
if (include_level == 0 && filename != last_readline_init_file)
|
if (include_level == 0 && filename != last_readline_init_file)
|
{
|
{
|
FREE (last_readline_init_file);
|
FREE (last_readline_init_file);
|
last_readline_init_file = savestring (filename);
|
last_readline_init_file = savestring (filename);
|
}
|
}
|
|
|
currently_reading_init_file = 1;
|
currently_reading_init_file = 1;
|
|
|
/* Loop over the lines in the file. Lines that start with `#' are
|
/* Loop over the lines in the file. Lines that start with `#' are
|
comments; all other lines are commands for readline initialization. */
|
comments; all other lines are commands for readline initialization. */
|
current_readline_init_lineno = 1;
|
current_readline_init_lineno = 1;
|
line = buffer;
|
line = buffer;
|
end = buffer + file_size;
|
end = buffer + file_size;
|
while (line < end)
|
while (line < end)
|
{
|
{
|
/* Find the end of this line. */
|
/* Find the end of this line. */
|
for (i = 0; line + i != end && line[i] != '\n'; i++);
|
for (i = 0; line + i != end && line[i] != '\n'; i++);
|
|
|
#if defined (__CYGWIN__)
|
#if defined (__CYGWIN__)
|
/* ``Be liberal in what you accept.'' */
|
/* ``Be liberal in what you accept.'' */
|
if (line[i] == '\n' && line[i-1] == '\r')
|
if (line[i] == '\n' && line[i-1] == '\r')
|
line[i - 1] = '\0';
|
line[i - 1] = '\0';
|
#endif
|
#endif
|
|
|
/* Mark end of line. */
|
/* Mark end of line. */
|
line[i] = '\0';
|
line[i] = '\0';
|
|
|
/* Skip leading whitespace. */
|
/* Skip leading whitespace. */
|
while (*line && whitespace (*line))
|
while (*line && whitespace (*line))
|
{
|
{
|
line++;
|
line++;
|
i--;
|
i--;
|
}
|
}
|
|
|
/* If the line is not a comment, then parse it. */
|
/* If the line is not a comment, then parse it. */
|
if (*line && *line != '#')
|
if (*line && *line != '#')
|
rl_parse_and_bind (line);
|
rl_parse_and_bind (line);
|
|
|
/* Move to the next line. */
|
/* Move to the next line. */
|
line += i + 1;
|
line += i + 1;
|
current_readline_init_lineno++;
|
current_readline_init_lineno++;
|
}
|
}
|
|
|
free (buffer);
|
free (buffer);
|
currently_reading_init_file = 0;
|
currently_reading_init_file = 0;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
static void
|
static void
|
_rl_init_file_error (msg)
|
_rl_init_file_error (msg)
|
const char *msg;
|
const char *msg;
|
{
|
{
|
if (currently_reading_init_file)
|
if (currently_reading_init_file)
|
fprintf (stderr, "readline: %s: line %d: %s\n", current_readline_init_file,
|
fprintf (stderr, "readline: %s: line %d: %s\n", current_readline_init_file,
|
current_readline_init_lineno, msg);
|
current_readline_init_lineno, msg);
|
else
|
else
|
fprintf (stderr, "readline: %s\n", msg);
|
fprintf (stderr, "readline: %s\n", msg);
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Parser Directives */
|
/* Parser Directives */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
typedef int _rl_parser_func_t PARAMS((char *));
|
typedef int _rl_parser_func_t PARAMS((char *));
|
|
|
/* Things that mean `Control'. */
|
/* Things that mean `Control'. */
|
const char *_rl_possible_control_prefixes[] = {
|
const char *_rl_possible_control_prefixes[] = {
|
"Control-", "C-", "CTRL-", (const char *)NULL
|
"Control-", "C-", "CTRL-", (const char *)NULL
|
};
|
};
|
|
|
const char *_rl_possible_meta_prefixes[] = {
|
const char *_rl_possible_meta_prefixes[] = {
|
"Meta", "M-", (const char *)NULL
|
"Meta", "M-", (const char *)NULL
|
};
|
};
|
|
|
/* Conditionals. */
|
/* Conditionals. */
|
|
|
/* Calling programs set this to have their argv[0]. */
|
/* Calling programs set this to have their argv[0]. */
|
const char *rl_readline_name = "other";
|
const char *rl_readline_name = "other";
|
|
|
/* Stack of previous values of parsing_conditionalized_out. */
|
/* Stack of previous values of parsing_conditionalized_out. */
|
static unsigned char *if_stack = (unsigned char *)NULL;
|
static unsigned char *if_stack = (unsigned char *)NULL;
|
static int if_stack_depth;
|
static int if_stack_depth;
|
static int if_stack_size;
|
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 (args)
|
char *args;
|
char *args;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
/* Push parser state. */
|
/* Push parser state. */
|
if (if_stack_depth + 1 >= if_stack_size)
|
if (if_stack_depth + 1 >= if_stack_size)
|
{
|
{
|
if (!if_stack)
|
if (!if_stack)
|
if_stack = (unsigned char *)xmalloc (if_stack_size = 20);
|
if_stack = (unsigned char *)xmalloc (if_stack_size = 20);
|
else
|
else
|
if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20);
|
if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20);
|
}
|
}
|
if_stack[if_stack_depth++] = _rl_parsing_conditionalized_out;
|
if_stack[if_stack_depth++] = _rl_parsing_conditionalized_out;
|
|
|
/* If parsing is turned off, then nothing can turn it back on except
|
/* If parsing is turned off, then nothing can turn it back on except
|
for finding the matching endif. In that case, return right now. */
|
for finding the matching endif. In that case, return right now. */
|
if (_rl_parsing_conditionalized_out)
|
if (_rl_parsing_conditionalized_out)
|
return 0;
|
return 0;
|
|
|
/* Isolate first argument. */
|
/* Isolate first argument. */
|
for (i = 0; args[i] && !whitespace (args[i]); i++);
|
for (i = 0; args[i] && !whitespace (args[i]); i++);
|
|
|
if (args[i])
|
if (args[i])
|
args[i++] = '\0';
|
args[i++] = '\0';
|
|
|
/* Handle "$if term=foo" and "$if mode=emacs" constructs. If this
|
/* Handle "$if term=foo" and "$if mode=emacs" constructs. If this
|
isn't term=foo, or mode=emacs, then check to see if the first
|
isn't term=foo, or mode=emacs, then check to see if the first
|
word in ARGS is the same as the value stored in rl_readline_name. */
|
word in ARGS is the same as the value stored in rl_readline_name. */
|
if (rl_terminal_name && _rl_strnicmp (args, "term=", 5) == 0)
|
if (rl_terminal_name && _rl_strnicmp (args, "term=", 5) == 0)
|
{
|
{
|
char *tem, *tname;
|
char *tem, *tname;
|
|
|
/* Terminals like "aaa-60" are equivalent to "aaa". */
|
/* Terminals like "aaa-60" are equivalent to "aaa". */
|
tname = savestring (rl_terminal_name);
|
tname = savestring (rl_terminal_name);
|
tem = strchr (tname, '-');
|
tem = strchr (tname, '-');
|
if (tem)
|
if (tem)
|
*tem = '\0';
|
*tem = '\0';
|
|
|
/* Test the `long' and `short' forms of the terminal name so that
|
/* Test the `long' and `short' forms of the terminal name so that
|
if someone has a `sun-cmd' and does not want to have bindings
|
if someone has a `sun-cmd' and does not want to have bindings
|
that will be executed if the terminal is a `sun', they can put
|
that will be executed if the terminal is a `sun', they can put
|
`$if term=sun-cmd' into their .inputrc. */
|
`$if term=sun-cmd' into their .inputrc. */
|
_rl_parsing_conditionalized_out = _rl_stricmp (args + 5, tname) &&
|
_rl_parsing_conditionalized_out = _rl_stricmp (args + 5, tname) &&
|
_rl_stricmp (args + 5, rl_terminal_name);
|
_rl_stricmp (args + 5, rl_terminal_name);
|
free (tname);
|
free (tname);
|
}
|
}
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
else if (_rl_strnicmp (args, "mode=", 5) == 0)
|
else if (_rl_strnicmp (args, "mode=", 5) == 0)
|
{
|
{
|
int mode;
|
int mode;
|
|
|
if (_rl_stricmp (args + 5, "emacs") == 0)
|
if (_rl_stricmp (args + 5, "emacs") == 0)
|
mode = emacs_mode;
|
mode = emacs_mode;
|
else if (_rl_stricmp (args + 5, "vi") == 0)
|
else if (_rl_stricmp (args + 5, "vi") == 0)
|
mode = vi_mode;
|
mode = vi_mode;
|
else
|
else
|
mode = no_mode;
|
mode = no_mode;
|
|
|
_rl_parsing_conditionalized_out = mode != rl_editing_mode;
|
_rl_parsing_conditionalized_out = mode != rl_editing_mode;
|
}
|
}
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
/* 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
|
else
|
_rl_parsing_conditionalized_out = 1;
|
_rl_parsing_conditionalized_out = 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* 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 (args)
|
char *args;
|
char *args;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
if (if_stack_depth == 0)
|
if (if_stack_depth == 0)
|
{
|
{
|
_rl_init_file_error ("$else found without matching $if");
|
_rl_init_file_error ("$else found without matching $if");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#if 0
|
#if 0
|
/* Check the previous (n - 1) levels of the stack to make sure that
|
/* Check the previous (n - 1) levels of the stack to make sure that
|
we haven't previously turned off parsing. */
|
we haven't previously turned off parsing. */
|
for (i = 0; i < if_stack_depth - 1; i++)
|
for (i = 0; i < if_stack_depth - 1; i++)
|
#else
|
#else
|
/* Check the previous (n) levels of the stack to make sure that
|
/* Check the previous (n) levels of the stack to make sure that
|
we haven't previously turned off parsing. */
|
we haven't previously turned off parsing. */
|
for (i = 0; i < if_stack_depth; i++)
|
for (i = 0; i < if_stack_depth; i++)
|
#endif
|
#endif
|
if (if_stack[i] == 1)
|
if (if_stack[i] == 1)
|
return 0;
|
return 0;
|
|
|
/* Invert the state of parsing if at top level. */
|
/* Invert the state of parsing if at top level. */
|
_rl_parsing_conditionalized_out = !_rl_parsing_conditionalized_out;
|
_rl_parsing_conditionalized_out = !_rl_parsing_conditionalized_out;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* 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 (args)
|
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];
|
else
|
else
|
_rl_init_file_error ("$endif without matching $if");
|
_rl_init_file_error ("$endif without matching $if");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
parser_include (args)
|
parser_include (args)
|
char *args;
|
char *args;
|
{
|
{
|
const char *old_init_file;
|
const char *old_init_file;
|
char *e;
|
char *e;
|
int old_line_number, old_include_level, r;
|
int old_line_number, old_include_level, r;
|
|
|
if (_rl_parsing_conditionalized_out)
|
if (_rl_parsing_conditionalized_out)
|
return (0);
|
return (0);
|
|
|
old_init_file = current_readline_init_file;
|
old_init_file = current_readline_init_file;
|
old_line_number = current_readline_init_lineno;
|
old_line_number = current_readline_init_lineno;
|
old_include_level = current_readline_init_include_level;
|
old_include_level = current_readline_init_include_level;
|
|
|
e = strchr (args, '\n');
|
e = strchr (args, '\n');
|
if (e)
|
if (e)
|
*e = '\0';
|
*e = '\0';
|
r = _rl_read_init_file ((const char *)args, old_include_level + 1);
|
r = _rl_read_init_file ((const char *)args, old_include_level + 1);
|
|
|
current_readline_init_file = old_init_file;
|
current_readline_init_file = old_init_file;
|
current_readline_init_lineno = old_line_number;
|
current_readline_init_lineno = old_line_number;
|
current_readline_init_include_level = old_include_level;
|
current_readline_init_include_level = old_include_level;
|
|
|
return r;
|
return r;
|
}
|
}
|
|
|
/* Associate textual names with actual functions. */
|
/* Associate textual names with actual functions. */
|
static struct {
|
static struct {
|
const char *name;
|
const char *name;
|
_rl_parser_func_t *function;
|
_rl_parser_func_t *function;
|
} parser_directives [] = {
|
} parser_directives [] = {
|
{ "if", parser_if },
|
{ "if", parser_if },
|
{ "endif", parser_endif },
|
{ "endif", parser_endif },
|
{ "else", parser_else },
|
{ "else", parser_else },
|
{ "include", parser_include },
|
{ "include", parser_include },
|
{ (char *)0x0, (_rl_parser_func_t *)0x0 }
|
{ (char *)0x0, (_rl_parser_func_t *)0x0 }
|
};
|
};
|
|
|
/* 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 (statement)
|
char *statement;
|
char *statement;
|
{
|
{
|
register int i;
|
register int i;
|
char *directive, *args;
|
char *directive, *args;
|
|
|
/* Isolate the actual directive. */
|
/* Isolate the actual directive. */
|
|
|
/* Skip whitespace. */
|
/* Skip whitespace. */
|
for (i = 0; whitespace (statement[i]); i++);
|
for (i = 0; whitespace (statement[i]); i++);
|
|
|
directive = &statement[i];
|
directive = &statement[i];
|
|
|
for (; statement[i] && !whitespace (statement[i]); i++);
|
for (; statement[i] && !whitespace (statement[i]); i++);
|
|
|
if (statement[i])
|
if (statement[i])
|
statement[i++] = '\0';
|
statement[i++] = '\0';
|
|
|
for (; statement[i] && whitespace (statement[i]); i++);
|
for (; statement[i] && whitespace (statement[i]); i++);
|
|
|
args = &statement[i];
|
args = &statement[i];
|
|
|
/* Lookup the command, and act on it. */
|
/* Lookup the command, and act on it. */
|
for (i = 0; parser_directives[i].name; i++)
|
for (i = 0; parser_directives[i].name; i++)
|
if (_rl_stricmp (directive, parser_directives[i].name) == 0)
|
if (_rl_stricmp (directive, parser_directives[i].name) == 0)
|
{
|
{
|
(*parser_directives[i].function) (args);
|
(*parser_directives[i].function) (args);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* 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 ("unknown parser directive");
|
return (1);
|
return (1);
|
}
|
}
|
|
|
/* Read the binding command from STRING and perform it.
|
/* Read the binding command from STRING and perform it.
|
A key binding command looks like: Keyname: function-name\0,
|
A key binding command looks like: Keyname: function-name\0,
|
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 (string)
|
char *string;
|
char *string;
|
{
|
{
|
char *funname, *kname;
|
char *funname, *kname;
|
register int c, i;
|
register int c, i;
|
int key, equivalency;
|
int key, equivalency;
|
|
|
while (string && whitespace (*string))
|
while (string && whitespace (*string))
|
string++;
|
string++;
|
|
|
if (!string || !*string || *string == '#')
|
if (!string || !*string || *string == '#')
|
return 0;
|
return 0;
|
|
|
/* If this is a parser directive, act on it. */
|
/* If this is a parser directive, act on it. */
|
if (*string == '$')
|
if (*string == '$')
|
{
|
{
|
handle_parser_directive (&string[1]);
|
handle_parser_directive (&string[1]);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* If we aren't supposed to be parsing right now, then we're done. */
|
/* If we aren't supposed to be parsing right now, then we're done. */
|
if (_rl_parsing_conditionalized_out)
|
if (_rl_parsing_conditionalized_out)
|
return 0;
|
return 0;
|
|
|
i = 0;
|
i = 0;
|
/* If this keyname is a complex key expression surrounded by quotes,
|
/* If this keyname is a complex key expression surrounded by quotes,
|
advance to after the matching close quote. This code allows the
|
advance to after the matching close quote. This code allows the
|
backslash to quote characters in the key expression. */
|
backslash to quote characters in the key expression. */
|
if (*string == '"')
|
if (*string == '"')
|
{
|
{
|
int passc = 0;
|
int passc = 0;
|
|
|
for (i = 1; c = string[i]; i++)
|
for (i = 1; c = string[i]; i++)
|
{
|
{
|
if (passc)
|
if (passc)
|
{
|
{
|
passc = 0;
|
passc = 0;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (c == '\\')
|
if (c == '\\')
|
{
|
{
|
passc++;
|
passc++;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (c == '"')
|
if (c == '"')
|
break;
|
break;
|
}
|
}
|
/* 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 ("no closing `\"' in key binding");
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
/* 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++ );
|
|
|
equivalency = (c == ':' && string[i + 1] == '=');
|
equivalency = (c == ':' && string[i + 1] == '=');
|
|
|
/* 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';
|
|
|
/* If doing assignment, skip the '=' sign as well. */
|
/* If doing assignment, skip the '=' sign as well. */
|
if (equivalency)
|
if (equivalency)
|
string[i++] = '\0';
|
string[i++] = '\0';
|
|
|
/* If this is a command to set a variable, then do that. */
|
/* If this is a command to set a variable, then do that. */
|
if (_rl_stricmp (string, "set") == 0)
|
if (_rl_stricmp (string, "set") == 0)
|
{
|
{
|
char *var, *value, *e;
|
char *var, *value, *e;
|
|
|
var = string + i;
|
var = string + i;
|
/* Make VAR point to start of variable name. */
|
/* Make VAR point to start of variable name. */
|
while (*var && whitespace (*var)) var++;
|
while (*var && whitespace (*var)) var++;
|
|
|
/* Make VALUE point to start of value string. */
|
/* Make VALUE point to start of value string. */
|
value = var;
|
value = var;
|
while (*value && !whitespace (*value)) value++;
|
while (*value && !whitespace (*value)) value++;
|
if (*value)
|
if (*value)
|
*value++ = '\0';
|
*value++ = '\0';
|
while (*value && whitespace (*value)) value++;
|
while (*value && whitespace (*value)) value++;
|
|
|
/* Strip trailing whitespace from values to boolean variables. Temp
|
/* Strip trailing whitespace from values to boolean variables. Temp
|
fix until I get a real quoted-string parser here. */
|
fix until I get a real quoted-string parser here. */
|
i = find_boolean_var (var);
|
i = find_boolean_var (var);
|
if (i >= 0)
|
if (i >= 0)
|
{
|
{
|
/* remove trailing whitespace */
|
/* remove trailing whitespace */
|
e = value + strlen (value) - 1;
|
e = value + strlen (value) - 1;
|
while (e >= value && whitespace (*e))
|
while (e >= value && whitespace (*e))
|
e--;
|
e--;
|
e++; /* skip back to whitespace or EOS */
|
e++; /* skip back to whitespace or EOS */
|
if (*e && e >= value)
|
if (*e && e >= value)
|
*e = '\0';
|
*e = '\0';
|
}
|
}
|
|
|
rl_variable_bind (var, value);
|
rl_variable_bind (var, value);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Skip any whitespace between keyname and funname. */
|
/* Skip any whitespace between keyname and funname. */
|
for (; string[i] && whitespace (string[i]); i++);
|
for (; string[i] && whitespace (string[i]); i++);
|
funname = &string[i];
|
funname = &string[i];
|
|
|
/* Now isolate funname.
|
/* Now isolate funname.
|
For straight function names just look for whitespace, since
|
For straight function names just look for whitespace, since
|
that will signify the end of the string. But this could be a
|
that will signify the end of the string. But this could be a
|
macro definition. In that case, the string is quoted, so skip
|
macro definition. In that case, the string is quoted, so skip
|
to the matching delimiter. We allow the backslash to quote the
|
to the matching delimiter. We allow the backslash to quote the
|
delimiter characters in the macro body. */
|
delimiter characters in the macro body. */
|
/* This code exists to allow whitespace in macro expansions, which
|
/* This code exists to allow whitespace in macro expansions, which
|
would otherwise be gobbled up by the next `for' loop.*/
|
would otherwise be gobbled up by the next `for' loop.*/
|
/* XXX - it may be desirable to allow backslash quoting only if " is
|
/* XXX - it may be desirable to allow backslash quoting only if " is
|
the quoted string delimiter, like the shell. */
|
the quoted string delimiter, like the shell. */
|
if (*funname == '\'' || *funname == '"')
|
if (*funname == '\'' || *funname == '"')
|
{
|
{
|
int delimiter, passc;
|
int delimiter, passc;
|
|
|
delimiter = string[i++];
|
delimiter = string[i++];
|
for (passc = 0; c = string[i]; i++)
|
for (passc = 0; c = string[i]; i++)
|
{
|
{
|
if (passc)
|
if (passc)
|
{
|
{
|
passc = 0;
|
passc = 0;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (c == '\\')
|
if (c == '\\')
|
{
|
{
|
passc = 1;
|
passc = 1;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (c == delimiter)
|
if (c == delimiter)
|
break;
|
break;
|
}
|
}
|
if (c)
|
if (c)
|
i++;
|
i++;
|
}
|
}
|
|
|
/* Advance to the end of the string. */
|
/* Advance to the end of the string. */
|
for (; string[i] && !whitespace (string[i]); i++);
|
for (; string[i] && !whitespace (string[i]); i++);
|
|
|
/* No extra whitespace at the end of the string. */
|
/* No extra whitespace at the end of the string. */
|
string[i] = '\0';
|
string[i] = '\0';
|
|
|
/* Handle equivalency bindings here. Make the left-hand side be exactly
|
/* Handle equivalency bindings here. Make the left-hand side be exactly
|
whatever the right-hand evaluates to, including keymaps. */
|
whatever the right-hand evaluates to, including keymaps. */
|
if (equivalency)
|
if (equivalency)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* 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 == '"')
|
{
|
{
|
char *seq;
|
char *seq;
|
register int j, k, passc;
|
register int j, k, passc;
|
|
|
seq = (char *)xmalloc (1 + strlen (string));
|
seq = (char *)xmalloc (1 + strlen (string));
|
for (j = 1, k = passc = 0; string[j]; j++)
|
for (j = 1, k = passc = 0; string[j]; j++)
|
{
|
{
|
/* Allow backslash to quote characters, but leave them in place.
|
/* Allow backslash to quote characters, but leave them in place.
|
This allows a string to end with a backslash quoting another
|
This allows a string to end with a backslash quoting another
|
backslash, or with a backslash quoting a double quote. The
|
backslash, or with a backslash quoting a double quote. The
|
backslashes are left in place for rl_translate_keyseq (). */
|
backslashes are left in place for rl_translate_keyseq (). */
|
if (passc || (string[j] == '\\'))
|
if (passc || (string[j] == '\\'))
|
{
|
{
|
seq[k++] = string[j];
|
seq[k++] = string[j];
|
passc = !passc;
|
passc = !passc;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (string[j] == '"')
|
if (string[j] == '"')
|
break;
|
break;
|
|
|
seq[k++] = string[j];
|
seq[k++] = string[j];
|
}
|
}
|
seq[k] = '\0';
|
seq[k] = '\0';
|
|
|
/* Binding macro? */
|
/* Binding macro? */
|
if (*funname == '\'' || *funname == '"')
|
if (*funname == '\'' || *funname == '"')
|
{
|
{
|
j = strlen (funname);
|
j = strlen (funname);
|
|
|
/* Remove the delimiting quotes from each end of FUNNAME. */
|
/* Remove the delimiting quotes from each end of FUNNAME. */
|
if (j && funname[j - 1] == *funname)
|
if (j && funname[j - 1] == *funname)
|
funname[j - 1] = '\0';
|
funname[j - 1] = '\0';
|
|
|
rl_macro_bind (seq, &funname[1], _rl_keymap);
|
rl_macro_bind (seq, &funname[1], _rl_keymap);
|
}
|
}
|
else
|
else
|
rl_bind_keyseq (seq, rl_named_function (funname));
|
rl_bind_keyseq (seq, rl_named_function (funname));
|
|
|
free (seq);
|
free (seq);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Get the actual character we want to deal with. */
|
/* Get the actual character we want to deal with. */
|
kname = strrchr (string, '-');
|
kname = strrchr (string, '-');
|
if (!kname)
|
if (!kname)
|
kname = string;
|
kname = string;
|
else
|
else
|
kname++;
|
kname++;
|
|
|
key = glean_key_from_name (kname);
|
key = glean_key_from_name (kname);
|
|
|
/* Add in control and meta bits. */
|
/* Add in control and meta bits. */
|
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));
|
|
|
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);
|
|
|
/* Temporary. Handle old-style keyname with macro-binding. */
|
/* Temporary. Handle old-style keyname with macro-binding. */
|
if (*funname == '\'' || *funname == '"')
|
if (*funname == '\'' || *funname == '"')
|
{
|
{
|
char useq[2];
|
char useq[2];
|
int fl = strlen (funname);
|
int fl = strlen (funname);
|
|
|
useq[0] = key; useq[1] = '\0';
|
useq[0] = key; useq[1] = '\0';
|
if (fl && funname[fl - 1] == *funname)
|
if (fl && funname[fl - 1] == *funname)
|
funname[fl - 1] = '\0';
|
funname[fl - 1] = '\0';
|
|
|
rl_macro_bind (useq, &funname[1], _rl_keymap);
|
rl_macro_bind (useq, &funname[1], _rl_keymap);
|
}
|
}
|
#if defined (PREFIX_META_HACK)
|
#if defined (PREFIX_META_HACK)
|
/* Ugly, but working hack to keep prefix-meta around. */
|
/* Ugly, but working hack to keep prefix-meta around. */
|
else if (_rl_stricmp (funname, "prefix-meta") == 0)
|
else if (_rl_stricmp (funname, "prefix-meta") == 0)
|
{
|
{
|
char seq[2];
|
char seq[2];
|
|
|
seq[0] = key;
|
seq[0] = key;
|
seq[1] = '\0';
|
seq[1] = '\0';
|
rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, _rl_keymap);
|
rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, _rl_keymap);
|
}
|
}
|
#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;
|
}
|
}
|
|
|
/* Simple structure for boolean readline variables (i.e., those that can
|
/* Simple structure for boolean readline variables (i.e., those that can
|
have one of two values; either "On" or 1 for truth, or "Off" or 0 for
|
have one of two values; either "On" or 1 for truth, or "Off" or 0 for
|
false. */
|
false. */
|
|
|
#define V_SPECIAL 0x1
|
#define V_SPECIAL 0x1
|
|
|
static struct {
|
static struct {
|
const char *name;
|
const char *name;
|
int *value;
|
int *value;
|
int flags;
|
int flags;
|
} boolean_varlist [] = {
|
} boolean_varlist [] = {
|
{ "bind-tty-special-chars", &_rl_bind_stty_chars, 0 },
|
{ "bind-tty-special-chars", &_rl_bind_stty_chars, 0 },
|
{ "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 },
|
{ "completion-ignore-case", &_rl_completion_case_fold, 0 },
|
{ "completion-ignore-case", &_rl_completion_case_fold, 0 },
|
{ "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 },
|
{ "enable-keypad", &_rl_enable_keypad, 0 },
|
{ "enable-keypad", &_rl_enable_keypad, 0 },
|
{ "expand-tilde", &rl_complete_with_tilde_expansion, 0 },
|
{ "expand-tilde", &rl_complete_with_tilde_expansion, 0 },
|
{ "history-preserve-point", &_rl_history_preserve_point, 0 },
|
{ "history-preserve-point", &_rl_history_preserve_point, 0 },
|
{ "horizontal-scroll-mode", &_rl_horizontal_scroll_mode, 0 },
|
{ "horizontal-scroll-mode", &_rl_horizontal_scroll_mode, 0 },
|
{ "input-meta", &_rl_meta_flag, 0 },
|
{ "input-meta", &_rl_meta_flag, 0 },
|
{ "mark-directories", &_rl_complete_mark_directories, 0 },
|
{ "mark-directories", &_rl_complete_mark_directories, 0 },
|
{ "mark-modified-lines", &_rl_mark_modified_lines, 0 },
|
{ "mark-modified-lines", &_rl_mark_modified_lines, 0 },
|
{ "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs, 0 },
|
{ "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs, 0 },
|
{ "match-hidden-files", &_rl_match_hidden_files, 0 },
|
{ "match-hidden-files", &_rl_match_hidden_files, 0 },
|
{ "meta-flag", &_rl_meta_flag, 0 },
|
{ "meta-flag", &_rl_meta_flag, 0 },
|
{ "output-meta", &_rl_output_meta_chars, 0 },
|
{ "output-meta", &_rl_output_meta_chars, 0 },
|
{ "page-completions", &_rl_page_completions, 0 },
|
{ "page-completions", &_rl_page_completions, 0 },
|
{ "prefer-visible-bell", &_rl_prefer_visible_bell, V_SPECIAL },
|
{ "prefer-visible-bell", &_rl_prefer_visible_bell, V_SPECIAL },
|
{ "print-completions-horizontally", &_rl_print_completions_horizontally, 0 },
|
{ "print-completions-horizontally", &_rl_print_completions_horizontally, 0 },
|
{ "show-all-if-ambiguous", &_rl_complete_show_all, 0 },
|
{ "show-all-if-ambiguous", &_rl_complete_show_all, 0 },
|
{ "show-all-if-unmodified", &_rl_complete_show_unmodified, 0 },
|
{ "show-all-if-unmodified", &_rl_complete_show_unmodified, 0 },
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
{ "visible-stats", &rl_visible_stats, 0 },
|
{ "visible-stats", &rl_visible_stats, 0 },
|
#endif /* VISIBLE_STATS */
|
#endif /* VISIBLE_STATS */
|
{ (char *)NULL, (int *)NULL }
|
{ (char *)NULL, (int *)NULL }
|
};
|
};
|
|
|
static int
|
static int
|
find_boolean_var (name)
|
find_boolean_var (name)
|
const char *name;
|
const char *name;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
for (i = 0; boolean_varlist[i].name; i++)
|
for (i = 0; boolean_varlist[i].name; i++)
|
if (_rl_stricmp (name, boolean_varlist[i].name) == 0)
|
if (_rl_stricmp (name, boolean_varlist[i].name) == 0)
|
return i;
|
return i;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* 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 (i)
|
int i;
|
int i;
|
{
|
{
|
const char *name;
|
const char *name;
|
|
|
name = boolean_varlist[i].name;
|
name = boolean_varlist[i].name;
|
|
|
if (_rl_stricmp (name, "blink-matching-paren") == 0)
|
if (_rl_stricmp (name, "blink-matching-paren") == 0)
|
_rl_enable_paren_matching (rl_blink_matching_paren);
|
_rl_enable_paren_matching (rl_blink_matching_paren);
|
else if (_rl_stricmp (name, "prefer-visible-bell") == 0)
|
else if (_rl_stricmp (name, "prefer-visible-bell") == 0)
|
{
|
{
|
if (_rl_prefer_visible_bell)
|
if (_rl_prefer_visible_bell)
|
_rl_bell_preference = VISIBLE_BELL;
|
_rl_bell_preference = VISIBLE_BELL;
|
else
|
else
|
_rl_bell_preference = AUDIBLE_BELL;
|
_rl_bell_preference = AUDIBLE_BELL;
|
}
|
}
|
}
|
}
|
|
|
typedef int _rl_sv_func_t PARAMS((const char *));
|
typedef int _rl_sv_func_t PARAMS((const char *));
|
|
|
/* These *must* correspond to the array indices for the appropriate
|
/* These *must* correspond to the array indices for the appropriate
|
string variable. (Though they're not used right now.) */
|
string variable. (Though they're not used right now.) */
|
#define V_BELLSTYLE 0
|
#define V_BELLSTYLE 0
|
#define V_COMBEGIN 1
|
#define V_COMBEGIN 1
|
#define V_EDITMODE 2
|
#define V_EDITMODE 2
|
#define V_ISRCHTERM 3
|
#define V_ISRCHTERM 3
|
#define V_KEYMAP 4
|
#define V_KEYMAP 4
|
|
|
#define V_STRING 1
|
#define V_STRING 1
|
#define V_INT 2
|
#define V_INT 2
|
|
|
/* Forward declarations */
|
/* Forward declarations */
|
static int sv_bell_style PARAMS((const char *));
|
static int sv_bell_style PARAMS((const char *));
|
static int sv_combegin PARAMS((const char *));
|
static int sv_combegin PARAMS((const char *));
|
static int sv_compquery PARAMS((const char *));
|
static int sv_compquery PARAMS((const char *));
|
static int sv_editmode PARAMS((const char *));
|
static int sv_editmode 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 struct {
|
static struct {
|
const char *name;
|
const char *name;
|
int flags;
|
int flags;
|
_rl_sv_func_t *set_func;
|
_rl_sv_func_t *set_func;
|
} string_varlist[] = {
|
} string_varlist[] = {
|
{ "bell-style", V_STRING, sv_bell_style },
|
{ "bell-style", V_STRING, sv_bell_style },
|
{ "comment-begin", V_STRING, sv_combegin },
|
{ "comment-begin", V_STRING, sv_combegin },
|
{ "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 },
|
{ "isearch-terminators", V_STRING, sv_isrchterm },
|
{ "isearch-terminators", V_STRING, sv_isrchterm },
|
{ "keymap", V_STRING, sv_keymap },
|
{ "keymap", V_STRING, sv_keymap },
|
{ (char *)NULL, 0 }
|
{ (char *)NULL, 0 }
|
};
|
};
|
|
|
static int
|
static int
|
find_string_var (name)
|
find_string_var (name)
|
const char *name;
|
const char *name;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
for (i = 0; string_varlist[i].name; i++)
|
for (i = 0; string_varlist[i].name; i++)
|
if (_rl_stricmp (name, string_varlist[i].name) == 0)
|
if (_rl_stricmp (name, string_varlist[i].name) == 0)
|
return i;
|
return i;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* 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-insenstive), or "1". Any other
|
values result in 0 (false). */
|
values result in 0 (false). */
|
static int
|
static int
|
bool_to_int (value)
|
bool_to_int (value)
|
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) ||
|
(value[0] == '1' && value[1] == '\0'));
|
(value[0] == '1' && value[1] == '\0'));
|
}
|
}
|
|
|
char *
|
char *
|
rl_variable_value (name)
|
rl_variable_value (name)
|
const char *name;
|
const char *name;
|
{
|
{
|
register int i;
|
register int i;
|
int v;
|
int v;
|
char *ret;
|
char *ret;
|
|
|
/* Check for simple variables first. */
|
/* Check for simple variables first. */
|
i = find_boolean_var (name);
|
i = find_boolean_var (name);
|
if (i >= 0)
|
if (i >= 0)
|
return (*boolean_varlist[i].value ? "on" : "off");
|
return (*boolean_varlist[i].value ? "on" : "off");
|
|
|
i = find_string_var (name);
|
i = find_string_var (name);
|
if (i >= 0)
|
if (i >= 0)
|
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 0;
|
}
|
}
|
|
|
int
|
int
|
rl_variable_bind (name, value)
|
rl_variable_bind (name, value)
|
const char *name, *value;
|
const char *name, *value;
|
{
|
{
|
register int i;
|
register int i;
|
int v;
|
int v;
|
|
|
/* Check for simple variables first. */
|
/* Check for simple variables first. */
|
i = find_boolean_var (name);
|
i = find_boolean_var (name);
|
if (i >= 0)
|
if (i >= 0)
|
{
|
{
|
*boolean_varlist[i].value = bool_to_int (value);
|
*boolean_varlist[i].value = bool_to_int (value);
|
if (boolean_varlist[i].flags & V_SPECIAL)
|
if (boolean_varlist[i].flags & V_SPECIAL)
|
hack_special_boolean_var (i);
|
hack_special_boolean_var (i);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
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, unknown variable names or string names without a
|
handler function are simply ignored. */
|
handler function are simply ignored. */
|
if (i < 0 || string_varlist[i].set_func == 0)
|
if (i < 0 || string_varlist[i].set_func == 0)
|
return 0;
|
return 0;
|
|
|
v = (*string_varlist[i].set_func) (value);
|
v = (*string_varlist[i].set_func) (value);
|
return v;
|
return v;
|
}
|
}
|
|
|
static int
|
static int
|
sv_editmode (value)
|
sv_editmode (value)
|
const char *value;
|
const char *value;
|
{
|
{
|
if (_rl_strnicmp (value, "vi", 2) == 0)
|
if (_rl_strnicmp (value, "vi", 2) == 0)
|
{
|
{
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
_rl_keymap = vi_insertion_keymap;
|
_rl_keymap = vi_insertion_keymap;
|
rl_editing_mode = vi_mode;
|
rl_editing_mode = vi_mode;
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
return 0;
|
return 0;
|
}
|
}
|
else if (_rl_strnicmp (value, "emacs", 5) == 0)
|
else if (_rl_strnicmp (value, "emacs", 5) == 0)
|
{
|
{
|
_rl_keymap = emacs_standard_keymap;
|
_rl_keymap = emacs_standard_keymap;
|
rl_editing_mode = emacs_mode;
|
rl_editing_mode = emacs_mode;
|
return 0;
|
return 0;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static int
|
static int
|
sv_combegin (value)
|
sv_combegin (value)
|
const char *value;
|
const char *value;
|
{
|
{
|
if (value && *value)
|
if (value && *value)
|
{
|
{
|
FREE (_rl_comment_begin);
|
FREE (_rl_comment_begin);
|
_rl_comment_begin = savestring (value);
|
_rl_comment_begin = savestring (value);
|
return 0;
|
return 0;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static int
|
static int
|
sv_compquery (value)
|
sv_compquery (value)
|
const char *value;
|
const char *value;
|
{
|
{
|
int nval = 100;
|
int nval = 100;
|
|
|
if (value && *value)
|
if (value && *value)
|
{
|
{
|
nval = atoi (value);
|
nval = atoi (value);
|
if (nval < 0)
|
if (nval < 0)
|
nval = 0;
|
nval = 0;
|
}
|
}
|
rl_completion_query_items = nval;
|
rl_completion_query_items = nval;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
sv_keymap (value)
|
sv_keymap (value)
|
const char *value;
|
const char *value;
|
{
|
{
|
Keymap kmap;
|
Keymap kmap;
|
|
|
kmap = rl_get_keymap_by_name (value);
|
kmap = rl_get_keymap_by_name (value);
|
if (kmap)
|
if (kmap)
|
{
|
{
|
rl_set_keymap (kmap);
|
rl_set_keymap (kmap);
|
return 0;
|
return 0;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static int
|
static int
|
sv_bell_style (value)
|
sv_bell_style (value)
|
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;
|
else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
|
else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
|
_rl_bell_preference = NO_BELL;
|
_rl_bell_preference = NO_BELL;
|
else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
|
else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
|
_rl_bell_preference = AUDIBLE_BELL;
|
_rl_bell_preference = AUDIBLE_BELL;
|
else if (_rl_stricmp (value, "visible") == 0)
|
else if (_rl_stricmp (value, "visible") == 0)
|
_rl_bell_preference = VISIBLE_BELL;
|
_rl_bell_preference = VISIBLE_BELL;
|
else
|
else
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
sv_isrchterm (value)
|
sv_isrchterm (value)
|
const char *value;
|
const char *value;
|
{
|
{
|
int beg, end, delim;
|
int beg, end, delim;
|
char *v;
|
char *v;
|
|
|
if (value == 0)
|
if (value == 0)
|
return 1;
|
return 1;
|
|
|
/* Isolate the value and translate it into a character string. */
|
/* Isolate the value and translate it into a character string. */
|
v = savestring (value);
|
v = savestring (value);
|
FREE (_rl_isearch_terminators);
|
FREE (_rl_isearch_terminators);
|
if (v[0] == '"' || v[0] == '\'')
|
if (v[0] == '"' || v[0] == '\'')
|
{
|
{
|
delim = v[0];
|
delim = v[0];
|
for (beg = end = 1; v[end] && v[end] != delim; end++)
|
for (beg = end = 1; v[end] && v[end] != delim; end++)
|
;
|
;
|
}
|
}
|
else
|
else
|
{
|
{
|
for (beg = end = 0; whitespace (v[end]) == 0; end++)
|
for (beg = end = 0; whitespace (v[end]) == 0; end++)
|
;
|
;
|
}
|
}
|
|
|
v[end] = '\0';
|
v[end] = '\0';
|
|
|
/* The value starts at v + beg. Translate it into a character string. */
|
/* The value starts at v + beg. Translate it into a character string. */
|
_rl_isearch_terminators = (char *)xmalloc (2 * strlen (v) + 1);
|
_rl_isearch_terminators = (char *)xmalloc (2 * strlen (v) + 1);
|
rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
|
rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
|
_rl_isearch_terminators[end] = '\0';
|
_rl_isearch_terminators[end] = '\0';
|
|
|
free (v);
|
free (v);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the character which matches NAME.
|
/* Return the character which matches NAME.
|
For example, `Space' returns ' '. */
|
For example, `Space' returns ' '. */
|
|
|
typedef struct {
|
typedef struct {
|
const char *name;
|
const char *name;
|
int value;
|
int value;
|
} assoc_list;
|
} assoc_list;
|
|
|
static assoc_list name_key_alist[] = {
|
static assoc_list name_key_alist[] = {
|
{ "DEL", 0x7f },
|
{ "DEL", 0x7f },
|
{ "ESC", '\033' },
|
{ "ESC", '\033' },
|
{ "Escape", '\033' },
|
{ "Escape", '\033' },
|
{ "LFD", '\n' },
|
{ "LFD", '\n' },
|
{ "Newline", '\n' },
|
{ "Newline", '\n' },
|
{ "RET", '\r' },
|
{ "RET", '\r' },
|
{ "Return", '\r' },
|
{ "Return", '\r' },
|
{ "Rubout", 0x7f },
|
{ "Rubout", 0x7f },
|
{ "SPC", ' ' },
|
{ "SPC", ' ' },
|
{ "Space", ' ' },
|
{ "Space", ' ' },
|
{ "Tab", 0x09 },
|
{ "Tab", 0x09 },
|
{ (char *)0x0, 0 }
|
{ (char *)0x0, 0 }
|
};
|
};
|
|
|
static int
|
static int
|
glean_key_from_name (name)
|
glean_key_from_name (name)
|
char *name;
|
char *name;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
for (i = 0; name_key_alist[i].name; i++)
|
for (i = 0; name_key_alist[i].name; i++)
|
if (_rl_stricmp (name, name_key_alist[i].name) == 0)
|
if (_rl_stricmp (name, name_key_alist[i].name) == 0)
|
return (name_key_alist[i].value);
|
return (name_key_alist[i].value);
|
|
|
return (*(unsigned char *)name); /* XXX was return (*name) */
|
return (*(unsigned char *)name); /* XXX was return (*name) */
|
}
|
}
|
|
|
/* Auxiliary functions to manage keymaps. */
|
/* Auxiliary functions to manage keymaps. */
|
static struct {
|
static struct {
|
const char *name;
|
const char *name;
|
Keymap map;
|
Keymap map;
|
} keymap_names[] = {
|
} 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 },
|
{ "emacs-ctlx", emacs_ctlx_keymap },
|
{ "emacs-ctlx", emacs_ctlx_keymap },
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
{ "vi", vi_movement_keymap },
|
{ "vi", vi_movement_keymap },
|
{ "vi-move", vi_movement_keymap },
|
{ "vi-move", vi_movement_keymap },
|
{ "vi-command", vi_movement_keymap },
|
{ "vi-command", vi_movement_keymap },
|
{ "vi-insert", vi_insertion_keymap },
|
{ "vi-insert", vi_insertion_keymap },
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
{ (char *)0x0, (Keymap)0x0 }
|
{ (char *)0x0, (Keymap)0x0 }
|
};
|
};
|
|
|
Keymap
|
Keymap
|
rl_get_keymap_by_name (name)
|
rl_get_keymap_by_name (name)
|
const char *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 (keymap_names[i].map);
|
return ((Keymap) NULL);
|
return ((Keymap) NULL);
|
}
|
}
|
|
|
char *
|
char *
|
rl_get_keymap_name (map)
|
rl_get_keymap_name (map)
|
Keymap 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 ((char *)keymap_names[i].name);
|
return ((char *)NULL);
|
return ((char *)NULL);
|
}
|
}
|
|
|
void
|
void
|
rl_set_keymap (map)
|
rl_set_keymap (map)
|
Keymap map;
|
Keymap map;
|
{
|
{
|
if (map)
|
if (map)
|
_rl_keymap = map;
|
_rl_keymap = map;
|
}
|
}
|
|
|
Keymap
|
Keymap
|
rl_get_keymap ()
|
rl_get_keymap ()
|
{
|
{
|
return (_rl_keymap);
|
return (_rl_keymap);
|
}
|
}
|
|
|
void
|
void
|
rl_set_keymap_from_edit_mode ()
|
rl_set_keymap_from_edit_mode ()
|
{
|
{
|
if (rl_editing_mode == emacs_mode)
|
if (rl_editing_mode == emacs_mode)
|
_rl_keymap = emacs_standard_keymap;
|
_rl_keymap = emacs_standard_keymap;
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
else if (rl_editing_mode == vi_mode)
|
else if (rl_editing_mode == vi_mode)
|
_rl_keymap = vi_insertion_keymap;
|
_rl_keymap = vi_insertion_keymap;
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
}
|
}
|
|
|
char *
|
char *
|
rl_get_keymap_name_from_edit_mode ()
|
rl_get_keymap_name_from_edit_mode ()
|
{
|
{
|
if (rl_editing_mode == emacs_mode)
|
if (rl_editing_mode == emacs_mode)
|
return "emacs";
|
return "emacs";
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
else if (rl_editing_mode == vi_mode)
|
else if (rl_editing_mode == vi_mode)
|
return "vi";
|
return "vi";
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
else
|
else
|
return "none";
|
return "none";
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Key Binding and Function Information */
|
/* Key Binding and Function Information */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Each of the following functions produces information about the
|
/* Each of the following functions produces information about the
|
state of keybindings and functions known to Readline. The info
|
state of keybindings and functions known to Readline. The info
|
is always printed to rl_outstream, and in such a way that it can
|
is always printed to rl_outstream, and in such a way that it can
|
be read back in (i.e., passed to rl_parse_and_bind ()). */
|
be read back in (i.e., passed to rl_parse_and_bind ()). */
|
|
|
/* 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 ()
|
{
|
{
|
register int i;
|
register int i;
|
const char **funmap_names;
|
const char **funmap_names;
|
|
|
funmap_names = rl_funmap_names ();
|
funmap_names = rl_funmap_names ();
|
|
|
if (!funmap_names)
|
if (!funmap_names)
|
return;
|
return;
|
|
|
for (i = 0; funmap_names[i]; i++)
|
for (i = 0; funmap_names[i]; i++)
|
fprintf (rl_outstream, "%s\n", funmap_names[i]);
|
fprintf (rl_outstream, "%s\n", funmap_names[i]);
|
|
|
free (funmap_names);
|
free (funmap_names);
|
}
|
}
|
|
|
static char *
|
static char *
|
_rl_get_keyname (key)
|
_rl_get_keyname (key)
|
int key;
|
int key;
|
{
|
{
|
char *keyname;
|
char *keyname;
|
int i, c;
|
int i, c;
|
|
|
keyname = (char *)xmalloc (8);
|
keyname = (char *)xmalloc (8);
|
|
|
c = key;
|
c = key;
|
/* Since this is going to be used to write out keysequence-function
|
/* Since this is going to be used to write out keysequence-function
|
pairs for possible inclusion in an inputrc file, we don't want to
|
pairs for possible inclusion in an inputrc file, we don't want to
|
do any special meta processing on KEY. */
|
do any special meta processing on KEY. */
|
|
|
#if 1
|
#if 1
|
/* XXX - Experimental */
|
/* XXX - Experimental */
|
/* We might want to do this, but the old version of the code did not. */
|
/* We might want to do this, but the old version of the code did not. */
|
|
|
/* If this is an escape character, we don't want to do any more processing.
|
/* If this is an escape character, we don't want to do any more processing.
|
Just add the special ESC key sequence and return. */
|
Just add the special ESC key sequence and return. */
|
if (c == ESC)
|
if (c == ESC)
|
{
|
{
|
keyname[0] = '\\';
|
keyname[0] = '\\';
|
keyname[1] = 'e';
|
keyname[1] = 'e';
|
keyname[2] = '\0';
|
keyname[2] = '\0';
|
return keyname;
|
return keyname;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* RUBOUT is translated directly into \C-? */
|
/* RUBOUT is translated directly into \C-? */
|
if (key == RUBOUT)
|
if (key == RUBOUT)
|
{
|
{
|
keyname[0] = '\\';
|
keyname[0] = '\\';
|
keyname[1] = 'C';
|
keyname[1] = 'C';
|
keyname[2] = '-';
|
keyname[2] = '-';
|
keyname[3] = '?';
|
keyname[3] = '?';
|
keyname[4] = '\0';
|
keyname[4] = '\0';
|
return keyname;
|
return keyname;
|
}
|
}
|
|
|
i = 0;
|
i = 0;
|
/* Now add special prefixes needed for control characters. This can
|
/* Now add special prefixes needed for control characters. This can
|
potentially change C. */
|
potentially change C. */
|
if (CTRL_CHAR (c))
|
if (CTRL_CHAR (c))
|
{
|
{
|
keyname[i++] = '\\';
|
keyname[i++] = '\\';
|
keyname[i++] = 'C';
|
keyname[i++] = 'C';
|
keyname[i++] = '-';
|
keyname[i++] = '-';
|
c = _rl_to_lower (UNCTRL (c));
|
c = _rl_to_lower (UNCTRL (c));
|
}
|
}
|
|
|
/* XXX experimental code. Turn the characters that are not ASCII or
|
/* XXX experimental code. Turn the characters that are not ASCII or
|
ISO Latin 1 (128 - 159) into octal escape sequences (\200 - \237).
|
ISO Latin 1 (128 - 159) into octal escape sequences (\200 - \237).
|
This changes C. */
|
This changes C. */
|
if (c >= 128 && c <= 159)
|
if (c >= 128 && c <= 159)
|
{
|
{
|
keyname[i++] = '\\';
|
keyname[i++] = '\\';
|
keyname[i++] = '2';
|
keyname[i++] = '2';
|
c -= 128;
|
c -= 128;
|
keyname[i++] = (c / 8) + '0';
|
keyname[i++] = (c / 8) + '0';
|
c = (c % 8) + '0';
|
c = (c % 8) + '0';
|
}
|
}
|
|
|
/* Now, if the character needs to be quoted with a backslash, do that. */
|
/* Now, if the character needs to be quoted with a backslash, do that. */
|
if (c == '\\' || c == '"')
|
if (c == '\\' || c == '"')
|
keyname[i++] = '\\';
|
keyname[i++] = '\\';
|
|
|
/* Now add the key, terminate the string, and return it. */
|
/* Now add the key, terminate the string, and return it. */
|
keyname[i++] = (char) c;
|
keyname[i++] = (char) c;
|
keyname[i] = '\0';
|
keyname[i] = '\0';
|
|
|
return keyname;
|
return keyname;
|
}
|
}
|
|
|
/* 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 (function, map)
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
register int key;
|
register int key;
|
char **result;
|
char **result;
|
int result_index, result_size;
|
int result_index, result_size;
|
|
|
result = (char **)NULL;
|
result = (char **)NULL;
|
result_index = result_size = 0;
|
result_index = result_size = 0;
|
|
|
for (key = 0; key < KEYMAP_SIZE; key++)
|
for (key = 0; key < KEYMAP_SIZE; key++)
|
{
|
{
|
switch (map[key].type)
|
switch (map[key].type)
|
{
|
{
|
case ISMACR:
|
case ISMACR:
|
/* Macros match, if, and only if, the pointers are identical.
|
/* Macros match, if, and only if, the pointers are identical.
|
Thus, they are treated exactly like functions in here. */
|
Thus, they are treated exactly like functions in here. */
|
case ISFUNC:
|
case ISFUNC:
|
/* If the function in the keymap is the one we are looking for,
|
/* If the function in the keymap is the one we are looking for,
|
then add the current KEY to the list of invoking keys. */
|
then add the current KEY to the list of invoking keys. */
|
if (map[key].function == function)
|
if (map[key].function == function)
|
{
|
{
|
char *keyname;
|
char *keyname;
|
|
|
keyname = _rl_get_keyname (key);
|
keyname = _rl_get_keyname (key);
|
|
|
if (result_index + 2 > result_size)
|
if (result_index + 2 > result_size)
|
{
|
{
|
result_size += 10;
|
result_size += 10;
|
result = (char **)xrealloc (result, result_size * sizeof (char *));
|
result = (char **)xrealloc (result, result_size * sizeof (char *));
|
}
|
}
|
|
|
result[result_index++] = keyname;
|
result[result_index++] = keyname;
|
result[result_index] = (char *)NULL;
|
result[result_index] = (char *)NULL;
|
}
|
}
|
break;
|
break;
|
|
|
case ISKMAP:
|
case ISKMAP:
|
{
|
{
|
char **seqs;
|
char **seqs;
|
register int i;
|
register int i;
|
|
|
/* Find the list of keyseqs in this map which have FUNCTION as
|
/* Find the list of keyseqs in this map which have FUNCTION as
|
their target. Add the key sequences found to RESULT. */
|
their target. Add the key sequences found to RESULT. */
|
if (map[key].function)
|
if (map[key].function)
|
seqs =
|
seqs =
|
rl_invoking_keyseqs_in_map (function, FUNCTION_TO_KEYMAP (map, key));
|
rl_invoking_keyseqs_in_map (function, FUNCTION_TO_KEYMAP (map, key));
|
else
|
else
|
break;
|
break;
|
|
|
if (seqs == 0)
|
if (seqs == 0)
|
break;
|
break;
|
|
|
for (i = 0; seqs[i]; i++)
|
for (i = 0; seqs[i]; i++)
|
{
|
{
|
char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
|
char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
|
|
|
if (key == ESC)
|
if (key == ESC)
|
#if 0
|
#if 0
|
sprintf (keyname, "\\e");
|
sprintf (keyname, "\\e");
|
#else
|
#else
|
/* XXX - experimental */
|
/* XXX - experimental */
|
sprintf (keyname, "\\M-");
|
sprintf (keyname, "\\M-");
|
#endif
|
#endif
|
else if (CTRL_CHAR (key))
|
else if (CTRL_CHAR (key))
|
sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
|
sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
|
else if (key == RUBOUT)
|
else if (key == RUBOUT)
|
sprintf (keyname, "\\C-?");
|
sprintf (keyname, "\\C-?");
|
else if (key == '\\' || key == '"')
|
else if (key == '\\' || key == '"')
|
{
|
{
|
keyname[0] = '\\';
|
keyname[0] = '\\';
|
keyname[1] = (char) key;
|
keyname[1] = (char) key;
|
keyname[2] = '\0';
|
keyname[2] = '\0';
|
}
|
}
|
else
|
else
|
{
|
{
|
keyname[0] = (char) key;
|
keyname[0] = (char) key;
|
keyname[1] = '\0';
|
keyname[1] = '\0';
|
}
|
}
|
|
|
strcat (keyname, seqs[i]);
|
strcat (keyname, seqs[i]);
|
free (seqs[i]);
|
free (seqs[i]);
|
|
|
if (result_index + 2 > result_size)
|
if (result_index + 2 > result_size)
|
{
|
{
|
result_size += 10;
|
result_size += 10;
|
result = (char **)xrealloc (result, result_size * sizeof (char *));
|
result = (char **)xrealloc (result, result_size * sizeof (char *));
|
}
|
}
|
|
|
result[result_index++] = keyname;
|
result[result_index++] = keyname;
|
result[result_index] = (char *)NULL;
|
result[result_index] = (char *)NULL;
|
}
|
}
|
|
|
free (seqs);
|
free (seqs);
|
}
|
}
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return (result);
|
return (result);
|
}
|
}
|
|
|
/* 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 (function)
|
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));
|
}
|
}
|
|
|
/* Print all of the functions and their bindings to rl_outstream. If
|
/* Print all of the functions and their bindings to rl_outstream. If
|
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 (print_readably)
|
int print_readably;
|
int print_readably;
|
{
|
{
|
register int i;
|
register int i;
|
const char **names;
|
const char **names;
|
const char *name;
|
const char *name;
|
|
|
names = rl_funmap_names ();
|
names = rl_funmap_names ();
|
|
|
fprintf (rl_outstream, "\n");
|
fprintf (rl_outstream, "\n");
|
|
|
for (i = 0; name = names[i]; i++)
|
for (i = 0; name = names[i]; i++)
|
{
|
{
|
rl_command_func_t *function;
|
rl_command_func_t *function;
|
char **invokers;
|
char **invokers;
|
|
|
function = rl_named_function (name);
|
function = rl_named_function (name);
|
invokers = rl_invoking_keyseqs_in_map (function, _rl_keymap);
|
invokers = rl_invoking_keyseqs_in_map (function, _rl_keymap);
|
|
|
if (print_readably)
|
if (print_readably)
|
{
|
{
|
if (!invokers)
|
if (!invokers)
|
fprintf (rl_outstream, "# %s (not bound)\n", name);
|
fprintf (rl_outstream, "# %s (not bound)\n", name);
|
else
|
else
|
{
|
{
|
register int j;
|
register int j;
|
|
|
for (j = 0; invokers[j]; j++)
|
for (j = 0; invokers[j]; j++)
|
{
|
{
|
fprintf (rl_outstream, "\"%s\": %s\n",
|
fprintf (rl_outstream, "\"%s\": %s\n",
|
invokers[j], name);
|
invokers[j], name);
|
free (invokers[j]);
|
free (invokers[j]);
|
}
|
}
|
|
|
free (invokers);
|
free (invokers);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (!invokers)
|
if (!invokers)
|
fprintf (rl_outstream, "%s is not bound to any keys\n",
|
fprintf (rl_outstream, "%s is not bound to any keys\n",
|
name);
|
name);
|
else
|
else
|
{
|
{
|
register int j;
|
register int j;
|
|
|
fprintf (rl_outstream, "%s can be found on ", name);
|
fprintf (rl_outstream, "%s can be found on ", name);
|
|
|
for (j = 0; invokers[j] && j < 5; j++)
|
for (j = 0; invokers[j] && j < 5; j++)
|
{
|
{
|
fprintf (rl_outstream, "\"%s\"%s", invokers[j],
|
fprintf (rl_outstream, "\"%s\"%s", invokers[j],
|
invokers[j + 1] ? ", " : ".\n");
|
invokers[j + 1] ? ", " : ".\n");
|
}
|
}
|
|
|
if (j == 5 && invokers[j])
|
if (j == 5 && invokers[j])
|
fprintf (rl_outstream, "...\n");
|
fprintf (rl_outstream, "...\n");
|
|
|
for (j = 0; invokers[j]; j++)
|
for (j = 0; invokers[j]; j++)
|
free (invokers[j]);
|
free (invokers[j]);
|
|
|
free (invokers);
|
free (invokers);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Print all of the current functions and their bindings to
|
/* Print all of the current functions and their bindings to
|
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 (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_dispatching)
|
if (rl_dispatching)
|
fprintf (rl_outstream, "\r\n");
|
fprintf (rl_outstream, "\r\n");
|
rl_function_dumper (rl_explicit_arg);
|
rl_function_dumper (rl_explicit_arg);
|
rl_on_new_line ();
|
rl_on_new_line ();
|
return (0);
|
return (0);
|
}
|
}
|
|
|
static void
|
static void
|
_rl_macro_dumper_internal (print_readably, map, prefix)
|
_rl_macro_dumper_internal (print_readably, map, prefix)
|
int print_readably;
|
int print_readably;
|
Keymap map;
|
Keymap map;
|
char *prefix;
|
char *prefix;
|
{
|
{
|
register int key;
|
register int key;
|
char *keyname, *out;
|
char *keyname, *out;
|
int prefix_len;
|
int prefix_len;
|
|
|
for (key = 0; key < KEYMAP_SIZE; key++)
|
for (key = 0; key < KEYMAP_SIZE; key++)
|
{
|
{
|
switch (map[key].type)
|
switch (map[key].type)
|
{
|
{
|
case ISMACR:
|
case ISMACR:
|
keyname = _rl_get_keyname (key);
|
keyname = _rl_get_keyname (key);
|
out = _rl_untranslate_macro_value ((char *)map[key].function);
|
out = _rl_untranslate_macro_value ((char *)map[key].function);
|
|
|
if (print_readably)
|
if (print_readably)
|
fprintf (rl_outstream, "\"%s%s\": \"%s\"\n", prefix ? prefix : "",
|
fprintf (rl_outstream, "\"%s%s\": \"%s\"\n", prefix ? prefix : "",
|
keyname,
|
keyname,
|
out ? out : "");
|
out ? out : "");
|
else
|
else
|
fprintf (rl_outstream, "%s%s outputs %s\n", prefix ? prefix : "",
|
fprintf (rl_outstream, "%s%s outputs %s\n", prefix ? prefix : "",
|
keyname,
|
keyname,
|
out ? out : "");
|
out ? out : "");
|
free (keyname);
|
free (keyname);
|
free (out);
|
free (out);
|
break;
|
break;
|
case ISFUNC:
|
case ISFUNC:
|
break;
|
break;
|
case ISKMAP:
|
case ISKMAP:
|
prefix_len = prefix ? strlen (prefix) : 0;
|
prefix_len = prefix ? strlen (prefix) : 0;
|
if (key == ESC)
|
if (key == ESC)
|
{
|
{
|
keyname = (char *)xmalloc (3 + prefix_len);
|
keyname = (char *)xmalloc (3 + prefix_len);
|
if (prefix)
|
if (prefix)
|
strcpy (keyname, prefix);
|
strcpy (keyname, prefix);
|
keyname[prefix_len] = '\\';
|
keyname[prefix_len] = '\\';
|
keyname[prefix_len + 1] = 'e';
|
keyname[prefix_len + 1] = 'e';
|
keyname[prefix_len + 2] = '\0';
|
keyname[prefix_len + 2] = '\0';
|
}
|
}
|
else
|
else
|
{
|
{
|
keyname = _rl_get_keyname (key);
|
keyname = _rl_get_keyname (key);
|
if (prefix)
|
if (prefix)
|
{
|
{
|
out = (char *)xmalloc (strlen (keyname) + prefix_len + 1);
|
out = (char *)xmalloc (strlen (keyname) + prefix_len + 1);
|
strcpy (out, prefix);
|
strcpy (out, prefix);
|
strcpy (out + prefix_len, keyname);
|
strcpy (out + prefix_len, keyname);
|
free (keyname);
|
free (keyname);
|
keyname = out;
|
keyname = out;
|
}
|
}
|
}
|
}
|
|
|
_rl_macro_dumper_internal (print_readably, FUNCTION_TO_KEYMAP (map, key), keyname);
|
_rl_macro_dumper_internal (print_readably, FUNCTION_TO_KEYMAP (map, key), keyname);
|
free (keyname);
|
free (keyname);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
rl_macro_dumper (print_readably)
|
rl_macro_dumper (print_readably)
|
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 (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_dispatching)
|
if (rl_dispatching)
|
fprintf (rl_outstream, "\r\n");
|
fprintf (rl_outstream, "\r\n");
|
rl_macro_dumper (rl_explicit_arg);
|
rl_macro_dumper (rl_explicit_arg);
|
rl_on_new_line ();
|
rl_on_new_line ();
|
return (0);
|
return (0);
|
}
|
}
|
|
|
static char *
|
static char *
|
_rl_get_string_variable_value (name)
|
_rl_get_string_variable_value (name)
|
const char *name;
|
const char *name;
|
{
|
{
|
static char numbuf[32];
|
static char numbuf[32];
|
char *ret;
|
char *ret;
|
int n;
|
int n;
|
|
|
if (_rl_stricmp (name, "bell-style") == 0)
|
if (_rl_stricmp (name, "bell-style") == 0)
|
{
|
{
|
switch (_rl_bell_preference)
|
switch (_rl_bell_preference)
|
{
|
{
|
case NO_BELL:
|
case NO_BELL:
|
return "none";
|
return "none";
|
case VISIBLE_BELL:
|
case VISIBLE_BELL:
|
return "visible";
|
return "visible";
|
case AUDIBLE_BELL:
|
case AUDIBLE_BELL:
|
default:
|
default:
|
return "audible";
|
return "audible";
|
}
|
}
|
}
|
}
|
else if (_rl_stricmp (name, "comment-begin") == 0)
|
else if (_rl_stricmp (name, "comment-begin") == 0)
|
return (_rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
|
return (_rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
|
else if (_rl_stricmp (name, "completion-query-items") == 0)
|
else if (_rl_stricmp (name, "completion-query-items") == 0)
|
{
|
{
|
sprintf (numbuf, "%d", rl_completion_query_items);
|
sprintf (numbuf, "%d", rl_completion_query_items);
|
return (numbuf);
|
return (numbuf);
|
}
|
}
|
else if (_rl_stricmp (name, "editing-mode") == 0)
|
else if (_rl_stricmp (name, "editing-mode") == 0)
|
return (rl_get_keymap_name_from_edit_mode ());
|
return (rl_get_keymap_name_from_edit_mode ());
|
else if (_rl_stricmp (name, "isearch-terminators") == 0)
|
else if (_rl_stricmp (name, "isearch-terminators") == 0)
|
{
|
{
|
if (_rl_isearch_terminators == 0)
|
if (_rl_isearch_terminators == 0)
|
return 0;
|
return 0;
|
ret = _rl_untranslate_macro_value (_rl_isearch_terminators);
|
ret = _rl_untranslate_macro_value (_rl_isearch_terminators);
|
if (ret)
|
if (ret)
|
{
|
{
|
strncpy (numbuf, ret, sizeof (numbuf) - 1);
|
strncpy (numbuf, ret, sizeof (numbuf) - 1);
|
free (ret);
|
free (ret);
|
numbuf[sizeof(numbuf) - 1] = '\0';
|
numbuf[sizeof(numbuf) - 1] = '\0';
|
}
|
}
|
else
|
else
|
numbuf[0] = '\0';
|
numbuf[0] = '\0';
|
return numbuf;
|
return numbuf;
|
}
|
}
|
else if (_rl_stricmp (name, "keymap") == 0)
|
else if (_rl_stricmp (name, "keymap") == 0)
|
{
|
{
|
ret = rl_get_keymap_name (_rl_keymap);
|
ret = rl_get_keymap_name (_rl_keymap);
|
if (ret == 0)
|
if (ret == 0)
|
ret = rl_get_keymap_name_from_edit_mode ();
|
ret = rl_get_keymap_name_from_edit_mode ();
|
return (ret ? ret : "none");
|
return (ret ? ret : "none");
|
}
|
}
|
else
|
else
|
return (0);
|
return (0);
|
}
|
}
|
|
|
void
|
void
|
rl_variable_dumper (print_readably)
|
rl_variable_dumper (print_readably)
|
int print_readably;
|
int print_readably;
|
{
|
{
|
int i;
|
int i;
|
char *v;
|
char *v;
|
|
|
for (i = 0; boolean_varlist[i].name; i++)
|
for (i = 0; boolean_varlist[i].name; i++)
|
{
|
{
|
if (print_readably)
|
if (print_readably)
|
fprintf (rl_outstream, "set %s %s\n", boolean_varlist[i].name,
|
fprintf (rl_outstream, "set %s %s\n", boolean_varlist[i].name,
|
*boolean_varlist[i].value ? "on" : "off");
|
*boolean_varlist[i].value ? "on" : "off");
|
else
|
else
|
fprintf (rl_outstream, "%s is set to `%s'\n", boolean_varlist[i].name,
|
fprintf (rl_outstream, "%s is set to `%s'\n", boolean_varlist[i].name,
|
*boolean_varlist[i].value ? "on" : "off");
|
*boolean_varlist[i].value ? "on" : "off");
|
}
|
}
|
|
|
for (i = 0; string_varlist[i].name; i++)
|
for (i = 0; string_varlist[i].name; i++)
|
{
|
{
|
v = _rl_get_string_variable_value (string_varlist[i].name);
|
v = _rl_get_string_variable_value (string_varlist[i].name);
|
if (v == 0) /* _rl_isearch_terminators can be NULL */
|
if (v == 0) /* _rl_isearch_terminators can be NULL */
|
continue;
|
continue;
|
if (print_readably)
|
if (print_readably)
|
fprintf (rl_outstream, "set %s %s\n", string_varlist[i].name, v);
|
fprintf (rl_outstream, "set %s %s\n", string_varlist[i].name, v);
|
else
|
else
|
fprintf (rl_outstream, "%s is set to `%s'\n", string_varlist[i].name, v);
|
fprintf (rl_outstream, "%s is set to `%s'\n", string_varlist[i].name, v);
|
}
|
}
|
}
|
}
|
|
|
/* Print all of the current variables and their values to
|
/* Print all of the current variables and their values to
|
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 (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_dispatching)
|
if (rl_dispatching)
|
fprintf (rl_outstream, "\r\n");
|
fprintf (rl_outstream, "\r\n");
|
rl_variable_dumper (rl_explicit_arg);
|
rl_variable_dumper (rl_explicit_arg);
|
rl_on_new_line ();
|
rl_on_new_line ();
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* 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 (string, array)
|
char *string;
|
char *string;
|
const char **array;
|
const char **array;
|
{
|
{
|
while (*array)
|
while (*array)
|
{
|
{
|
if (_rl_strindex (string, *array))
|
if (_rl_strindex (string, *array))
|
return (1);
|
return (1);
|
array++;
|
array++;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
