Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/include/readline/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"

Include dependency graph for bind.c:

Go to the source code of this file.

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

---

Define Documentation

#define READLINE_LIBRARY

Definition at line 23 of file bind.c.

#define V_BELLSTYLE   0

Definition at line 1421 of file bind.c.

#define V_COMBEGIN   1

Definition at line 1422 of file bind.c.

#define V_EDITMODE   2

Definition at line 1423 of file bind.c.

#define V_INT   2

Definition at line 1428 of file bind.c.

#define V_ISRCHTERM   3

Definition at line 1424 of file bind.c.

#define V_KEYMAP   4

Definition at line 1425 of file bind.c.

#define V_SPECIAL   0x1

Definition at line 1349 of file bind.c.

#define V_STRING   1

Definition at line 1427 of file bind.c.

---

Typedef Documentation

typedef int _rl_sv_func_t PARAMS((const char *))

Definition at line 1417 of file bind.c.

typedef int _rl_parser_func_t PARAMS((char *))

Definition at line 893 of file bind.c.

---

Function Documentation

static char* _rl_get_keyname

(

int

key

)

[static]

Definition at line 1767 of file bind.c.

References _rl_to_lower, CTRL_CHAR, ESC, RUBOUT, UNCTRL, and xmalloc().

{
  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;
}

Here is the call graph for this function:

static void _rl_init_file_error

(

char *

msg

)

const [static]

Definition at line 877 of file bind.c.

{
  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 2039 of file bind.c.

References _rl_get_keyname(), _rl_macro_dumper_internal(), _rl_untranslate_macro_value(), ESC, free, function, FUNCTION_TO_KEYMAP, ISFUNC, ISKMAP, ISMACR, key, KEYMAP_SIZE, map, rl_outstream, strlen(), and xmalloc().

{
  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;
        }
    }
}

Here is the call graph for this function:

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

Definition at line 723 of file bind.c.

References buffer, errno, free, NULL, and xmalloc().

{
  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);
}

Here is the call graph for this function:

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

Definition at line 810 of file bind.c.

References _rl_read_file(), buffer, errno, FREE, free, line, rl_parse_and_bind(), savestring, tilde_expand(), and whitespace.

{
  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);
}

Here is the call graph for this function:

static char* _rl_untranslate_macro_value

(

char *

seq

)

[static]

Definition at line 587 of file bind.c.

References _rl_to_lower, CTRL_CHAR, ESC, META_CHAR, RUBOUT, strlen(), UNCTRL, UNMETA, and xmalloc().

{
  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;
}

Here is the call graph for this function:

static int bool_to_int

(

char *

value

)

[static]

Definition at line 1468 of file bind.c.

References _rl_stricmp().

{
  return (value == 0 || *value == '\0' ||
                (_rl_stricmp (value, "on") == 0) ||
                (value[0] == '1' && value[1] == '\0'));
}

Here is the call graph for this function:

static int find_boolean_var

(

char *

name

)

const [static]

Definition at line 1384 of file bind.c.

References _rl_stricmp(), and boolean_varlist.

{
  register int i;

  for (i = 0; boolean_varlist[i].name; i++)
    if (_rl_stricmp (name, boolean_varlist[i].name) == 0)
      return i;
  return -1;
}

Here is the call graph for this function:

static int find_string_var

(

char *

name

)

const [static]

Definition at line 1453 of file bind.c.

References _rl_stricmp(), and string_varlist.

{
  register int i;

  for (i = 0; string_varlist[i].name; i++)
    if (_rl_stricmp (name, string_varlist[i].name) == 0)
      return i;
  return -1;
}

Here is the call graph for this function:

static int glean_key_from_name

(

char *

name

)

[static]

Definition at line 1646 of file bind.c.

References _rl_stricmp(), assoc_list::name, name_key_alist, and value.

{
  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) */
}

Here is the call graph for this function:

static void hack_special_boolean_var

(

int

i

)

[static]

Definition at line 1399 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.

{
  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;
    }
}

Here is the call graph for this function:

static int handle_parser_directive

(

char *

statement

)

[static]

Definition at line 1073 of file bind.c.

References _rl_init_file_error(), _rl_stricmp(), args, function, name, parser_directives, and whitespace.

{
  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);
}

Here is the call graph for this function:

static int substring_member_of_array PARAMS

(

(char *, const char **)

)

[static]

static int glean_key_from_name PARAMS

(

(char *)

)

[static]

static int _rl_read_init_file PARAMS

(

(const char *, int)

)

[static]

static void _rl_init_file_error PARAMS

(

(const char *)

)

[static]

static char* _rl_read_file PARAMS

(

(char *, size_t *)

)

[static]

static int parser_else

(

char *

args

)

[static]

Definition at line 990 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;
    }

#if 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++)
#else
  /* Check the previous (n) levels of the stack to make sure that
     we haven't previously turned off parsing. */
  for (i = 0; i < if_stack_depth; i++)
#endif
    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;
}

Here is the call graph for this function:

static int parser_endif

(

char *

args

)

[static]

Definition at line 1021 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;
}

Here is the call graph for this function:

static int parser_if

(

char *

args

)

[static]

Definition at line 917 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;
}

Here is the call graph for this function:

static int parser_include

(

char *

args

)

[static]

Definition at line 1032 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;
}

Here is the call graph for this function:

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

Definition at line 95 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;
}

Here is the call graph for this function:

int rl_bind_key	(	int	key,
		rl_command_func_t *	function
	)

