URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [readline/] [bind.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/* bind.c -- key binding and startup file support for the readline library. */
 
/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
 
   This file is part of the GNU Readline Library, a library for
   reading lines of text with interactive input and history editing.
 
   The GNU Readline Library is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.
 
   The GNU Readline Library is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   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
   have a copy of the license, write to the Free Software Foundation,
   59 Temple Place, Suite 330, Boston, MA 02111 USA. */
#define READLINE_LIBRARY
 
#if defined (HAVE_CONFIG_H)
#  include <config.h>
#endif
 
#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#if defined (HAVE_SYS_FILE_H)
#  include <sys/file.h>
#endif /* HAVE_SYS_FILE_H */
 
#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif /* HAVE_UNISTD_H */
 
#if defined (HAVE_STDLIB_H)
#  include <stdlib.h>
#else
#  include "ansi_stdlib.h"
#endif /* HAVE_STDLIB_H */
 
#include <errno.h>
 
#if !defined (errno)
extern int errno;
#endif /* !errno */
 
#include "posixstat.h"
 
/* System-specific feature definitions and include files. */
#include "rldefs.h"
 
/* Some standard library routines. */
#include "readline.h"
#include "history.h"
 
#include "rlprivate.h"
#include "rlshell.h"
#include "xmalloc.h"
 
#if !defined (strchr) && !defined (__STDC__)
extern char *strchr (), *strrchr ();
#endif /* !strchr && !__STDC__ */
 
/* Variables exported by this file. */
Keymap rl_binding_keymap;
 
static int _rl_read_init_file __P((char *, int));
static int glean_key_from_name __P((char *));
static int substring_member_of_array __P((char *, char **));
 
static int currently_reading_init_file;
 
/* used only in this file */
static int _rl_prefer_visible_bell = 1;
 
/* **************************************************************** */
/*                                                                  */
/*                      Binding keys                                */
/*                                                                  */
/* **************************************************************** */
 
/* rl_add_defun (char *name, Function *function, int key)
   Add NAME to the list of named functions.  Make FUNCTION be the function
   that gets called.  If KEY is not -1, then bind it. */
int
rl_add_defun (name, function, key)
     char *name;
     Function *function;
     int key;
{
  if (key != -1)
    rl_bind_key (key, function);
  rl_add_funmap_entry (name, function);
  return 0;
}
 
/* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
int
rl_bind_key (key, function)
     int key;
     Function *function;
{
  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);
}
 
/* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
   KEY. */
int
rl_bind_key_in_map (key, function, map)
     int key;
     Function *function;
     Keymap map;
{
  int result;
  Keymap oldmap;
 
  oldmap = _rl_keymap;
  _rl_keymap = map;
  result = rl_bind_key (key, function);
  _rl_keymap = oldmap;
  return (result);
}
 
/* Make KEY do nothing in the currently selected keymap.
   Returns non-zero in case of error. */
int
rl_unbind_key (key)
     int key;
{
  return (rl_bind_key (key, (Function *)NULL));
}
 
/* Make KEY do nothing in MAP.
   Returns non-zero in case of error. */
int
rl_unbind_key_in_map (key, map)
     int key;
     Keymap map;
{
  return (rl_bind_key_in_map (key, (Function *)NULL, map));
}
 
/* Unbind all keys bound to FUNCTION in MAP. */
int
rl_unbind_function_in_map (func, map)
     Function *func;
     Keymap map;
{
  register int i, rval;
 
  for (i = rval = 0; i < KEYMAP_SIZE; i++)
    {
      if (map[i].type == ISFUNC && map[i].function == func)
        {
          map[i].function = (Function *)NULL;
          rval = 1;
        }
    }
  return rval;
}
 
int
rl_unbind_command_in_map (command, map)
     char *command;
     Keymap map;
{
  Function *func;
 
  func = rl_named_function (command);
  if (func == 0)
    return 0;
  return (rl_unbind_function_in_map (func, map));
}
 
/* Bind the key sequence represented by the string KEYSEQ to
   FUNCTION.  This makes new keymaps as necessary.  The initial
   place to do bindings is in MAP. */
int
rl_set_key (keyseq, function, map)
     char *keyseq;
     Function *function;
     Keymap map;
{
  return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}
 
/* Bind the key sequence represented by the string KEYSEQ to
   the string of characters MACRO.  This makes new keymaps as
   necessary.  The initial place to do bindings is in MAP. */
int
rl_macro_bind (keyseq, macro, map)
     char *keyseq, *macro;
     Keymap map;
{
  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;
}
 
/* Bind the key sequence represented by the string KEYSEQ to
   the arbitrary pointer DATA.  TYPE says what kind of data is
   pointed to by DATA, right now this can be a function (ISFUNC),
   a macro (ISMACR), or a keymap (ISKMAP).  This makes new keymaps
   as necessary.  The initial place to do bindings is in MAP. */
int
rl_generic_bind (type, keyseq, data, map)
     int type;
     char *keyseq, *data;
     Keymap map;
{
  char *keys;
  int keys_len;
  register int i;
 
  /* If no keys to bind to, exit right away. */
  if (!keyseq || !*keyseq)
    {
      if (type == ISMACR)
        free (data);
      return -1;
    }
 
  keys = 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++)
    {
      int ic = (int) ((unsigned char)keys[i]);
 
      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)
            {
              if (map[ic].type == ISMACR)
                free ((char *)map[ic].function);
 
              map[ic].type = ISKMAP;
              map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
            }
          map = FUNCTION_TO_KEYMAP (map, ic);
        }
      else
        {
          if (map[ic].type == ISMACR)
            free ((char *)map[ic].function);
 
          map[ic].function = KEYMAP_TO_FUNCTION (data);
          map[ic].type = type;
        }
 
      rl_binding_keymap = map;
    }
  free (keys);
  return 0;
}
 
/* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
   an array of characters.  LEN gets the final length of ARRAY.  Return
   non-zero if there was an error parsing SEQ. */
int
rl_translate_keyseq (seq, array, len)
     char *seq, *array;
     int *len;
{
  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;
                  i += 5;
                  array[l++] = CTRL (_rl_to_upper (seq[i]));
                  if (seq[i] == '\0')
                    i--;
                }
              else if (c == 'M')
                {
                  i++;
                  array[l++] = ESC;     /* XXX */
                }
              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 + 1);
              break;
            case 'x':
              i++;
              for (temp = 3, c = 0; isxdigit (seq[i]) && temp--; i++)
                c = (c * 16) + HEXVALUE (seq[i]);
              if (temp == 3)
                c = 'x';
              i--;      /* auto-increment in for loop */
              array[l++] = c % (largest_char + 1);
              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);
}
 
char *
rl_untranslate_keyseq (seq)
     int seq;
{
  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;
}
 
static char *
_rl_untranslate_macro_value (seq)
     char *seq;
{
  char *ret, *r, *s;
  int c;
 
  r = ret = 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;
}
 
/* Return a pointer to the function that STRING represents.
   If STRING doesn't have a matching function, then a NULL pointer
   is returned. */
Function *
rl_named_function (string)
     char *string;
{
  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 ((Function *)NULL);
}
 
/* 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
   used.  TYPE, if non-NULL, is a pointer to an int which will receive the
   type of the object pointed to.  One of ISFUNC (function), ISKMAP (keymap),
   or ISMACR (macro). */
