bind.c File Reference

#include "config_readline.h"
#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include "ansi_stdlib.h"
#include <errno.h>
#include "posixstat.h"
#include "rldefs.h"
#include "readline.h"
#include "history.h"
#include "rlprivate.h"
#include "rlshell.h"
#include "xmalloc.h"

Go to the source code of this file.

Data Structures
struct	assoc_list
Defines
#define	READLINE_LIBRARY
#define	V_BELLSTYLE   0
#define	V_COMBEGIN   1
#define	V_EDITMODE   2
#define	V_INT   2
#define	V_ISRCHTERM   3
#define	V_KEYMAP   4
#define	V_SPECIAL   0x1
#define	V_STRING   1
Typedefs
typedef int _rl_parser_func_t	PARAMS ((char *))
Functions
void	_rl_bind_if_unbound (char *keyseq, rl_command_func_t *default_func) const
static char *	_rl_get_keyname (int key)
static void	_rl_init_file_error (char *msg) const
static void	_rl_macro_dumper_internal (int print_readably, Keymap map, char *prefix)
static char *	_rl_read_file (char *filename, size_t *sizep)
static int	_rl_read_init_file (char *filename, int include_level) const
static char *	_rl_untranslate_macro_value (char *seq)
static int	bool_to_int (char *value)
static int	find_boolean_var (char *name) const
static int	find_string_var (char *name) const
static int	glean_key_from_name (char *name)
static void	hack_special_boolean_var (int i)
static int	handle_parser_directive (char *statement)
static int	parser_else (args)
static int	parser_endif (args)
static int	parser_if (char *args)
static int	parser_include (char *args)
int	rl_add_defun (char *name, rl_command_func_t *function, int key) const
int	rl_bind_key (int key, rl_command_func_t *function)
int	rl_bind_key_in_map (int key, rl_command_func_t *function, Keymap map)
int	rl_dump_functions (count, key)
int	rl_dump_macros (count, key)
int	rl_dump_variables (count, key)
void	rl_function_dumper (int print_readably)
rl_command_func_t *	rl_function_of_keyseq (char *keyseq, Keymap map, int *type) const
int	rl_generic_bind (int type, const char *keyseq, char *data, Keymap map)
Keymap	rl_get_keymap ()
Keymap	rl_get_keymap_by_name (char *name) const
char *	rl_get_keymap_name (Keymap map)
const char *	rl_get_keymap_name_from_edit_mode ()
char **	rl_invoking_keyseqs (rl_command_func_t *function)
char **	rl_invoking_keyseqs_in_map (rl_command_func_t *function, Keymap map)
void	rl_list_funmap_names ()
int	rl_macro_bind (char *keyseq, char *macro, Keymap map) const
void	rl_macro_dumper (int print_readably)
rl_command_func_t *	rl_named_function (char *string) const
int	rl_parse_and_bind (char *string)
int	rl_re_read_init_file (count, ignore)
int	rl_read_init_file (char *filename) const
int	rl_set_key (char *keyseq, rl_command_func_t *function, Keymap map) const
void	rl_set_keymap (Keymap map)
void	rl_set_keymap_from_edit_mode ()
int	rl_translate_keyseq (char *seq, char *array, int *len) const
int	rl_unbind_command_in_map (char *command, Keymap map) const
int	rl_unbind_function_in_map (rl_command_func_t *func, Keymap map)
int	rl_unbind_key (int key)
int	rl_unbind_key_in_map (int key, Keymap map)
char *	rl_untranslate_keyseq (int seq)
int	rl_variable_bind (char *name, char *value) const
void	rl_variable_dumper (int print_readably)
char *	strchr ()
char **	strrchr ()
static int	substring_member_of_array (char *string, const char **array)
static int	sv_bell_style (char *value) const
static int	sv_combegin (char *value) const
static int	sv_compquery (char *value) const
static int	sv_editmode (char *value) const
static int	sv_isrchterm (char *value) const
static int	sv_keymap (char *value) const
Variables
const char *	_rl_possible_control_prefixes []
const char *	_rl_possible_meta_prefixes []
static int	_rl_prefer_visible_bell = 1
struct {
int   flags
const char *   name
int *   value
}	boolean_varlist
static const char *	current_readline_init_file
static int	current_readline_init_include_level
static int	current_readline_init_lineno
static int	currently_reading_init_file
int	errno
static unsigned char *	if_stack = (unsigned char *)NULL
static int	if_stack_depth
static int	if_stack_size
struct {
Keymap   map
const char *   name
}	keymap_names []
static char *	last_readline_init_file = (char *)NULL
static assoc_list	name_key_alist []
struct {
const char *   f0
const char *   f2
int(*   func )(EditLine *, int, const char **)
_rl_parser_func_t *   function
int   m_bug
int(*   m_test )()
const char *   name
const char *   name
u_int32_t   power
u_int32_t   prime
}	parser_directives
Keymap	rl_binding_keymap
const char *	rl_readline_name = "other"
struct {
int   flags
const char *   name
_rl_sv_func_t *   set_func
}	string_varlist []