Definition at line 108 of file bind.c.

References _rl_convert_meta_chars_to_ascii, _rl_keymap, ESC, _keymap_entry::function, FUNCTION_TO_KEYMAP, ISFUNC, ISKMAP, META_CHAR, rl_binding_keymap, _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_if_unbound	(	int	key,
		rl_command_func_t *	default_func
	)

Definition at line 171 of file bind.c.

References _rl_keymap, and rl_bind_keyseq_if_unbound_in_map().

{
  char keyseq[2];

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

Here is the call graph for this function:

int rl_bind_key_if_unbound_in_map	(	int	key,
		rl_command_func_t *	default_func,
		Keymap	kmap
	)

Definition at line 158 of file bind.c.

References rl_bind_keyseq_if_unbound_in_map().

{
  char keyseq[2];

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

Here is the call graph for this function:

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

Definition at line 139 of file bind.c.

References _rl_keymap, map, 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);
}

Here is the call graph for this function:

int rl_bind_keyseq	(	char *	keyseq,
		rl_command_func_t *	function
	)			const

Definition at line 237 of file bind.c.

References _rl_keymap, ISFUNC, and rl_generic_bind().

{
  return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));
}

Here is the call graph for this function:

int rl_bind_keyseq_if_unbound	(	char *	keyseq,
		rl_command_func_t *	default_func
	)			const

Definition at line 293 of file bind.c.

References _rl_keymap, and rl_bind_keyseq_if_unbound_in_map().

{
  return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
}

Here is the call graph for this function:

int rl_bind_keyseq_if_unbound_in_map	(	char *	keyseq,
		rl_command_func_t *	default_func,
		Keymap	kmap
	)			const

Definition at line 270 of file bind.c.

References func, NULL, rl_bind_keyseq_in_map(), rl_do_lowercase_version(), rl_function_of_keyseq(), and rl_vi_movement_mode().

{
  rl_command_func_t *func;

  if (keyseq)
    {
      func = rl_function_of_keyseq (keyseq, kmap, (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
        return (rl_bind_keyseq_in_map (keyseq, default_func, kmap));
      else
        return 1;
    }
  return 0;
}

Here is the call graph for this function:

int rl_bind_keyseq_in_map	(	char *	keyseq,
		rl_command_func_t *	function,
		Keymap	map
	)			const

Definition at line 248 of file bind.c.

References ISFUNC, map, and rl_generic_bind().

{
  return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}

Here is the call graph for this function:

int rl_dump_functions	(	int	count,
		int	key
	)

Definition at line 2028 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);
}

Here is the call graph for this function:

int rl_dump_macros	(	int	count,
		int	key
	)

Definition at line 2108 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);
}

Here is the call graph for this function:

int rl_dump_variables	(	int	count,
		int	key
	)

Definition at line 2198 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);
}

Here is the call graph for this function:

void rl_function_dumper

(

int

print_readably

)

Definition at line 1958 of file bind.c.

References _rl_keymap, free, function, name, rl_funmap_names(), rl_invoking_keyseqs_in_map(), rl_named_function(), and rl_outstream.

{
  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
            {
              register int j;

              fprintf (rl_outstream, "%s can be found on ", name);

              for (j = 0; invokers[j] && j < 5; j++)
                {
                  fprintf (rl_outstream, "\"%s\"%s", invokers[j],
                           invokers[j + 1] ? ", " : ".\n");
                }

              if (j == 5 && invokers[j])
                fprintf (rl_outstream, "...\n");

              for (j = 0; invokers[j]; j++)
                free (invokers[j]);

              free (invokers);
            }
        }
    }
}

Here is the call graph for this function:

rl_command_func_t* rl_function_of_keyseq	(	char *	keyseq,
		Keymap	map,
		int *	type
	)			const

Definition at line 656 of file bind.c.

References _rl_convert_meta_chars_to_ascii, _rl_keymap, ESC, function, FUNCTION_TO_KEYMAP, ISKMAP, map, META_CHAR, NULL, and UNMETA.

{
  register int i;

  if (!map)
    map = _rl_keymap;

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

      if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
        {
          if (map[ESC].type != ISKMAP)
            {
              if (type)
                *type = map[ESC].type;

              return (map[ESC].function);
            }
          else
            {
              map = FUNCTION_TO_KEYMAP (map, ESC);
              ic = UNMETA (ic);
            }
        }

      if (map[ic].type == ISKMAP)
        {
          /* If this is the last key in the key sequence, return the
             map. */
          if (!keyseq[i + 1])
            {
              if (type)
                *type = ISKMAP;

              return (map[ic].function);
            }
          else
            map = FUNCTION_TO_KEYMAP (map, ic);
        }
      else
        {
          if (type)
            *type = map[ic].type;

          return (map[ic].function);
        }
    }
  return ((rl_command_func_t *) NULL);
}

int rl_generic_bind	(	int	type,
		const char *	keyseq,
		char *	data,
		Keymap	map
	)

Definition at line 328 of file bind.c.

References _rl_convert_meta_chars_to_ascii, ANYOTHERKEY, ESC, free, function, _keymap_entry::function, FUNCTION_TO_KEYMAP, ISFUNC, ISKMAP, ISMACR, KEYMAP_SIZE, KEYMAP_TO_FUNCTION, keys, map, META_CHAR, rl_binding_keymap, rl_do_lowercase_version(), rl_make_bare_keymap(), rl_translate_keyseq(), strlen(), _keymap_entry::type, UNMETA, and xmalloc().