Function *
rl_function_of_keyseq (keyseq, map, type)
     char *keyseq;
     Keymap map;
     int *type;
{
  register int i;
 
  if (!map)
    map = _rl_keymap;
 
  for (i = 0; keyseq && keyseq[i]; i++)
    {
      int 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 ((Function *) NULL);
}
 
/* The last key bindings file read. */
static char *last_readline_init_file = (char *)NULL;
 
/* The file we're currently reading key bindings from. */
static char *current_readline_init_file;
static int current_readline_init_include_level;
static int current_readline_init_lineno;
 
/* Read FILENAME into a locally-allocated buffer and return the buffer.
   The size of the buffer is returned in *SIZEP.  Returns NULL if any
   errors were encountered. */
static char *
_rl_read_file (filename, sizep)
     char *filename;
     size_t *sizep;
{
  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 0
  if (i < file_size)
#else
  if (i < 0)
#endif
    {
      free (buffer);
      return ((char *)NULL);
    }
 
#if 0
  buffer[file_size] = '\0';
  if (sizep)
    *sizep = file_size;
#else
  buffer[i] = '\0';
  if (sizep)
    *sizep = i;
#endif
 
  return (buffer);
}
 
/* Re-read the current keybindings file. */
int
rl_re_read_init_file (count, ignore)
     int count, ignore;
{
  int r;
  r = rl_read_init_file ((char *)NULL);
  rl_set_keymap_from_edit_mode ();
  return r;
}
 
/* Do key bindings from a file.  If FILENAME is NULL it defaults
   to the first non-null filename from this list:
     1. the filename used for the previous call
     2. the value of the shell variable `INPUTRC'
     3. ~/.inputrc
   If the file existed and could be opened and read, 0 is returned,
   otherwise errno is returned. */
int
rl_read_init_file (filename)
     char *filename;
{
  /* Default the filename. */
  if (filename == 0)
    {
      filename = last_readline_init_file;
      if (filename == 0)
        filename = 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));
}
 
static int
_rl_read_init_file (filename, include_level)
     char *filename;
     int include_level;
{
  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 (__CYGWIN32__)
      /* ``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 void
_rl_init_file_error (msg)
     char *msg;
{
  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);
}
 
/* **************************************************************** */
/*                                                                  */
/*                      Parser Directives                           */
/*                                                                  */
/* **************************************************************** */
 
/* Conditionals. */
 
/* Calling programs set this to have their argv[0]. */
char *rl_readline_name = "other";
 
/* Stack of previous values of parsing_conditionalized_out. */
static unsigned char *if_stack = (unsigned char *)NULL;
static int if_stack_depth;
static int if_stack_size;
 
/* Push _rl_parsing_conditionalized_out, and set parser state based
   on ARGS. */
static int
parser_if (args)
     char *args;
{
  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;
}
 
/* Invert the current parser state if there is anything on the stack. */
static int
parser_else (args)
     char *args;
{
  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;
}
 
/* Terminate a conditional, popping the value of
   _rl_parsing_conditionalized_out from the stack. */
static int
parser_endif (args)
     char *args;
{
  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_include (args)
     char *args;
{
  char *old_init_file, *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 (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;
}
 
/* Associate textual names with actual functions. */
static struct {
  char *name;
  Function *function;
} parser_directives [] = {
  { "if", parser_if },
  { "endif", parser_endif },
  { "else", parser_else },
  { "include", parser_include },
  { (char *)0x0, (Function *)0x0 }
};
 
/* Handle a parser directive.  STATEMENT is the line of the directive
   without any leading `$'. */
static int
handle_parser_directive (statement)
     char *statement;
{
  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);
}
 
/* Read the binding command from STRING and perform it.
   A key binding command looks like: Keyname: function-name\0,
   a variable binding command looks like: set variable value.
   A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
int
rl_parse_and_bind (string)
     char *string;
{
  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_set_key ().  Otherwise, let the older code deal with it. */
  if (*string == '"')
    {
      char *seq;
      register int j, k, passc;
 
      seq = 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_set_key (seq, rl_named_function (funname), _rl_keymap);
 
      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, possible_control_prefixes))
    key = CTRL (_rl_to_upper (key));
 
  if (substring_member_of_array (string, possible_meta_prefixes))
    key = META (key);
 
  /* Temporary.  Handle old-style keyname with macro-binding. */
  if (*funname == '\'' || *funname == '"')
    {
      unsigned 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;
}
 
/* 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
   false. */
 
#define V_SPECIAL       0x1
 
static struct {
  char *name;
  int *value;
  int flags;
} boolean_varlist [] = {
  { "blink-matching-paren",     &rl_blink_matching_paren,       V_SPECIAL },
  { "completion-ignore-case",   &_rl_completion_case_fold,      0 },
  { "convert-meta",             &_rl_convert_meta_chars_to_ascii, 0 },
  { "disable-completion",       &rl_inhibit_completion,         0 },
  { "enable-keypad",            &_rl_enable_keypad,             0 },
  { "expand-tilde",             &rl_complete_with_tilde_expansion, 0 },
  { "horizontal-scroll-mode",   &_rl_horizontal_scroll_mode,    0 },
  { "input-meta",               &_rl_meta_flag,                 0 },
  { "mark-directories",         &_rl_complete_mark_directories, 0 },
  { "mark-modified-lines",      &_rl_mark_modified_lines,       0 },
  { "meta-flag",                &_rl_meta_flag,                 0 },
  { "output-meta",              &_rl_output_meta_chars,         0 },
  { "prefer-visible-bell",      &_rl_prefer_visible_bell,       V_SPECIAL },
  { "print-completions-horizontally", &_rl_print_completions_horizontally, 0 },
  { "show-all-if-ambiguous",    &_rl_complete_show_all,         0 },
#if defined (VISIBLE_STATS)
  { "visible-stats",            &rl_visible_stats,              0 },
#endif /* VISIBLE_STATS */
  { (char *)NULL, (int *)NULL }
};
 
static int
find_boolean_var (name)
     char *name;
{
  register int i;
 
  for (i = 0; boolean_varlist[i].name; i++)
    if (_rl_stricmp (name, boolean_varlist[i].name) == 0)
      return i;
  return -1;
}
 
/* Hooks for handling special boolean variables, where a
   function needs to be called or another variable needs
   to be changed when they're changed. */
static void
hack_special_boolean_var (i)
     int i;
{
  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;
    }
}
 