---

Define Documentation

#define READLINE_LIBRARY

Definition at line 22 of file bind.c.

#define V_BELLSTYLE   0

Definition at line 1326 of file bind.c.

#define V_COMBEGIN   1

Definition at line 1327 of file bind.c.

#define V_EDITMODE   2

Definition at line 1328 of file bind.c.

#define V_INT   2

Definition at line 1333 of file bind.c.

#define V_ISRCHTERM   3

Definition at line 1329 of file bind.c.

#define V_KEYMAP   4

Definition at line 1330 of file bind.c.

#define V_SPECIAL   0x1

Definition at line 1255 of file bind.c. Referenced by rl_variable_bind().

#define V_STRING   1

Definition at line 1332 of file bind.c.

---

Typedef Documentation

static boolean stab_demangle_fund_type PARAMS

Definition at line 805 of file bind.c.

---

Function Documentation

void _rl_bind_if_unbound (  char *  keyseq, rl_command_func_t *  default_func )  const

Definition at line 2118 of file bind.c. References _rl_keymap, func, NULL, rl_do_lowercase_version(), rl_function_of_keyseq(), rl_set_key(), and rl_vi_movement_mode(). Referenced by bind_arrow_keys_internal(), and bind_termcap_arrow_keys(). { rl_command_func_t *func; if (keyseq) { func = rl_function_of_keyseq (keyseq, _rl_keymap, (int *)NULL); #if defined (VI_MODE) if (!func || func == rl_do_lowercase_version || func == rl_vi_movement_mode) #else if (!func || func == rl_do_lowercase_version) #endif rl_set_key (keyseq, default_func, _rl_keymap); } }

static char* _rl_get_keyname (  int  key  )  [static]

Definition at line 1673 of file bind.c. References _rl_to_lower, CTRL_CHAR, ESC, RUBOUT, UNCTRL, and xmalloc(). Referenced by _rl_macro_dumper_internal(), and rl_invoking_keyseqs_in_map(). { char *keyname; int i, c; keyname = (char *)xmalloc (8); c = key; /* 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 do any special meta processing on KEY. */ #if 1 /* XXX - Experimental */ /* 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. Just add the special ESC key sequence and return. */ if (c == ESC) { keyname[0] = '\\'; keyname[1] = 'e'; keyname[2] = '\0'; return keyname; } #endif /* RUBOUT is translated directly into \C-? */ if (key == RUBOUT) { keyname[0] = '\\'; keyname[1] = 'C'; keyname[2] = '-'; keyname[3] = '?'; keyname[4] = '\0'; return keyname; } i = 0; /* Now add special prefixes needed for control characters. This can potentially change C. */ if (CTRL_CHAR (c)) { keyname[i++] = '\\'; keyname[i++] = 'C'; keyname[i++] = '-'; c = _rl_to_lower (UNCTRL (c)); } /* XXX experimental code. Turn the characters that are not ASCII or ISO Latin 1 (128 - 159) into octal escape sequences (\200 - \237). This changes C. */ if (c >= 128 && c <= 159) { keyname[i++] = '\\'; keyname[i++] = '2'; c -= 128; keyname[i++] = (c / 8) + '0'; c = (c % 8) + '0'; } /* Now, if the character needs to be quoted with a backslash, do that. */ if (c == '\\' || c == '"') keyname[i++] = '\\'; /* Now add the key, terminate the string, and return it. */ keyname[i++] = (char) c; keyname[i] = '\0'; return keyname; }

static void _rl_init_file_error (  char *  msg  )  const [static]

Definition at line 789 of file bind.c. Referenced by handle_parser_directive(), parser_else(), parser_endif(), and rl_parse_and_bind(). { if (currently_reading_init_file) fprintf (stderr, "readline: %s: line %d: %s\n", current_readline_init_file, current_readline_init_lineno, msg); else fprintf (stderr, "readline: %s\n", msg); }

static void _rl_macro_dumper_internal (  int  print_readably, Keymap  map, char *  prefix )  [static]

Definition at line 1945 of file bind.c. References _rl_get_keyname(), _rl_untranslate_macro_value(), ESC, free, function, FUNCTION_TO_KEYMAP, ISFUNC, ISKMAP, ISMACR, key, KEYMAP_SIZE, rl_outstream, and xmalloc(). Referenced by rl_macro_dumper(). { register int key; char *keyname, *out; int prefix_len; for (key = 0; key < KEYMAP_SIZE; key++) { switch (map[key].type) { case ISMACR: keyname = _rl_get_keyname (key); out = _rl_untranslate_macro_value ((char *)map[key].function); if (print_readably) fprintf (rl_outstream, "\"%s%s\": \"%s\"\n", prefix ? prefix : "", keyname, out ? out : ""); else fprintf (rl_outstream, "%s%s outputs %s\n", prefix ? prefix : "", keyname, out ? out : ""); free (keyname); free (out); break; case ISFUNC: break; case ISKMAP: prefix_len = prefix ? strlen (prefix) : 0; if (key == ESC) { keyname = (char *)xmalloc (3 + prefix_len); if (prefix) strcpy (keyname, prefix); keyname[prefix_len] = '\\'; keyname[prefix_len + 1] = 'e'; keyname[prefix_len + 2] = '\0'; } else { keyname = _rl_get_keyname (key); if (prefix) { out = (char *)xmalloc (strlen (keyname) + prefix_len + 1); strcpy (out, prefix); strcpy (out + prefix_len, keyname); free (keyname); keyname = out; } } _rl_macro_dumper_internal (print_readably, FUNCTION_TO_KEYMAP (map, key), keyname); free (keyname); break; } } }

static char* _rl_read_file (  char *  filename, size_t *  sizep )  [static]

Definition at line 635 of file bind.c. References buffer, close(), EFBIG, errno, file, free, NULL, open(), read(), and xmalloc(). Referenced by _rl_read_init_file(). { struct stat finfo; size_t file_size; char *buffer; int i, file; if ((stat (filename, &finfo) < 0) || (file = open (filename, O_RDONLY, 0666)) < 0) return ((char *)NULL); file_size = (size_t)finfo.st_size; /* check for overflow on very large files */ if (file_size != finfo.st_size || file_size + 1 < file_size) { if (file >= 0) close (file); #if defined (EFBIG) errno = EFBIG; #endif return ((char *)NULL); } /* Read the file into BUFFER. */ buffer = (char *)xmalloc (file_size + 1); i = read (file, buffer, file_size); close (file); if (i < 0) { free (buffer); return ((char *)NULL); } buffer[i] = '\0'; if (sizep) *sizep = i; return (buffer); }

static int _rl_read_init_file (  char *  filename, int  include_level )  const [static]

Definition at line 722 of file bind.c. References _rl_read_file(), buffer, errno, FREE, free, line, rl_parse_and_bind(), savestring, tilde_expand(), and whitespace. Referenced by parser_include(), and rl_read_init_file(). { register int i; char *buffer, *openname, *line, *end; size_t file_size; current_readline_init_file = filename; current_readline_init_include_level = include_level; openname = tilde_expand (filename); buffer = _rl_read_file (openname, &file_size); free (openname); if (buffer == 0) return (errno); if (include_level == 0 && filename != last_readline_init_file) { FREE (last_readline_init_file); last_readline_init_file = savestring (filename); } currently_reading_init_file = 1; /* Loop over the lines in the file. Lines that start with `#' are comments; all other lines are commands for readline initialization. */ current_readline_init_lineno = 1; line = buffer; end = buffer + file_size; while (line < end) { /* Find the end of this line. */ for (i = 0; line + i != end && line[i] != '\n'; i++); #if defined (__CYGWIN__) /* ``Be liberal in what you accept.'' */ if (line[i] == '\n' && line[i-1] == '\r') line[i - 1] = '\0'; #endif /* Mark end of line. */ line[i] = '\0'; /* Skip leading whitespace. */ while (*line && whitespace (*line)) { line++; i--; } /* If the line is not a comment, then parse it. */ if (*line && *line != '#') rl_parse_and_bind (line); /* Move to the next line. */ line += i + 1; current_readline_init_lineno++; } free (buffer); currently_reading_init_file = 0; return (0); }

static char* _rl_untranslate_macro_value (  char *  seq  )  [static]

Definition at line 499 of file bind.c. References _rl_to_lower, CTRL_CHAR, ESC, META_CHAR, RUBOUT, UNCTRL, UNMETA, and xmalloc(). Referenced by _rl_macro_dumper_internal(), and rl_variable_dumper(). { char *ret, *r, *s; int c; r = ret = (char *)xmalloc (7 * strlen (seq) + 1); for (s = seq; *s; s++) { c = *s; if (META_CHAR (c)) { *r++ = '\\'; *r++ = 'M'; *r++ = '-'; c = UNMETA (c); } else if (CTRL_CHAR (c) && c != ESC) { *r++ = '\\'; *r++ = 'C'; *r++ = '-'; c = _rl_to_lower (UNCTRL (c)); } else if (c == RUBOUT) { *r++ = '\\'; *r++ = 'C'; *r++ = '-'; c = '?'; } if (c == ESC) { *r++ = '\\'; c = 'e'; } else if (c == '\\' || c == '"') *r++ = '\\'; *r++ = (unsigned char)c; } *r = '\0'; return ret; }

static int bool_to_int (  char *  value  )  [static]

Definition at line 1373 of file bind.c. References _rl_stricmp(). Referenced by rl_variable_bind(). { return (value == 0 || *value == '\0' || (_rl_stricmp (value, "on") == 0) || (value[0] == '1' && value[1] == '\0')); }

static int find_boolean_var (  char *  name  )  const [static]

Definition at line 1289 of file bind.c. References _rl_stricmp(), and boolean_varlist. Referenced by rl_variable_bind(). { register int i; for (i = 0; boolean_varlist[i].name; i++) if (_rl_stricmp (name, boolean_varlist[i].name) == 0) return i; return -1; }

static int find_string_var (  char *  name  )  const [static]

Definition at line 1358 of file bind.c. References _rl_stricmp(), and string_varlist. Referenced by rl_variable_bind(). { register int i; for (i = 0; string_varlist[i].name; i++) if (_rl_stricmp (name, string_varlist[i].name) == 0) return i; return -1; }

static int glean_key_from_name (  char *  name  )  [static]

Definition at line 1551 of file bind.c. References _rl_stricmp(), and value. Referenced by rl_parse_and_bind(). { register int i; for (i = 0; name_key_alist[i].name; i++) if (_rl_stricmp (name, name_key_alist[i].name) == 0) return (name_key_alist[i].value); return (*(unsigned char *)name); /* XXX was return (*name) */ }

static void hack_special_boolean_var (  int  i  )  [static]

Definition at line 1304 of file bind.c. References _rl_bell_preference, _rl_enable_paren_matching(), _rl_stricmp(), AUDIBLE_BELL, boolean_varlist, name, rl_blink_matching_paren, and VISIBLE_BELL. Referenced by rl_variable_bind(). { const char *name; name = boolean_varlist[i].name; if (_rl_stricmp (name, "blink-matching-paren") == 0) _rl_enable_paren_matching (rl_blink_matching_paren); else if (_rl_stricmp (name, "prefer-visible-bell") == 0) { if (_rl_prefer_visible_bell) _rl_bell_preference = VISIBLE_BELL; else _rl_bell_preference = AUDIBLE_BELL; } }

static int handle_parser_directive (  char *  statement  )  [static]

Definition at line 979 of file bind.c. References _rl_init_file_error(), _rl_stricmp(), args, name, parser_directives, and whitespace. Referenced by rl_parse_and_bind(). { register int i; char *directive, *args; /* Isolate the actual directive. */ /* Skip whitespace. */ for (i = 0; whitespace (statement[i]); i++); directive = &statement[i]; for (; statement[i] && !whitespace (statement[i]); i++); if (statement[i]) statement[i++] = '\0'; for (; statement[i] && whitespace (statement[i]); i++); args = &statement[i]; /* Lookup the command, and act on it. */ for (i = 0; parser_directives[i].name; i++) if (_rl_stricmp (directive, parser_directives[i].name) == 0) { (*parser_directives[i].function) (args); return (0); } /* display an error message about the unknown parser directive */ _rl_init_file_error ("unknown parser directive"); return (1); }

static int parser_else (  args   )  [static]

Definition at line 902 of file bind.c. References _rl_init_file_error(), and _rl_parsing_conditionalized_out. { register int i; if (if_stack_depth == 0) { _rl_init_file_error ("$else found without matching $if"); return 0; } /* Check the previous (n - 1) levels of the stack to make sure that we haven't previously turned off parsing. */ for (i = 0; i < if_stack_depth - 1; i++) if (if_stack[i] == 1) return 0; /* Invert the state of parsing if at top level. */ _rl_parsing_conditionalized_out = !_rl_parsing_conditionalized_out; return 0; }

static int parser_endif (  args   )  [static]

Definition at line 927 of file bind.c. References _rl_init_file_error(), and _rl_parsing_conditionalized_out. { if (if_stack_depth) _rl_parsing_conditionalized_out = if_stack[--if_stack_depth]; else _rl_init_file_error ("$endif without matching $if"); return 0; }

static int parser_if (  char *  args  )  [static]

Definition at line 829 of file bind.c. References _rl_parsing_conditionalized_out, _rl_stricmp(), _rl_strnicmp(), emacs_mode, free, no_mode, rl_editing_mode, rl_terminal_name, savestring, strchr(), vi_mode, whitespace, xmalloc(), and xrealloc(). { register int i; /* Push parser state. */ if (if_stack_depth + 1 >= if_stack_size) { if (!if_stack) if_stack = (unsigned char *)xmalloc (if_stack_size = 20); else if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20); } if_stack[if_stack_depth++] = _rl_parsing_conditionalized_out; /* If parsing is turned off, then nothing can turn it back on except for finding the matching endif. In that case, return right now. */ if (_rl_parsing_conditionalized_out) return 0; /* Isolate first argument. */ for (i = 0; args[i] && !whitespace (args[i]); i++); if (args[i]) args[i++] = '\0'; /* 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 word in ARGS is the same as the value stored in rl_readline_name. */ if (rl_terminal_name && _rl_strnicmp (args, "term=", 5) == 0) { char *tem, *tname; /* Terminals like "aaa-60" are equivalent to "aaa". */ tname = savestring (rl_terminal_name); tem = strchr (tname, '-'); if (tem) *tem = '\0'; /* 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 that will be executed if the terminal is a `sun', they can put `$if term=sun-cmd' into their .inputrc. */ _rl_parsing_conditionalized_out = _rl_stricmp (args + 5, tname) && _rl_stricmp (args + 5, rl_terminal_name); free (tname); } #if defined (VI_MODE) else if (_rl_strnicmp (args, "mode=", 5) == 0) { int mode; if (_rl_stricmp (args + 5, "emacs") == 0) mode = emacs_mode; else if (_rl_stricmp (args + 5, "vi") == 0) mode = vi_mode; else mode = no_mode; _rl_parsing_conditionalized_out = mode != rl_editing_mode; } #endif /* VI_MODE */ /* Check to see if the first word in ARGS is the same as the value stored in rl_readline_name. */ else if (_rl_stricmp (args, rl_readline_name) == 0) _rl_parsing_conditionalized_out = 0; else _rl_parsing_conditionalized_out = 1; return 0; }

static int parser_include (  char *  args  )  [static]

Definition at line 938 of file bind.c. References _rl_parsing_conditionalized_out, _rl_read_init_file(), e, and strchr(). { const char *old_init_file; char *e; int old_line_number, old_include_level, r; if (_rl_parsing_conditionalized_out) return (0); old_init_file = current_readline_init_file; old_line_number = current_readline_init_lineno; old_include_level = current_readline_init_include_level; e = strchr (args, '\n'); if (e) *e = '\0'; r = _rl_read_init_file ((const char *)args, old_include_level + 1); current_readline_init_file = old_init_file; current_readline_init_lineno = old_line_number; current_readline_init_include_level = old_include_level; return r; }

int rl_add_defun (  char *  name, rl_command_func_t *  function, int  key )  const

Definition at line 90 of file bind.c. References rl_add_funmap_entry(), and rl_bind_key(). { if (key != -1) rl_bind_key (key, function); rl_add_funmap_entry (name, function); return 0; }

int rl_bind_key (  int  key, rl_command_func_t *  function )

Definition at line 103 of file bind.c. References _rl_convert_meta_chars_to_ascii, _rl_keymap, ESC, _keymap_entry::function, FUNCTION_TO_KEYMAP, ISFUNC, ISKMAP, META_CHAR, _keymap_entry::type, and UNMETA. { if (key < 0) return (key); if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii) { if (_rl_keymap[ESC].type == ISKMAP) { Keymap escmap; escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC); key = UNMETA (key); escmap[key].type = ISFUNC; escmap[key].function = function; return (0); } return (key); } _rl_keymap[key].type = ISFUNC; _rl_keymap[key].function = function; rl_binding_keymap = _rl_keymap; return (0); }

int rl_bind_key_in_map (  int  key, rl_command_func_t *  function, Keymap  map )

Definition at line 134 of file bind.c. References _rl_keymap, and rl_bind_key(). { int result; Keymap oldmap; oldmap = _rl_keymap; _rl_keymap = map; result = rl_bind_key (key, function); _rl_keymap = oldmap; return (result); }

int rl_dump_functions (  count  , key  )

Definition at line 1934 of file bind.c. References rl_dispatching, rl_explicit_arg, rl_function_dumper(), rl_on_new_line(), and rl_outstream. { if (rl_dispatching) fprintf (rl_outstream, "\r\n"); rl_function_dumper (rl_explicit_arg); rl_on_new_line (); return (0); }

int rl_dump_macros (  count  , key  )

Definition at line 2014 of file bind.c. References rl_dispatching, rl_explicit_arg, rl_macro_dumper(), rl_on_new_line(), and rl_outstream. { if (rl_dispatching) fprintf (rl_outstream, "\r\n"); rl_macro_dumper (rl_explicit_arg); rl_on_new_line (); return (0); }

int rl_dump_variables (  count  , key  )

Definition at line 2104 of file bind.c. References rl_dispatching, rl_explicit_arg, rl_on_new_line(), rl_outstream, and rl_variable_dumper(). { if (rl_dispatching) fprintf (rl_outstream, "\r\n"); rl_variable_dumper (rl_explicit_arg); rl_on_new_line (); return (0); }

void rl_function_dumper (  int  print_readably  )

Definition at line 1864 of file bind.c. References _rl_keymap, free, function, name, rl_funmap_names(), rl_invoking_keyseqs_in_map(), rl_named_function(), and rl_outstream. Referenced by rl_dump_functions(). { register int i; const char **names; const char *name; names = rl_funmap_names (); fprintf (rl_outstream, "\n"); for (i = 0; (name = names[i]); i++) { rl_command_func_t *function; char **invokers; function = rl_named_function (name); invokers = rl_invoking_keyseqs_in_map (function, _rl_keymap); if (print_readably) { if (!invokers) fprintf (rl_outstream, "# %s (not bound)\n", name); else { register int j; for (j = 0; invokers[j]; j++) { fprintf (rl_outstream, "\"%s\": %s\n", invokers[j], name); free (invokers[j]); } free (invokers); } } else { if (!invokers) fprintf (rl_outstream, "%s is not bound to any keys\n", name); else {