{
  char *keys;
  int keys_len;
  register int i;
  KEYMAP_ENTRY k;

  k.function = 0;

  /* If no keys to bind to, exit right away. */
  if (!keyseq || !*keyseq)
    {
      if (type == ISMACR)
        free (data);
      return -1;
    }

  keys = (char *)xmalloc (1 + (2 * strlen (keyseq)));

  /* Translate the ASCII representation of KEYSEQ into an array of
     characters.  Stuff the characters into KEYS, and the length of
     KEYS into KEYS_LEN. */
  if (rl_translate_keyseq (keyseq, keys, &keys_len))
    {
      free (keys);
      return -1;
    }

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

      ic = uc;
      if (ic < 0 || ic >= KEYMAP_SIZE)
        return -1;

      if (_rl_convert_meta_chars_to_ascii && META_CHAR (ic))
        {
          ic = UNMETA (ic);
          if (map[ESC].type == ISKMAP)
            map = FUNCTION_TO_KEYMAP (map, ESC);
        }

      if ((i + 1) < keys_len)
        {
          if (map[ic].type != ISKMAP)
            {
              /* We allow subsequences of keys.  If a keymap is being
                 created that will `shadow' an existing function or macro
                 key binding, we save that keybinding into the ANYOTHERKEY
                 index in the new map.  The dispatch code will look there
                 to find the function to execute if the subsequence is not
                 matched.  ANYOTHERKEY was chosen to be greater than
                 UCHAR_MAX. */
              k = map[ic];

              map[ic].type = ISKMAP;
              map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
            }
          map = FUNCTION_TO_KEYMAP (map, ic);
          /* The dispatch code will return this function if no matching
             key sequence is found in the keymap.  This (with a little
             help from the dispatch code in readline.c) allows `a' to be
             mapped to something, `abc' to be mapped to something else,
             and the function bound  to `a' to be executed when the user
             types `abx', leaving `bx' in the input queue. */
          if (k.function && ((k.type == ISFUNC && k.function != rl_do_lowercase_version) || k.type == ISMACR))
            {
              map[ANYOTHERKEY] = k;
              k.function = 0;
            }
        }
      else
        {
          if (map[ic].type == ISMACR)
            free ((char *)map[ic].function);
          else if (map[ic].type == ISKMAP)
            {
              map = FUNCTION_TO_KEYMAP (map, ic);
              ic = ANYOTHERKEY;
            }

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

      rl_binding_keymap = map;
    }
  free (keys);
  return 0;
}

Here is the call graph for this function:

Keymap rl_get_keymap

(

void

)

Definition at line 1708 of file bind.c.

References _rl_keymap.

{
  return (_rl_keymap);
}

Keymap rl_get_keymap_by_name

(

char *

name

)

const

Definition at line 1677 of file bind.c.

References _rl_stricmp(), keymap_names, map, and NULL.

{
  register int i;

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

Here is the call graph for this function:

char* rl_get_keymap_name

(

Keymap

map

)

Definition at line 1689 of file bind.c.

References keymap_names, name, and NULL.

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

char* rl_get_keymap_name_from_edit_mode

(

)

Definition at line 1725 of file bind.c.

References emacs_mode, rl_editing_mode, and vi_mode.

{
  if (rl_editing_mode == emacs_mode)
    return "emacs";
#if defined (VI_MODE)
  else if (rl_editing_mode == vi_mode)
    return "vi";
#endif /* VI_MODE */
  else
    return "none";
}

char** rl_invoking_keyseqs

(

rl_command_func_t *

function

)

Definition at line 1948 of file bind.c.

References _rl_keymap, and rl_invoking_keyseqs_in_map().

{
  return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
}

Here is the call graph for this function:

char** rl_invoking_keyseqs_in_map	(	rl_command_func_t *	function,
		Keymap	map
	)

Definition at line 1843 of file bind.c.

References _rl_get_keyname(), _rl_to_lower, CTRL_CHAR, ESC, free, FUNCTION_TO_KEYMAP, ISFUNC, ISKMAP, ISMACR, key, KEYMAP_SIZE, map, NULL, rl_invoking_keyseqs_in_map(), RUBOUT, strcat(), strlen(), UNCTRL, xmalloc(), and xrealloc().

{
  register int key;
  char **result;
  int result_index, result_size;

  result = (char **)NULL;
  result_index = result_size = 0;

  for (key = 0; key < KEYMAP_SIZE; key++)
    {
      switch (map[key].type)
        {
        case ISMACR:
          /* Macros match, if, and only if, the pointers are identical.
             Thus, they are treated exactly like functions in here. */
        case ISFUNC:
          /* If the function in the keymap is the one we are looking for,
             then add the current KEY to the list of invoking keys. */
          if (map[key].function == function)
            {
              char *keyname;

              keyname = _rl_get_keyname (key);

              if (result_index + 2 > result_size)
                {
                  result_size += 10;
                  result = (char **)xrealloc (result, result_size * sizeof (char *));
                }

              result[result_index++] = keyname;
              result[result_index] = (char *)NULL;
            }
          break;

        case ISKMAP:
          {
            char **seqs;
            register int i;

            /* Find the list of keyseqs in this map which have FUNCTION as
               their target.  Add the key sequences found to RESULT. */
            if (map[key].function)
              seqs =
                rl_invoking_keyseqs_in_map (function, FUNCTION_TO_KEYMAP (map, key));
            else
              break;

            if (seqs == 0)
              break;

            for (i = 0; seqs[i]; i++)
              {
                char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));

                if (key == ESC)
#if 0
                  sprintf (keyname, "\\e");
#else
                /* XXX - experimental */
                  sprintf (keyname, "\\M-");
#endif
                else if (CTRL_CHAR (key))
                  sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
                else if (key == RUBOUT)
                  sprintf (keyname, "\\C-?");
                else if (key == '\\' || key == '"')
                  {
                    keyname[0] = '\\';
                    keyname[1] = (char) key;
                    keyname[2] = '\0';
                  }
                else
                  {
                    keyname[0] = (char) key;
                    keyname[1] = '\0';
                  }
                
                strcat (keyname, seqs[i]);
                free (seqs[i]);

                if (result_index + 2 > result_size)
                  {
                    result_size += 10;
                    result = (char **)xrealloc (result, result_size * sizeof (char *));
                  }

                result[result_index++] = keyname;
                result[result_index] = (char *)NULL;
              }

            free (seqs);
          }
          break;
        }
    }
  return (result);
}