/* These *must* correspond to the array indices for the appropriate
   string variable.  (Though they're not used right now.) */
#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
 
/* Forward declarations */
static int sv_bell_style __P((char *));
static int sv_combegin __P((char *));
static int sv_compquery __P((char *));
static int sv_editmode __P((char *));
static int sv_isrchterm __P((char *));
static int sv_keymap __P((char *));
 
static struct {
  char *name;
  int flags;
  Function *set_func;
} string_varlist[] = {
  { "bell-style",       V_STRING,       sv_bell_style },
  { "comment-begin",    V_STRING,       sv_combegin },
  { "completion-query-items", V_INT,    sv_compquery },
  { "editing-mode",     V_STRING,       sv_editmode },
  { "isearch-terminators", V_STRING,    sv_isrchterm },
  { "keymap",           V_STRING,       sv_keymap },
  { (char *)NULL,       0 }
};
 
static int
find_string_var (name)
     char *name;
{
  register int i;
 
  for (i = 0; string_varlist[i].name; i++)
    if (_rl_stricmp (name, string_varlist[i].name) == 0)
      return i;
  return -1;
}
 
/* 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
   values result in 0 (false). */
static int
bool_to_int (value)
     char *value;
{
  return (value == 0 || *value == '\0' ||
                (_rl_stricmp (value, "on") == 0) ||
                (value[0] == '1' && value[1] == '\0'));
}
 
int
rl_variable_bind (name, value)
     char *name, *value;
{
  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;
}
 
static int
sv_editmode (value)
     char *value;
{
  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;
}
 
static int
sv_combegin (value)
     char *value;
{
  if (value && *value)
    {
      FREE (_rl_comment_begin);
      _rl_comment_begin = savestring (value);
      return 0;
    }
  return 1;
}
 
static int
sv_compquery (value)
     char *value;
{
  int nval = 100;
 
  if (value && *value)
    {
      nval = atoi (value);
      if (nval < 0)
        nval = 0;
    }
  rl_completion_query_items = nval;
  return 0;
}
 
static int
sv_keymap (value)
     char *value;
{
  Keymap kmap;
 
  kmap = rl_get_keymap_by_name (value);
  if (kmap)
    {
      rl_set_keymap (kmap);
      return 0;
    }
  return 1;
}
 
#define _SET_BELL(v)    do { _rl_bell_preference = v; return 0; } while (0)
 
static int
sv_bell_style (value)
     char *value;
{
  if (value == 0 || *value == '\0')
    _SET_BELL (AUDIBLE_BELL);
  else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
    _SET_BELL (NO_BELL);
  else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
    _SET_BELL (AUDIBLE_BELL);
  else if (_rl_stricmp (value, "visible") == 0)
    _SET_BELL (VISIBLE_BELL);
  else
    return 1;
}
#undef _SET_BELL
 