Here is the call graph for this function:

void rl_list_funmap_names

(

)

Definition at line 1750 of file bind.c.

References free, rl_funmap_names(), and rl_outstream.

{
  register int i;
  const char **funmap_names;

  funmap_names = rl_funmap_names ();

  if (!funmap_names)
    return;

  for (i = 0; funmap_names[i]; i++)
    fprintf (rl_outstream, "%s\n", funmap_names[i]);

  free (funmap_names);
}

Here is the call graph for this function:

int rl_macro_bind	(	char *	keyseq,
		char *	macro,
		Keymap	map
	)			const

Definition at line 304 of file bind.c.

References free, ISMACR, map, rl_generic_bind(), rl_translate_keyseq(), strlen(), and xmalloc().

{
  char *macro_keys;
  int macro_keys_len;

  macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);

  if (rl_translate_keyseq (macro, macro_keys, &macro_keys_len))
    {
      free (macro_keys);
      return -1;
    }
  rl_generic_bind (ISMACR, keyseq, macro_keys, map);
  return 0;
}

Here is the call graph for this function:

void rl_macro_dumper

(

int

print_readably

)

Definition at line 2101 of file bind.c.

References _rl_keymap, _rl_macro_dumper_internal(), and NULL.

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

Here is the call graph for this function:

rl_command_func_t* rl_named_function

(

char *

string

)

const

Definition at line 637 of file bind.c.

References _rl_stricmp(), function, funmap, name, NULL, and rl_initialize_funmap().

{
  register int i;

  rl_initialize_funmap ();

  for (i = 0; funmap[i]; i++)
    if (_rl_stricmp (funmap[i]->name, string) == 0)
      return (funmap[i]->function);
  return ((rl_command_func_t *)NULL);
}

Here is the call graph for this function:

int rl_parse_and_bind

(

char *

string

)

Definition at line 1113 of file bind.c.

References _rl_init_file_error(), _rl_keymap, _rl_parsing_conditionalized_out, _rl_stricmp(), _rl_to_upper, CTRL, delimiter, emacs_meta_keymap, free, glean_key_from_name(), handle_parser_directive(), ISKMAP, key, META, rl_bind_key(), rl_bind_keyseq(), rl_generic_bind(), rl_macro_bind(), rl_named_function(), rl_variable_bind(), strlen(), strrchr(), substring_member_of_array(), value, whitespace, and xmalloc().

{
  char *funname, *kname;
  register int c, i;
  int key, equivalency;

  while (string && whitespace (*string))
    string++;

  if (!string || !*string || *string == '#')
    return 0;

  /* If this is a parser directive, act on it. */
  if (*string == '$')
    {
      handle_parser_directive (&string[1]);
      return 0;
    }

  /* If we aren't supposed to be parsing right now, then we're done. */
  if (_rl_parsing_conditionalized_out)
    return 0;

  i = 0;
  /* If this keyname is a complex key expression surrounded by quotes,
     advance to after the matching close quote.  This code allows the
     backslash to quote characters in the key expression. */
  if (*string == '"')
    {
      int passc = 0;

      for (i = 1; c = string[i]; i++)
        {
          if (passc)
            {
              passc = 0;
              continue;
            }

          if (c == '\\')
            {
              passc++;
              continue;
            }

          if (c == '"')
            break;
        }
      /* If we didn't find a closing quote, abort the line. */
      if (string[i] == '\0')
        {
          _rl_init_file_error ("no closing `\"' in key binding");
          return 1;
        }
    }

  /* Advance to the colon (:) or whitespace which separates the two objects. */
  for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );

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

  /* Mark the end of the command (or keyname). */
  if (string[i])
    string[i++] = '\0';

  /* If doing assignment, skip the '=' sign as well. */
  if (equivalency)
    string[i++] = '\0';

  /* If this is a command to set a variable, then do that. */
  if (_rl_stricmp (string, "set") == 0)
    {
      char *var = string + i;
      char *value;

      /* Make VAR point to start of variable name. */
      while (*var && whitespace (*var)) var++;

      /* Make VALUE point to start of value string. */
      value = var;
      while (*value && !whitespace (*value)) value++;
      if (*value)
        *value++ = '\0';
      while (*value && whitespace (*value)) value++;

      rl_variable_bind (var, value);
      return 0;
    }

  /* Skip any whitespace between keyname and funname. */
  for (; string[i] && whitespace (string[i]); i++);
  funname = &string[i];

  /* Now isolate funname.
     For straight function names just look for whitespace, since
     that will signify the end of the string.  But this could be a
     macro definition.  In that case, the string is quoted, so skip
     to the matching delimiter.  We allow the backslash to quote the
     delimiter characters in the macro body. */
  /* This code exists to allow whitespace in macro expansions, which
     would otherwise be gobbled up by the next `for' loop.*/
  /* XXX - it may be desirable to allow backslash quoting only if " is
     the quoted string delimiter, like the shell. */
  if (*funname == '\'' || *funname == '"')
    {
      int delimiter = string[i++], passc;

      for (passc = 0; c = string[i]; i++)
        {
          if (passc)
            {
              passc = 0;
              continue;
            }

          if (c == '\\')
            {
              passc = 1;
              continue;
            }

          if (c == delimiter)
            break;
        }
      if (c)
        i++;
    }

  /* Advance to the end of the string.  */
  for (; string[i] && !whitespace (string[i]); i++);

  /* No extra whitespace at the end of the string. */
  string[i] = '\0';

  /* Handle equivalency bindings here.  Make the left-hand side be exactly
     whatever the right-hand evaluates to, including keymaps. */
  if (equivalency)
    {
      return 0;
    }

  /* If this is a new-style key-binding, then do the binding with
     rl_bind_keyseq ().  Otherwise, let the older code deal with it. */
  if (*string == '"')
    {
      char *seq;
      register int j, k, passc;

      seq = (char *)xmalloc (1 + strlen (string));
      for (j = 1, k = passc = 0; string[j]; j++)
        {
          /* Allow backslash to quote characters, but leave them in place.
             This allows a string to end with a backslash quoting another
             backslash, or with a backslash quoting a double quote.  The
             backslashes are left in place for rl_translate_keyseq (). */
          if (passc || (string[j] == '\\'))
            {
              seq[k++] = string[j];
              passc = !passc;
              continue;
            }

          if (string[j] == '"')
            break;

          seq[k++] = string[j];
        }
      seq[k] = '\0';

      /* Binding macro? */
      if (*funname == '\'' || *funname == '"')
        {
          j = strlen (funname);

          /* Remove the delimiting quotes from each end of FUNNAME. */
          if (j && funname[j - 1] == *funname)
            funname[j - 1] = '\0';

          rl_macro_bind (seq, &funname[1], _rl_keymap);
        }
      else
        rl_bind_keyseq (seq, rl_named_function (funname));

      free (seq);
      return 0;
    }

  /* Get the actual character we want to deal with. */
  kname = strrchr (string, '-');
  if (!kname)
    kname = string;
  else
    kname++;

  key = glean_key_from_name (kname);

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

  if (substring_member_of_array (string, _rl_possible_meta_prefixes))
    key = META (key);

  /* Temporary.  Handle old-style keyname with macro-binding. */
  if (*funname == '\'' || *funname == '"')
    {
      char useq[2];
      int fl = strlen (funname);

      useq[0] = key; useq[1] = '\0';
      if (fl && funname[fl - 1] == *funname)
        funname[fl - 1] = '\0';

      rl_macro_bind (useq, &funname[1], _rl_keymap);
    }
#if defined (PREFIX_META_HACK)
  /* Ugly, but working hack to keep prefix-meta around. */
  else if (_rl_stricmp (funname, "prefix-meta") == 0)
    {
      char seq[2];

      seq[0] = key;
      seq[1] = '\0';
      rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, _rl_keymap);
    }
#endif /* PREFIX_META_HACK */
  else
    rl_bind_key (key, rl_named_function (funname));
  return 0;
}

Here is the call graph for this function:

int rl_re_read_init_file	(	int	count,
		int	ignore
	)

Definition at line 768 of file bind.c.

References NULL, rl_read_init_file(), and rl_set_keymap_from_edit_mode().

{
  int r;
  r = rl_read_init_file ((const char *)NULL);
  rl_set_keymap_from_edit_mode ();
  return r;
}

Here is the call graph for this function:

int rl_read_init_file

(

char *

filename

)

const

Definition at line 785 of file bind.c.

References _rl_read_init_file(), DEFAULT_INPUTRC, and sh_get_env_value().

{
  /* Default the filename. */
  if (filename == 0)
    {
      filename = last_readline_init_file;
      if (filename == 0)
        filename = sh_get_env_value ("INPUTRC");
      if (filename == 0)
        filename = DEFAULT_INPUTRC;
    }

  if (*filename == 0)
    filename = DEFAULT_INPUTRC;

#if defined (__MSDOS__)
  if (_rl_read_init_file (filename, 0) == 0)
    return 0;
  filename = "~/_inputrc";
#endif
  return (_rl_read_init_file (filename, 0));
}

Here is the call graph for this function:

int rl_set_key	(	char *	keyseq,
		rl_command_func_t *	function,
		Keymap	map
	)			const

Definition at line 258 of file bind.c.

References ISFUNC, map, and rl_generic_bind().

{
  return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}

Here is the call graph for this function:

void rl_set_keymap

(

Keymap

map

)

Definition at line 1700 of file bind.c.

References _rl_keymap.

{
  if (map)
    _rl_keymap = map;
}

void rl_set_keymap_from_edit_mode

(

)

Definition at line 1714 of file bind.c.

References _rl_keymap, emacs_mode, emacs_standard_keymap, rl_editing_mode, vi_insertion_keymap, and vi_mode.