static int
sv_isrchterm (value)
     char *value;
{
  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 = (unsigned char *)xmalloc (2 * strlen (v) + 1);
  rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
  _rl_isearch_terminators[end] = '\0';
 
  free (v);
  return 0;
}
 
/* Return the character which matches NAME.
   For example, `Space' returns ' '. */
 
typedef struct {
  char *name;
  int value;
} assoc_list;
 
static assoc_list name_key_alist[] = {
  { "DEL", 0x7f },
  { "ESC", '\033' },
  { "Escape", '\033' },
  { "LFD", '\n' },
  { "Newline", '\n' },
  { "RET", '\r' },
  { "Return", '\r' },
  { "Rubout", 0x7f },
  { "SPC", ' ' },
  { "Space", ' ' },
  { "Tab", 0x09 },
  { (char *)0x0, 0 }
};
 
static int
glean_key_from_name (name)
     char *name;
{
  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) */
}
 
/* Auxiliary functions to manage keymaps. */
static struct {
  char *name;
  Keymap map;
} keymap_names[] = {
  { "emacs", emacs_standard_keymap },
  { "emacs-standard", emacs_standard_keymap },
  { "emacs-meta", emacs_meta_keymap },
  { "emacs-ctlx", emacs_ctlx_keymap },
#if defined (VI_MODE)
  { "vi", vi_movement_keymap },
  { "vi-move", vi_movement_keymap },
  { "vi-command", vi_movement_keymap },
  { "vi-insert", vi_insertion_keymap },
#endif /* VI_MODE */
  { (char *)0x0, (Keymap)0x0 }
};
 
Keymap
rl_get_keymap_by_name (name)
     char *name;
{
  register int i;
 
  for (i = 0; keymap_names[i].name; i++)
    if (strcmp (name, keymap_names[i].name) == 0)
      return (keymap_names[i].map);
  return ((Keymap) NULL);
}
 
char *
rl_get_keymap_name (map)
     Keymap map;
{
  register int i;
  for (i = 0; keymap_names[i].name; i++)
    if (map == keymap_names[i].map)
      return (keymap_names[i].name);
  return ((char *)NULL);
}
 
void
rl_set_keymap (map)
     Keymap map;
{
  if (map)
    _rl_keymap = map;
}
 
Keymap
rl_get_keymap ()
{
  return (_rl_keymap);
}
 
void
rl_set_keymap_from_edit_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 */
}
 
char *
rl_get_keymap_name_from_edit_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";
}
 
/* **************************************************************** */
/*                                                                  */
/*                Key Binding and Function Information              */
/*                                                                  */
/* **************************************************************** */
 
/* Each of the following functions produces information about the
   state of keybindings and functions known to Readline.  The info
   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 (). */
 
/* Print the names of functions known to Readline. */
void
rl_list_funmap_names ()
{
  register int i;
  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);
}
 
static char *
_rl_get_keyname (key)
     int key;
{
  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 0
  /* 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)
    {
      keyseq[0] = '\\';
      keyseq[1] = 'e';
      keyseq[2] = '\0';
      return keyseq;
    }
#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;
}
 
/* Return a NULL terminated array of strings which represent the key
   sequences that are used to invoke FUNCTION in MAP. */
char **
rl_invoking_keyseqs_in_map (function, map)
     Function *function;
     Keymap map;
{
  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)
                  sprintf (keyname, "\\e");
                else if (CTRL_CHAR (key))
                  sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
                else if (key == RUBOUT)
                  sprintf (keyname, "\\C-?");
                else if (key == '\\' || key == '"')
                  {
                    keyname[0] = '\\';
                    keyname[1] = (char) key;
                    keyname[2] = '\0';
                  }
                else
                  {
                    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);
}
 
/* Return a NULL terminated array of strings which represent the key
   sequences that can be used to invoke FUNCTION using the current keymap. */
char **
rl_invoking_keyseqs (function)
     Function *function;
{
  return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
}
 
/* 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
   that it can be read back in. */
void
rl_function_dumper (print_readably)
     int print_readably;
{
  register int i;
  char **names;
  char *name;
 
  names = rl_funmap_names ();
 
  fprintf (rl_outstream, "\n");
 
  for (i = 0; name = names[i]; i++)
    {
      Function *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);
            }
        }
    }
}
 