{
  if (rl_editing_mode == emacs_mode)
    _rl_keymap = emacs_standard_keymap;
#if defined (VI_MODE)
  else if (rl_editing_mode == vi_mode)
    _rl_keymap = vi_insertion_keymap;
#endif /* VI_MODE */
}

int rl_translate_keyseq	(	char *	seq,
		char *	array,
		int *	len
	)			const

Definition at line 430 of file bind.c.

References _rl_to_upper, CTRL, ESC, HEXVALUE, ISOCTAL, ISXDIGIT, largest_char, NEWLINE, OCTVALUE, RETURN, RUBOUT, and TAB.

{
  register int i, c, l, temp;

  for (i = l = 0; c = seq[i]; i++)
    {
      if (c == '\\')
        {
          c = seq[++i];

          if (c == 0)
            break;

          /* Handle \C- and \M- prefixes. */
          if ((c == 'C' || c == 'M') && seq[i + 1] == '-')
            {
              /* Handle special case of backwards define. */
              if (strncmp (&seq[i], "C-\\M-", 5) == 0)
                {
                  array[l++] = ESC;     /* ESC is meta-prefix */
                  i += 5;
                  array[l++] = CTRL (_rl_to_upper (seq[i]));
                  if (seq[i] == '\0')
                    i--;
                }
              else if (c == 'M')
                {
                  i++;
                  array[l++] = ESC;     /* ESC is meta-prefix */
                }
              else if (c == 'C')
                {
                  i += 2;
                  /* Special hack for C-?... */
                  array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
                }
              continue;
            }         

          /* Translate other backslash-escaped characters.  These are the
             same escape sequences that bash's `echo' and `printf' builtins
             handle, with the addition of \d -> RUBOUT.  A backslash
             preceding a character that is not special is stripped. */
          switch (c)
            {
            case 'a':
              array[l++] = '\007';
              break;
            case 'b':
              array[l++] = '\b';
              break;
            case 'd':
              array[l++] = RUBOUT;      /* readline-specific */
              break;
            case 'e':
              array[l++] = ESC;
              break;
            case 'f':
              array[l++] = '\f';
              break;
            case 'n':
              array[l++] = NEWLINE;
              break;
            case 'r':
              array[l++] = RETURN;
              break;
            case 't':
              array[l++] = TAB;
              break;
            case 'v':
              array[l++] = 0x0B;
              break;
            case '\\':
              array[l++] = '\\';
              break;
            case '0': case '1': case '2': case '3':
            case '4': case '5': case '6': case '7':
              i++;
              for (temp = 2, c -= '0'; ISOCTAL (seq[i]) && temp--; i++)
                c = (c * 8) + OCTVALUE (seq[i]);
              i--;      /* auto-increment in for loop */
              array[l++] = c & largest_char;
              break;
            case 'x':
              i++;
              for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i]) && temp--; i++)
                c = (c * 16) + HEXVALUE (seq[i]);
              if (temp == 2)
                c = 'x';
              i--;      /* auto-increment in for loop */
              array[l++] = c & largest_char;
              break;
            default:    /* backslashes before non-special chars just add the char */
              array[l++] = c;
              break;    /* the backslash is stripped */
            }
          continue;
        }

      array[l++] = c;
    }

  *len = l;
  array[l] = '\0';
  return (0);
}

int rl_unbind_command_in_map	(	char *	command,
		Keymap	map
	)			const

Definition at line 221 of file bind.c.

References func, map, rl_named_function(), and rl_unbind_function_in_map().

{
  rl_command_func_t *func;

  func = rl_named_function (command);
  if (func == 0)
    return 0;
  return (rl_unbind_function_in_map (func, map));
}

Here is the call graph for this function:

int rl_unbind_function_in_map	(	rl_command_func_t *	func,
		Keymap	map
	)

Definition at line 203 of file bind.c.

References function, ISFUNC, KEYMAP_SIZE, map, and NULL.

{
  register int i, rval;

  for (i = rval = 0; i < KEYMAP_SIZE; i++)
    {
      if (map[i].type == ISFUNC && map[i].function == func)
        {
          map[i].function = (rl_command_func_t *)NULL;
          rval = 1;
        }
    }
  return rval;
}

int rl_unbind_key

(

int

key

)

Definition at line 185 of file bind.c.

References NULL, and rl_bind_key().

{
  return (rl_bind_key (key, (rl_command_func_t *)NULL));
}

Here is the call graph for this function:

int rl_unbind_key_in_map	(	int	key,
		Keymap	map
	)

Definition at line 194 of file bind.c.

References map, NULL, and rl_bind_key_in_map().

{
  return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));
}

Here is the call graph for this function:

char* rl_untranslate_keyseq

(

int

seq

)

Definition at line 541 of file bind.c.

References _rl_to_lower, CTRL_CHAR, ESC, META_CHAR, RUBOUT, UNCTRL, and UNMETA.

{
  static char kseq[16];
  int i, c;

  i = 0;
  c = seq;
  if (META_CHAR (c))
    {
      kseq[i++] = '\\';
      kseq[i++] = 'M';
      kseq[i++] = '-';
      c = UNMETA (c);
    }
  else if (CTRL_CHAR (c))
    {
      kseq[i++] = '\\';
      kseq[i++] = 'C';
      kseq[i++] = '-';
      c = _rl_to_lower (UNCTRL (c));
    }
  else if (c == RUBOUT)
    {
      kseq[i++] = '\\';
      kseq[i++] = 'C';
      kseq[i++] = '-';
      c = '?';
    }

  if (c == ESC)
    {
      kseq[i++] = '\\';
      c = 'e';
    }
  else if (c == '\\' || c == '"')
    {
      kseq[i++] = '\\';
    }

  kseq[i++] = (unsigned char) c;
  kseq[i] = '\0';
  return kseq;
}

int rl_variable_bind	(	char *	name,
		char *	value
	)			const

Definition at line 1477 of file bind.c.

References bool_to_int(), boolean_varlist, find_boolean_var(), find_string_var(), flags, hack_special_boolean_var(), set_func, and string_varlist.

{
  register int i;
  int   v;

  /* Check for simple variables first. */
  i = find_boolean_var (name);
  if (i >= 0)
    {
      *boolean_varlist[i].value = bool_to_int (value);
      if (boolean_varlist[i].flags & V_SPECIAL)
        hack_special_boolean_var (i);
      return 0;
    }

  i = find_string_var (name);

  /* For the time being, unknown variable names or string names without a
     handler function are simply ignored. */
  if (i < 0 || string_varlist[i].set_func == 0)
    return 0;

  v = (*string_varlist[i].set_func) (value);
  return v;
}

Here is the call graph for this function:

void rl_variable_dumper

(

int

print_readably

)

Definition at line 2119 of file bind.c.

References _rl_bell_preference, _rl_comment_begin, _rl_isearch_terminators, _rl_keymap, _rl_untranslate_macro_value(), AUDIBLE_BELL, boolean_varlist, emacs_mode, free, name, NO_BELL, RL_COMMENT_BEGIN_DEFAULT, rl_completion_query_items, rl_editing_mode, rl_get_keymap_name(), rl_get_keymap_name_from_edit_mode(), rl_outstream, value, and VISIBLE_BELL.