/* Print all of the current functions and their bindings to
   rl_outstream.  If an explicit argument is given, then print
   the output in such a way that it can be read back in. */
int
rl_dump_functions (count, key)
     int count, key;
{
  if (rl_dispatching)
    fprintf (rl_outstream, "\r\n");
  rl_function_dumper (rl_explicit_arg);
  rl_on_new_line ();
  return (0);
}
 
static void
_rl_macro_dumper_internal (print_readably, map, prefix)
     int print_readably;
     Keymap map;
     char *prefix;
{
  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);
#if 0
          out = (char *)map[key].function;
#else
          out = _rl_untranslate_macro_value ((char *)map[key].function);
#endif
          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);
#if 1
          free (out);
#endif
          break;
        case ISFUNC:
          break;
        case ISKMAP:
          prefix_len = prefix ? strlen (prefix) : 0;
          if (key == ESC)
            {
              keyname = 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 = 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;
        }
    }
}
 
void
rl_macro_dumper (print_readably)
     int print_readably;
{
  _rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
}
 
int
rl_dump_macros (count, key)
     int count, key;
{
  if (rl_dispatching)
    fprintf (rl_outstream, "\r\n");
  rl_macro_dumper (rl_explicit_arg);
  rl_on_new_line ();
  return (0);
}
 
void
rl_variable_dumper (print_readably)
     int print_readably;
{
  int i;
  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 : "");
 
  /* 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");
 
  /* 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");
 
  /* 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);
    }
}
 
/* Print all of the current variables and their values to
   rl_outstream.  If an explicit argument is given, then print
   the output in such a way that it can be read back in. */
int
rl_dump_variables (count, key)
     int count, key;
{
  if (rl_dispatching)
    fprintf (rl_outstream, "\r\n");
  rl_variable_dumper (rl_explicit_arg);
  rl_on_new_line ();
  return (0);
}
 
/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. */
void
_rl_bind_if_unbound (keyseq, default_func)
     char *keyseq;
     Function *default_func;
{
  Function *func;
 
  if (keyseq)
    {
      func = rl_function_of_keyseq (keyseq, _rl_keymap, (int *)NULL);
      if (!func || func == rl_do_lowercase_version)
        rl_set_key (keyseq, default_func, _rl_keymap);
    }
}
 
/* Return non-zero if any members of ARRAY are a substring in STRING. */
static int
substring_member_of_array (string, array)
     char *string, **array;
{
  while (*array)
    {
      if (_rl_strindex (string, *array))
        return (1);
      array++;
    }
  return (0);
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [readline/] [bind.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	578	markom	`/* bind.c -- key binding and startup file support for the readline library. */`
2
3			`/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.`
4
5			`This file is part of the GNU Readline Library, a library for`
6			`reading lines of text with interactive input and history editing.`
7
8			`The GNU Readline Library is free software; you can redistribute it`
9			`and/or modify it under the terms of the GNU General Public License`
10			`as published by the Free Software Foundation; either version 2, or`
11			`(at your option) any later version.`
12
13			`The GNU Readline Library is distributed in the hope that it will be`
14			`useful, but WITHOUT ANY WARRANTY; without even the implied warranty`
15			`of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`The GNU General Public License is often shipped with GNU software, and`
19			`is generally kept in a file called COPYING or LICENSE. If you do not`
20			`have a copy of the license, write to the Free Software Foundation,`
21			`59 Temple Place, Suite 330, Boston, MA 02111 USA. */`
22			`#define READLINE_LIBRARY`
23
24			`#if defined (HAVE_CONFIG_H)`
25			`# include <config.h>`
26			`#endif`
27
28			`#include <stdio.h>`
29			`#include <sys/types.h>`
30			`#include <fcntl.h>`
31			`#if defined (HAVE_SYS_FILE_H)`
32			`# include <sys/file.h>`
33			`#endif /* HAVE_SYS_FILE_H */`
34
35			`#if defined (HAVE_UNISTD_H)`
36			`# include <unistd.h>`
37			`#endif /* HAVE_UNISTD_H */`
38
39			`#if defined (HAVE_STDLIB_H)`
40			`# include <stdlib.h>`