{
  int i;
  const char *kname;

  for (i = 0; boolean_varlist[i].name; i++)
    {
      if (print_readably)
        fprintf (rl_outstream, "set %s %s\n", boolean_varlist[i].name,
                               *boolean_varlist[i].value ? "on" : "off");
      else
        fprintf (rl_outstream, "%s is set to `%s'\n", boolean_varlist[i].name,
                               *boolean_varlist[i].value ? "on" : "off");
    }

  /* bell-style */
  switch (_rl_bell_preference)
    {
    case NO_BELL:
      kname = "none"; break;
    case VISIBLE_BELL:
      kname = "visible"; break;
    case AUDIBLE_BELL:
    default:
      kname = "audible"; break;
    }
  if (print_readably)
    fprintf (rl_outstream, "set bell-style %s\n", kname);
  else
    fprintf (rl_outstream, "bell-style is set to `%s'\n", kname);

  /* comment-begin */
  if (print_readably)
    fprintf (rl_outstream, "set comment-begin %s\n", _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
  else
    fprintf (rl_outstream, "comment-begin is set to `%s'\n", _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);

  /* completion-query-items */
  if (print_readably)
    fprintf (rl_outstream, "set completion-query-items %d\n", rl_completion_query_items);
  else
    fprintf (rl_outstream, "completion-query-items is set to `%d'\n", rl_completion_query_items);

  /* editing-mode */
  if (print_readably)
    fprintf (rl_outstream, "set editing-mode %s\n", (rl_editing_mode == emacs_mode) ? "emacs" : "vi");
  else
    fprintf (rl_outstream, "editing-mode is set to `%s'\n", (rl_editing_mode == emacs_mode) ? "emacs" : "vi");

  /* isearch-terminators */
  if (_rl_isearch_terminators)
    {
      char *disp;

      disp = _rl_untranslate_macro_value (_rl_isearch_terminators);

      if (print_readably)
        fprintf (rl_outstream, "set isearch-terminators \"%s\"\n", disp);
      else
        fprintf (rl_outstream, "isearch-terminators is set to \"%s\"\n", disp);

      free (disp);
    }

  /* keymap */
  kname = rl_get_keymap_name (_rl_keymap);
  if (kname == 0)
    kname = rl_get_keymap_name_from_edit_mode ();
  if (print_readably)
    fprintf (rl_outstream, "set keymap %s\n", kname ? kname : "none");
  else
    fprintf (rl_outstream, "keymap is set to `%s'\n", kname ? kname : "none");
}

Here is the call graph for this function:

char* strchr

(

)

char* * strrchr

(

)

static int substring_member_of_array	(	char *	string,
		const char **	array
	)			[static]

Definition at line 2210 of file bind.c.

References _rl_strindex().

{
  while (*array)
    {
      if (_rl_strindex (string, *array))
        return (1);
      array++;
    }
  return (0);
}

Here is the call graph for this function:

static int sv_bell_style

(

char *

value

)

const [static]

Definition at line 1570 of file bind.c.

References _rl_bell_preference, _rl_stricmp(), AUDIBLE_BELL, NO_BELL, and VISIBLE_BELL.

{
  if (value == 0 || *value == '\0')
    _rl_bell_preference = AUDIBLE_BELL;
  else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
    _rl_bell_preference = NO_BELL;
  else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
    _rl_bell_preference = AUDIBLE_BELL;
  else if (_rl_stricmp (value, "visible") == 0)
    _rl_bell_preference = VISIBLE_BELL;
  else
    return 1;
  return 0;
}

Here is the call graph for this function:

static int sv_combegin

(

char *

value

)

const [static]

Definition at line 1526 of file bind.c.

References _rl_comment_begin, FREE, and savestring.

{
  if (value && *value)
    {
      FREE (_rl_comment_begin);
      _rl_comment_begin = savestring (value);
      return 0;
    }
  return 1;
}

static int sv_compquery

(

char *

value

)

const [static]

Definition at line 1539 of file bind.c.

References atoi(), and rl_completion_query_items.

{
  int nval = 100;

  if (value && *value)
    {
      nval = atoi (value);
      if (nval < 0)
        nval = 0;
    }
  rl_completion_query_items = nval;
  return 0;
}

Here is the call graph for this function:

static int sv_editmode

(

char *

value

)

const [static]

Definition at line 1505 of file bind.c.

References _rl_keymap, _rl_strnicmp(), emacs_mode, emacs_standard_keymap, rl_editing_mode, vi_insertion_keymap, and vi_mode.

{
  if (_rl_strnicmp (value, "vi", 2) == 0)
    {
#if defined (VI_MODE)
      _rl_keymap = vi_insertion_keymap;
      rl_editing_mode = vi_mode;
#endif /* VI_MODE */
      return 0;
    }
  else if (_rl_strnicmp (value, "emacs", 5) == 0)
    {
      _rl_keymap = emacs_standard_keymap;
      rl_editing_mode = emacs_mode;
      return 0;
    }
  return 1;
}

Here is the call graph for this function:

static int sv_isrchterm

(

char *

value

)

const [static]

Definition at line 1587 of file bind.c.

References _rl_isearch_terminators, free, FREE, rl_translate_keyseq(), savestring, strlen(), whitespace, and xmalloc().

{
  int beg, end, delim;
  char *v;

  if (value == 0)
    return 1;

  /* Isolate the value and translate it into a character string. */
  v = savestring (value);
  FREE (_rl_isearch_terminators);
  if (v[0] == '"' || v[0] == '\'')
    {
      delim = v[0];
      for (beg = end = 1; v[end] && v[end] != delim; end++)
        ;
    }
  else
    {
      for (beg = end = 0; whitespace (v[end]) == 0; end++)
        ;
    }

  v[end] = '\0';

  /* The value starts at v + beg.  Translate it into a character string. */
  _rl_isearch_terminators = (char *)xmalloc (2 * strlen (v) + 1);
  rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
  _rl_isearch_terminators[end] = '\0';

  free (v);
  return 0;
}

Here is the call graph for this function:

static int sv_keymap

(

char *

value

)

const [static]

Definition at line 1555 of file bind.c.

References rl_get_keymap_by_name(), and rl_set_keymap().

{
  Keymap kmap;

  kmap = rl_get_keymap_by_name (value);
  if (kmap)
    {
      rl_set_keymap (kmap);
      return 0;
    }
  return 1;
}

Here is the call graph for this function:

---

Variable Documentation

const char* _rl_possible_control_prefixes[]

Initial value:

 {
  "Control-", "C-", "CTRL-", (const char *)NULL
}

Definition at line 896 of file bind.c.

const char* _rl_possible_meta_prefixes[]

Initial value:

 {
  "Meta", "M-", (const char *)NULL
}

Definition at line 900 of file bind.c.

int _rl_prefer_visible_bell = 1 [static]

Definition at line 83 of file bind.c.

struct { ... } boolean_varlist[] [static]

const char* current_readline_init_file [static]

Definition at line 715 of file bind.c.

int current_readline_init_include_level [static]

Definition at line 716 of file bind.c.

int current_readline_init_lineno [static]

Definition at line 717 of file bind.c.

int currently_reading_init_file [static]

Definition at line 80 of file bind.c.

int errno

int flags

Definition at line 1440 of file bind.c.

int flags

Definition at line 1354 of file bind.c.

_rl_parser_func_t* function

Definition at line 1061 of file bind.c.

unsigned char* if_stack = (unsigned char *)NULL [static]

Definition at line 910 of file bind.c.

int if_stack_depth [static]

Definition at line 911 of file bind.c.

int if_stack_size [static]

Definition at line 912 of file bind.c.

struct { ... } keymap_names[] [static]

char* last_readline_init_file = (char *)NULL [static]

Definition at line 712 of file bind.c.

Keymap map

Definition at line 1661 of file bind.c.

const char* name

Definition at line 1660 of file bind.c.

const char* name

Definition at line 1439 of file bind.c.

const char* name

Definition at line 1352 of file bind.c.

const char* name

Definition at line 1060 of file bind.c.

assoc_list name_key_alist[] [static]

Initial value:

 {
  { "DEL", 0x7f },
  { "ESC", '\033' },
  { "Escape", '\033' },
  { "LFD", '\n' },
  { "Newline", '\n' },
  { "RET", '\r' },
  { "Return", '\r' },
  { "Rubout", 0x7f },
  { "SPC", ' ' },
  { "Space", ' ' },
  { "Tab", 0x09 },
  { (char *)0x0, 0 }
}

Definition at line 1630 of file bind.c.

struct { ... } parser_directives[] [static]

Keymap rl_binding_keymap

Definition at line 72 of file bind.c.

const char* rl_readline_name = "other"

Definition at line 907 of file bind.c.

_rl_sv_func_t* set_func

Definition at line 1441 of file bind.c.

struct { ... } string_varlist[] [static]

int* value

Definition at line 1353 of file bind.c.

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.