/usr/src/gnu/lib/libreadline/bind.c

Bug Summary

File:	src/gnu/lib/libreadline/bind.c
Warning:	line 323, column 6 Argument to free() is a function pointer
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name bind.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/lib/libreadline/obj -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I /usr/src/gnu/lib/libreadline -D PIC -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/lib/libreadline/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/lib/libreadline/bind.c
1/* bind.c -- key binding and startup file support for the readline library. */

3/* 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. */
22#define READLINE_LIBRARY

24#if defined (HAVE_CONFIG_H1)
25#  include <config.h>
26#endif

28#include <stdio.h>
29#include <sys/types.h>
30#include <fcntl.h>
31#if defined (HAVE_SYS_FILE_H1)
32#  include <sys/file.h>
33#endif /* HAVE_SYS_FILE_H */

35#if defined (HAVE_UNISTD_H1)
36#  include <unistd.h>
37#endif /* HAVE_UNISTD_H */

39#if defined (HAVE_STDLIB_H1)
40#  include <stdlib.h>
41#else
42#  include "ansi_stdlib.h"
43#endif /* HAVE_STDLIB_H */

45#include <errno(*__errno()).h>

47#if !defined (errno(*__errno()))
48extern int errno(*__errno());
49#endif /* !errno */

51#include "posixstat.h"

53/* System-specific feature definitions and include files. */
54#include "rldefs.h"

56/* Some standard library routines. */
57#include "readline.h"
58#include "history.h"

60#include "rlprivate.h"
61#include "rlshell.h"
62#include "xmalloc.h"

64#if !defined (strchr) && !defined (__STDC__1)
65extern char *strchr (), *strrchr ();
66#endif /* !strchr && !__STDC__ */

68/* Variables exported by this file. */
69Keymap rl_binding_keymap;

71static char *_rl_read_file PARAMS((char *, size_t *))(char *, size_t *);
72static void _rl_init_file_error PARAMS((const char *))(const char *);
73static int _rl_read_init_file PARAMS((const char *, int))(const char *, int);
74static int glean_key_from_name PARAMS((char *))(char *);
75static int substring_member_of_array PARAMS((char *, const char **))(char *, const char **);

77static int currently_reading_init_file;

79/* used only in this file */
80static int _rl_prefer_visible_bell = 1;

82/* **************************************************************** */
83/*								    */
84/*			Binding keys				    */
85/*								    */
86/* **************************************************************** */

88/* rl_add_defun (char *name, rl_command_func_t *function, int key)
 Add NAME to the list of named functions.  Make FUNCTION be the function
 that gets called.  If KEY is not -1, then bind it. */
91int
92rl_add_defun (name, function, key)
   const char *name;
   rl_command_func_t *function;
   int key;
96{
if (key != -1)
  rl_bind_key (key, function);
rl_add_funmap_entry (name, function);
return 0;
101}

103/* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
104int
105rl_bind_key (key, function)
   int key;
   rl_command_func_t *function;
108{
if (key < 0)
  return (key);

if (META_CHAR (key)((key) > 0x07f && (key) <= 255) && _rl_convert_meta_chars_to_ascii)
  {
    if (_rl_keymap[ESC(('[') & 0x1f)].type == ISKMAP1)
{
 Keymap escmap;

 escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC)(Keymap)(_rl_keymap[(('[') & 0x1f)].function);
 key = UNMETA (key)((key) & (~0x080));
 escmap[key].type = ISFUNC0;
 escmap[key].function = function;
 return (0);
}
    return (key);
  }

_rl_keymap[key].type = ISFUNC0;
_rl_keymap[key].function = function;
rl_binding_keymap = _rl_keymap;
return (0);
131}

133/* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
 KEY. */
135int
136rl_bind_key_in_map (key, function, map)
   int key;
   rl_command_func_t *function;
   Keymap map;
140{
int result;
Keymap oldmap;

oldmap = _rl_keymap;
_rl_keymap = map;
result = rl_bind_key (key, function);
_rl_keymap = oldmap;
return (result);
149}

151/* Make KEY do nothing in the currently selected keymap.
 Returns non-zero in case of error. */
153int
154rl_unbind_key (key)
   int key;
156{
return (rl_bind_key (key, (rl_command_func_t *)NULL((void *)0)));
158}

160/* Make KEY do nothing in MAP.
 Returns non-zero in case of error. */
162int
163rl_unbind_key_in_map (key, map)
   int key;
   Keymap map;
166{
return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL((void *)0), map));
168}

170/* Unbind all keys bound to FUNCTION in MAP. */
171int
172rl_unbind_function_in_map (func, map)
   rl_command_func_t *func;
   Keymap map;
175{
register int i, rval;

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

189int
190rl_unbind_command_in_map (command, map)
   const char *command;
   Keymap map;
193{
rl_command_func_t *func;

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

202/* 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. */
205int
206rl_set_key (keyseq, function, map)
   const char *keyseq;
   rl_command_func_t *function;
   Keymap map;
210{
return (rl_generic_bind (ISFUNC0, keyseq, (char *)function, map));
6
←
Calling 'rl_generic_bind'→
212}

214/* 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. */
217int
218rl_macro_bind (keyseq, macro, map)
   const char *keyseq, *macro;
   Keymap map;
221{
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 (ISMACR2, keyseq, macro_keys, map);
return 0;
234}

236/* 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. */
241int
242rl_generic_bind (type, keyseq, data, map)
   int type;
   const char *keyseq;
   char *data;
   Keymap map;
247{
char *keys;
int keys_len;
register int i;
KEYMAP_ENTRY k;

k.function = 0;

/* If no keys to bind to, exit right away. */
if (!keyseq6.1
'keyseq' is non-null
 || !*keyseq)
7
←
Taking false branch→
  {
    if (type == ISMACR2)
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))
8
←
Taking false branch→
  {
    free (keys);
    return -1;
  }

/* Bind keys, making new keymaps as necessary. */
for (i = 0; i < keys_len; i++)
9
←
Loop condition is true.  Entering loop body→
  {
    unsigned char uc = keys[i];
    int ic;

    ic = uc;
    if (ic < 0 || ic10.1
'ic' is < KEYMAP_SIZE
 >= KEYMAP_SIZE257)
10
←
Assuming 'ic' is >= 0→
11
←
Taking false branch→
return -1;

    if (_rl_convert_meta_chars_to_ascii && META_CHAR (ic)((ic) > 0x07f && (ic) <= 255))
12
←
Assuming '_rl_convert_meta_chars_to_ascii' is 0→
{
 ic = UNMETA (ic)((ic) & (~0x080));
 if (map[ESC(('[') & 0x1f)].type == ISKMAP1)
   map = FUNCTION_TO_KEYMAP (map, ESC)(Keymap)(map[(('[') & 0x1f)].function);
}

    if ((i + 1) < keys_len)
13
←
Taking false branch→
{
 if (map[ic].type != ISKMAP1)
   {
     /* 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 = ISKMAP1;
     map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap())(rl_command_func_t *)(rl_make_bare_keymap());
   }
 map = FUNCTION_TO_KEYMAP (map, ic)(Keymap)(map[ic].function);
 /* 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 == ISFUNC0 && k.function != rl_do_lowercase_version) || k.type == ISMACR2))
   {
     map[ANYOTHERKEY257 -1] = k;
     k.function = 0;
   }
}
    else
{
 if (map[ic].type == ISMACR2)
14
←
Assuming field 'type' is equal to ISMACR→
15
←
Taking true branch→
   free ((char *)map[ic].function);
16
←
Argument to free() is a function pointer
 else if (map[ic].type == ISKMAP1)
   {
     map = FUNCTION_TO_KEYMAP (map, ic)(Keymap)(map[ic].function);
     ic = ANYOTHERKEY257 -1;
   }

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

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

340/* 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. */
343int
344rl_translate_keyseq (seq, array, len)
   const char *seq;
   char *array;
   int *len;
348{
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(('[') & 0x1f);	/* ESC is meta-prefix */
  i += 5;
  array[l++] = CTRL (_rl_to_upper (seq[i]))((((((unsigned char)(seq[i]) == (seq[i])) && (isascii
(seq[i]) && islower (seq[i]))) ? toupper((unsigned char
)seq[i]) : (seq[i]))) & 0x1f);
  if (seq[i] == '\0')
    i--;
}
     else if (c == 'M')
{
  i++;
  array[l++] = ESC(('[') & 0x1f);	/* ESC is meta-prefix */
}
     else if (c == 'C')
{
  i += 2;
  /* Special hack for C-?... */
  array[l++] = (seq[i] == '?') ? RUBOUT0x7f : CTRL (_rl_to_upper (seq[i]))((((((unsigned char)(seq[i]) == (seq[i])) && (isascii
(seq[i]) && islower (seq[i]))) ? toupper((unsigned char
)seq[i]) : (seq[i]))) & 0x1f);
}
     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++] = RUBOUT0x7f;	/* readline-specific */
     break;
   case 'e':
     array[l++] = ESC(('[') & 0x1f);
     break;
   case 'f':
     array[l++] = '\f';
     break;
   case 'n':
     array[l++] = NEWLINE'\n';
     break;
   case 'r':
     array[l++] = RETURN(('M') & 0x1f);
     break;
   case 't':
     array[l++] = TAB'\t';
     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])((seq[i]) >= '0' && (seq[i]) <= '7') && temp--; i++)
       c = (c * 8) + OCTVALUE (seq[i])((seq[i]) - '0');
     i--;	/* auto-increment in for loop */
     array[l++] = c & largest_char255;
     break;
   case 'x':
     i++;
     for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i])(isascii((unsigned char)seq[i]) && isxdigit ((unsigned
 char)seq[i])) && temp--; i++)
       c = (c * 16) + HEXVALUE (seq[i])(((seq[i]) >= 'a' && (seq[i]) <= 'f') ? (seq[i]
)-'a'+10 : (seq[i]) >= 'A' && (seq[i]) <= 'F' ?
 (seq[i])-'A'+10 : (seq[i])-'0');
     if (temp == 2)
       c = 'x';
     i--;	/* auto-increment in for loop */
     array[l++] = c & largest_char255;
     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);
452}

454char *
455rl_untranslate_keyseq (seq)
   int seq;
457{
static char kseq[16];
int i, c;

i = 0;
c = seq;
if (META_CHAR (c)((c) > 0x07f && (c) <= 255))
  {
    kseq[i++] = '\\';
    kseq[i++] = 'M';
    kseq[i++] = '-';
    c = UNMETA (c)((c) & (~0x080));
  }
else if (CTRL_CHAR (c)((c) < 0x020 && (((c) & 0x80) == 0)))
  {
    kseq[i++] = '\\';
    kseq[i++] = 'C';
    kseq[i++] = '-';
    c = _rl_to_lower (UNCTRL (c))((((unsigned char)(((((unsigned char)(((c)|0x40)) == (((c)|0x40
))) && (isascii(((c)|0x40)) && islower (((c)|
0x40)))) ? toupper((unsigned char)((c)|0x40)) : (((c)|0x40)))
) == (((((unsigned char)(((c)|0x40)) == (((c)|0x40))) &&
 (isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40))))) && (isascii
(((((unsigned char)(((c)|0x40)) == (((c)|0x40))) && (
isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))) && isupper
 (((((unsigned char)(((c)|0x40)) == (((c)|0x40))) && (
isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))))) ? tolower((unsigned
 char)((((unsigned char)(((c)|0x40)) == (((c)|0x40))) &&
 (isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))) : (((((unsigned char
)(((c)|0x40)) == (((c)|0x40))) && (isascii(((c)|0x40)
) && islower (((c)|0x40)))) ? toupper((unsigned char)
((c)|0x40)) : (((c)|0x40)))));
  }
else if (c == RUBOUT0x7f)
  {
    kseq[i++] = '\\';
    kseq[i++] = 'C';
    kseq[i++] = '-';
    c = '?';
  }

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

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

500static char *
501_rl_untranslate_macro_value (seq)
   char *seq;
503{
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)((c) > 0x07f && (c) <= 255))
{
 *r++ = '\\';
 *r++ = 'M';
 *r++ = '-';
 c = UNMETA (c)((c) & (~0x080));
}
    else if (CTRL_CHAR (c)((c) < 0x020 && (((c) & 0x80) == 0)) && c != ESC(('[') & 0x1f))
{
 *r++ = '\\';
 *r++ = 'C';
 *r++ = '-';
 c = _rl_to_lower (UNCTRL (c))((((unsigned char)(((((unsigned char)(((c)|0x40)) == (((c)|0x40
))) && (isascii(((c)|0x40)) && islower (((c)|
0x40)))) ? toupper((unsigned char)((c)|0x40)) : (((c)|0x40)))
) == (((((unsigned char)(((c)|0x40)) == (((c)|0x40))) &&
 (isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40))))) && (isascii
(((((unsigned char)(((c)|0x40)) == (((c)|0x40))) && (
isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))) && isupper
 (((((unsigned char)(((c)|0x40)) == (((c)|0x40))) && (
isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))))) ? tolower((unsigned
 char)((((unsigned char)(((c)|0x40)) == (((c)|0x40))) &&
 (isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))) : (((((unsigned char
)(((c)|0x40)) == (((c)|0x40))) && (isascii(((c)|0x40)
) && islower (((c)|0x40)))) ? toupper((unsigned char)
((c)|0x40)) : (((c)|0x40)))));
}
    else if (c == RUBOUT0x7f)
{
 *r++ = '\\';
 *r++ = 'C';
 *r++ = '-';
 c = '?';
}

    if (c == ESC(('[') & 0x1f))
{
 *r++ = '\\';
 c = 'e';
}
    else if (c == '\\' || c == '"')
*r++ = '\\';

    *r++ = (unsigned char)c;
  }
*r = '\0';
return ret;
545}

547/* Return a pointer to the function that STRING represents.
 If STRING doesn't have a matching function, then a NULL pointer
 is returned. */
550rl_command_func_t *
551rl_named_function (string)
   const char *string;
553{
register int i;

rl_initialize_funmap ();

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

564/* 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). */
569rl_command_func_t *
570rl_function_of_keyseq (keyseq, map, type)
   const char *keyseq;
   Keymap map;
   int *type;
574{
register int i;

if (!map)
  map = _rl_keymap;

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

    if (META_CHAR (ic)((ic) > 0x07f && (ic) <= 255) && _rl_convert_meta_chars_to_ascii)
{
 if (map[ESC(('[') & 0x1f)].type != ISKMAP1)
   {
     if (type)
*type = map[ESC(('[') & 0x1f)].type;

     return (map[ESC(('[') & 0x1f)].function);
   }
 else
   {
     map = FUNCTION_TO_KEYMAP (map, ESC)(Keymap)(map[(('[') & 0x1f)].function);
     ic = UNMETA (ic)((ic) & (~0x080));
   }
}

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

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

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

625/* The last key bindings file read. */
626static char *last_readline_init_file = (char *)NULL((void *)0);

628/* The file we're currently reading key bindings from. */
629static const char *current_readline_init_file;
630static int current_readline_init_include_level;
631static int current_readline_init_lineno;

633/* 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. */
636static char *
637_rl_read_file (filename, sizep)
   char *filename;
   size_t *sizep;
640{
struct stat finfo;
size_t file_size;
char *buffer;
int i, file;

if ((stat (filename, &finfo) < 0) || (file = open (filename, O_RDONLY0x0000, 0666)) < 0)
  return ((char *)NULL((void *)0));

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);
656#if defined (EFBIG27)
    errno(*__errno()) = EFBIG27;
658#endif
    return ((char *)NULL((void *)0));
  }

/* 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((void *)0));
  }

buffer[i] = '\0';
if (sizep)
  *sizep = i;

return (buffer);
678}

680/* Re-read the current keybindings file. */
681int
682rl_re_read_init_file (count, ignore)
   int count, ignore;
684{
int r;
r = rl_read_init_file ((const char *)NULL((void *)0));
rl_set_keymap_from_edit_mode ();
return r;
689}

691/* 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. */
698int
699rl_read_init_file (filename)
   const char *filename;
701{
/* Default the filename. */
if (filename == 0)
  {
    filename = last_readline_init_file;
    if (filename == 0)
      filename = sh_get_env_value ("INPUTRC");
    if (filename == 0 || *filename == '\0')
filename = DEFAULT_INPUTRC"~/.inputrc";
  }

if (*filename == 0)
  filename = DEFAULT_INPUTRC"~/.inputrc";

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

723static int
724_rl_read_init_file (filename, include_level)
   const char *filename;
   int include_level;
727{
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(*__errno()));

if (include_level == 0 && filename != last_readline_init_file)
  {
    FREE (last_readline_init_file)if (last_readline_init_file) free (last_readline_init_file);
    last_readline_init_file = savestring (filename)xstrdup(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++);

760#if defined (__CYGWIN__)
    /* ``Be liberal in what you accept.'' */
    if (line[i] == '\n' && line[i-1] == '\r')
line[i - 1] = '\0';
764#endif

    /* Mark end of line. */
    line[i] = '\0';

    /* Skip leading whitespace. */
    while (*line && whitespace (*line)(((*line) == ' ') || ((*line) == '\t')))
      {
 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);
788}

790static void
791_rl_init_file_error (msg)
   const char *msg;
793{
if (currently_reading_init_file)
  fprintf (stderr(&__sF[2]), "readline: %s: line %d: %s\n", current_readline_init_file,
     current_readline_init_lineno, msg);
else
  fprintf (stderr(&__sF[2]), "readline: %s\n", msg);
799}

801/* **************************************************************** */
802/*								    */
803/*			Parser Directives			    */
804/*								    */
805/* **************************************************************** */

807typedef int _rl_parser_func_t PARAMS((char *))(char *);

809/* Things that mean `Control'. */
810const char *_rl_possible_control_prefixes[] = {
"Control-", "C-", "CTRL-", (const char *)NULL((void *)0)
812};

814const char *_rl_possible_meta_prefixes[] = {
"Meta", "M-", (const char *)NULL((void *)0)
816};

818/* Conditionals. */

820/* Calling programs set this to have their argv[0]. */
821const char *rl_readline_name = "other";

823/* Stack of previous values of parsing_conditionalized_out. */
824static unsigned char *if_stack = (unsigned char *)NULL((void *)0);
825static int if_stack_depth;
826static int if_stack_size;

828/* Push _rl_parsing_conditionalized_out, and set parser state based
 on ARGS. */
830static int
831parser_if (args)
   char *args;
833{
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])(((args[i]) == ' ') || ((args[i]) == '\t')); 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_strnicmpstrncasecmp (args, "term=", 5) == 0)
  {
    char *tem, *tname;

    /* Terminals like "aaa-60" are equivalent to "aaa". */
    tname = savestring (rl_terminal_name)xstrdup(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_stricmpstrcasecmp (args + 5, tname) &&
			_rl_stricmpstrcasecmp (args + 5, rl_terminal_name);
    free (tname);
  }
878#if defined (VI_MODE)
else if (_rl_strnicmpstrncasecmp (args, "mode=", 5) == 0)
  {
    int mode;

    if (_rl_stricmpstrcasecmp (args + 5, "emacs") == 0)
mode = emacs_mode1;
    else if (_rl_stricmpstrcasecmp (args + 5, "vi") == 0)
mode = vi_mode0;
    else
mode = no_mode-1;

    _rl_parsing_conditionalized_out = mode != rl_editing_mode;
  }
892#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_stricmpstrcasecmp (args, rl_readline_name) == 0)
  _rl_parsing_conditionalized_out = 0;
else
  _rl_parsing_conditionalized_out = 1;
return 0;
900}

902/* Invert the current parser state if there is anything on the stack. */
903static int
904parser_else (args)
   char *args;
906{
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;
924}

926/* Terminate a conditional, popping the value of
 _rl_parsing_conditionalized_out from the stack. */
928static int
929parser_endif (args)
   char *args;
931{
if (if_stack_depth)
  _rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
else
  _rl_init_file_error ("$endif without matching $if");
return 0;
937}

939static int
940parser_include (args)
   char *args;
942{
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;
964}

966/* Associate textual names with actual functions. */
967static struct {
const char *name;
_rl_parser_func_t *function;
970} parser_directives [] = {
{ "if", parser_if },
{ "endif", parser_endif },
{ "else", parser_else },
{ "include", parser_include },
{ (char *)0x0, (_rl_parser_func_t *)0x0 }
976};

978/* Handle a parser directive.  STATEMENT is the line of the directive
 without any leading `$'. */
980static int
981handle_parser_directive (statement)
   char *statement;
983{
register int i;
char *directive, *args;

/* Isolate the actual directive. */

/* Skip whitespace. */
for (i = 0; whitespace (statement[i])(((statement[i]) == ' ') || ((statement[i]) == '\t')); i++);

directive = &statement[i];

for (; statement[i] && !whitespace (statement[i])(((statement[i]) == ' ') || ((statement[i]) == '\t')); i++);

if (statement[i])
  statement[i++] = '\0';

for (; statement[i] && whitespace (statement[i])(((statement[i]) == ' ') || ((statement[i]) == '\t')); i++);

args = &statement[i];

/* Lookup the command, and act on it. */
for (i = 0; parser_directives[i].name; i++)
  if (_rl_stricmpstrcasecmp (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);
1014}

1016/* 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. */
1020int
1021rl_parse_and_bind (string)
   char *string;
1023{
char *funname, *kname;
register int c, i;
int key, equivalency;

while (string && whitespace (*string)(((*string) == ' ') || ((*string) == '\t')))
  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_stricmpstrcasecmp (string, "set") == 0)
  {
    char *var = string + i;
    char *value;

    /* Make VAR point to start of variable name. */
    while (*var && whitespace (*var)(((*var) == ' ') || ((*var) == '\t'))) var++;

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

    rl_variable_bind (var, value);
    return 0;
  }

/* Skip any whitespace between keyname and funname. */
for (; string[i] && whitespace (string[i])(((string[i]) == ' ') || ((string[i]) == '\t')); 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])(((string[i]) == ' ') || ((string[i]) == '\t')); 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 = (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_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, _rl_possible_control_prefixes))
  key = CTRL (_rl_to_upper (key))((((((unsigned char)(key) == (key)) && (isascii(key) &&
 islower (key))) ? toupper((unsigned char)key) : (key))) &
 0x1f);

if (substring_member_of_array (string, _rl_possible_meta_prefixes))
  key = META (key)((key) | 0x080);

/* 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);
  }
1237#if defined (PREFIX_META_HACK)
/* Ugly, but working hack to keep prefix-meta around. */
else if (_rl_stricmpstrcasecmp (funname, "prefix-meta") == 0)
  {
    char seq[2];

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

1253/* 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. */

1257#define V_SPECIAL0x1	0x1

1259static struct {
const char *name;
int *value;
int flags;
1263} boolean_varlist [] = {
{ "blink-matching-paren",	&rl_blink_matching_paren,	V_SPECIAL0x1 },
{ "byte-oriented",		&rl_byte_oriented,		0 },
{ "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 },
{ "history-preserve-point",	&_rl_history_preserve_point,	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 },
{ "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs, 0 },
{ "match-hidden-files",	&_rl_match_hidden_files,	0 },
{ "meta-flag",		&_rl_meta_flag,			0 },
{ "output-meta",		&_rl_output_meta_chars,		0 },
{ "page-completions",		&_rl_page_completions,		0 },
{ "prefer-visible-bell",	&_rl_prefer_visible_bell,	V_SPECIAL0x1 },
{ "print-completions-horizontally", &_rl_print_completions_horizontally, 0 },
{ "show-all-if-ambiguous",	&_rl_complete_show_all,		0 },
1284#if defined (VISIBLE_STATS)
{ "visible-stats",		&rl_visible_stats,		0 },
1286#endif /* VISIBLE_STATS */
{ (char *)NULL((void *)0), (int *)NULL((void *)0) }
1288};

1290static int
1291find_boolean_var (name)
   const char *name;
1293{
register int i;

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

1302/* Hooks for handling special boolean variables, where a
 function needs to be called or another variable needs
 to be changed when they're changed. */
1305static void
1306hack_special_boolean_var (i)
   int i;
1308{
const char *name;

name = boolean_varlist[i].name;

if (_rl_stricmpstrcasecmp (name, "blink-matching-paren") == 0)
  _rl_enable_paren_matching (rl_blink_matching_paren);
else if (_rl_stricmpstrcasecmp (name, "prefer-visible-bell") == 0)
  {
    if (_rl_prefer_visible_bell)
_rl_bell_preference = VISIBLE_BELL2;
    else
_rl_bell_preference = AUDIBLE_BELL1;
  }
1322}

1324typedef int _rl_sv_func_t PARAMS((const char *))(const char *);

1326/* These *must* correspond to the array indices for the appropriate
 string variable.  (Though they're not used right now.) */
1328#define V_BELLSTYLE0	0
1329#define V_COMBEGIN1	1
1330#define V_EDITMODE2	2
1331#define V_ISRCHTERM3	3
1332#define V_KEYMAP4	4

1334#define	V_STRING1	1
1335#define V_INT2		2

1337/* Forward declarations */
1338static int sv_bell_style PARAMS((const char *))(const char *);
1339static int sv_combegin PARAMS((const char *))(const char *);
1340static int sv_compquery PARAMS((const char *))(const char *);
1341static int sv_editmode PARAMS((const char *))(const char *);
1342static int sv_isrchterm PARAMS((const char *))(const char *);
1343static int sv_keymap PARAMS((const char *))(const char *);

1345static struct {
const char *name;
int flags;
_rl_sv_func_t *set_func;
1349} string_varlist[] = {
{ "bell-style",	V_STRING1,	sv_bell_style },
{ "comment-begin",	V_STRING1,	sv_combegin },
{ "completion-query-items", V_INT2,	sv_compquery },
{ "editing-mode",	V_STRING1,	sv_editmode },
{ "isearch-terminators", V_STRING1,	sv_isrchterm },
{ "keymap",		V_STRING1,	sv_keymap },
{ (char *)NULL((void *)0),	0 }
1357};

1359static int
1360find_string_var (name)
   const char *name;
1362{
register int i;

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

1371/* 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). */
1374static int
1375bool_to_int (value)
   const char *value;
1377{
return (value == 0 || *value == '\0' ||
(_rl_stricmpstrcasecmp (value, "on") == 0) ||
(value[0] == '1' && value[1] == '\0'));
1381}

1383int
1384rl_variable_bind (name, value)
   const char *name, *value;
1386{
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_SPECIAL0x1)
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;
1409}

1411static int
1412sv_editmode (value)
   const char *value;
1414{
if (_rl_strnicmpstrncasecmp (value, "vi", 2) == 0)
  {
1417#if defined (VI_MODE)
    _rl_keymap = vi_insertion_keymap;
    rl_editing_mode = vi_mode0;
1420#endif /* VI_MODE */
    return 0;
  }
else if (_rl_strnicmpstrncasecmp (value, "emacs", 5) == 0)
  {
    _rl_keymap = emacs_standard_keymap;
    rl_editing_mode = emacs_mode1;
    return 0;
  }
return 1;
1430}

1432static int
1433sv_combegin (value)
   const char *value;
1435{
if (value && *value)
  {
    FREE (_rl_comment_begin)if (_rl_comment_begin) free (_rl_comment_begin);
    _rl_comment_begin = savestring (value)xstrdup(value);
    return 0;
  }
return 1;
1443}

1445static int
1446sv_compquery (value)
   const char *value;
1448{
int nval = 100;

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

1461static int
1462sv_keymap (value)
   const char *value;
1464{
Keymap kmap;

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

1476static int
1477sv_bell_style (value)
   const char *value;
1479{
if (value == 0 || *value == '\0')
  _rl_bell_preference = AUDIBLE_BELL1;
else if (_rl_stricmpstrcasecmp (value, "none") == 0 || _rl_stricmpstrcasecmp (value, "off") == 0)
  _rl_bell_preference = NO_BELL0;
else if (_rl_stricmpstrcasecmp (value, "audible") == 0 || _rl_stricmpstrcasecmp (value, "on") == 0)
  _rl_bell_preference = AUDIBLE_BELL1;
else if (_rl_stricmpstrcasecmp (value, "visible") == 0)
  _rl_bell_preference = VISIBLE_BELL2;
else
  return 1;
return 0;
1491}

1493static int
1494sv_isrchterm (value)
   const char *value;
1496{
int beg, end, delim;
char *v;

if (value == 0)
  return 1;

/* Isolate the value and translate it into a character string. */
v = savestring (value)xstrdup(value);
FREE (_rl_isearch_terminators)if (_rl_isearch_terminators) 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])(((v[end]) == ' ') || ((v[end]) == '\t')) == 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;
1527}

1529/* Return the character which matches NAME.
 For example, `Space' returns ' '. */

1532typedef struct {
const char *name;
int value;
1535} assoc_list;

1537static 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 }
1550};

1552static int
1553glean_key_from_name (name)
   char *name;
1555{
register int i;

for (i = 0; name_key_alist[i].name; i++)
  if (_rl_stricmpstrcasecmp (name, name_key_alist[i].name) == 0)
    return (name_key_alist[i].value);

return (*(unsigned char *)name);	/* XXX was return (*name) */
1563}

1565/* Auxiliary functions to manage keymaps. */
1566static struct {
const char *name;
Keymap map;
1569} keymap_names[] = {
{ "emacs", emacs_standard_keymap },
{ "emacs-standard", emacs_standard_keymap },
{ "emacs-meta", emacs_meta_keymap },
{ "emacs-ctlx", emacs_ctlx_keymap },
1574#if defined (VI_MODE)
{ "vi", vi_movement_keymap },
{ "vi-move", vi_movement_keymap },
{ "vi-command", vi_movement_keymap },
{ "vi-insert", vi_insertion_keymap },
1579#endif /* VI_MODE */
{ (char *)0x0, (Keymap)0x0 }
1581};

1583Keymap
1584rl_get_keymap_by_name (name)
   const char *name;
1586{
register int i;

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

1595char *
1596rl_get_keymap_name (map)
   Keymap map;
1598{
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((void *)0));
1604}

1606void
1607rl_set_keymap (map)
   Keymap map;
1609{
if (map)
  _rl_keymap = map;
1612}

1614Keymap
1615rl_get_keymap ()
1616{
return (_rl_keymap);
1618}

1620void
1621rl_set_keymap_from_edit_mode ()
1622{
if (rl_editing_mode == emacs_mode1)
  _rl_keymap = emacs_standard_keymap;
1625#if defined (VI_MODE)
else if (rl_editing_mode == vi_mode0)
  _rl_keymap = vi_insertion_keymap;
1628#endif /* VI_MODE */
1629}

1631char *
1632rl_get_keymap_name_from_edit_mode ()
1633{
if (rl_editing_mode == emacs_mode1)
  return "emacs";
1636#if defined (VI_MODE)
else if (rl_editing_mode == vi_mode0)
  return "vi";
1639#endif /* VI_MODE */
else
  return "none";
1642}

1644/* **************************************************************** */
1645/*								    */
1646/*		  Key Binding and Function Information		    */
1647/*								    */
1648/* **************************************************************** */

1650/* 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 (). */

1655/* Print the names of functions known to Readline. */
1656void
1657rl_list_funmap_names ()
1658{
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);
1671}

1673static char *
1674_rl_get_keyname (key)
   int key;
1676{
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. */

1687#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(('[') & 0x1f))
  {
    keyname[0] = '\\';
    keyname[1] = 'e';
    keyname[2] = '\0';
    return keyname;
  }
1700#endif

/* RUBOUT is translated directly into \C-? */
if (key == RUBOUT0x7f)
  {
    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)((c) < 0x020 && (((c) & 0x80) == 0)))
  {
    keyname[i++] = '\\';
    keyname[i++] = 'C';
    keyname[i++] = '-';
    c = _rl_to_lower (UNCTRL (c))((((unsigned char)(((((unsigned char)(((c)|0x40)) == (((c)|0x40
))) && (isascii(((c)|0x40)) && islower (((c)|
0x40)))) ? toupper((unsigned char)((c)|0x40)) : (((c)|0x40)))
) == (((((unsigned char)(((c)|0x40)) == (((c)|0x40))) &&
 (isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40))))) && (isascii
(((((unsigned char)(((c)|0x40)) == (((c)|0x40))) && (
isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))) && isupper
 (((((unsigned char)(((c)|0x40)) == (((c)|0x40))) && (
isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))))) ? tolower((unsigned
 char)((((unsigned char)(((c)|0x40)) == (((c)|0x40))) &&
 (isascii(((c)|0x40)) && islower (((c)|0x40)))) ? toupper
((unsigned char)((c)|0x40)) : (((c)|0x40)))) : (((((unsigned char
)(((c)|0x40)) == (((c)|0x40))) && (isascii(((c)|0x40)
) && islower (((c)|0x40)))) ? toupper((unsigned char)
((c)|0x40)) : (((c)|0x40)))));
  }

/* 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;
1745}

1747/* Return a NULL terminated array of strings which represent the key
 sequences that are used to invoke FUNCTION in MAP. */
1749char **
1750rl_invoking_keyseqs_in_map (function, map)
   rl_command_func_t *function;
   Keymap map;
1753{
register int key;
char **result;
int result_index, result_size;

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

for (key = 0; key < KEYMAP_SIZE257; key++)
  {
    switch (map[key].type)
{
case ISMACR2:
 /* Macros match, if, and only if, the pointers are identical.
    Thus, they are treated exactly like functions in here. */
case ISFUNC0:
 /* 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((void *)0);
   }
 break;

case ISKMAP1:
 {
   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)(Keymap)(map[key].function));
   else
     break;

   if (seqs == 0)
     break;

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

if (key == ESC(('[') & 0x1f))
1810#if 0
  snprintf(keyname, len, "\\e");
1812#else
/* XXX - experimental */
  snprintf(keyname, len, "\\M-");
1815#endif
else if (CTRL_CHAR (key)((key) < 0x020 && (((key) & 0x80) == 0)))
  snprintf(keyname, len, "\\C-%c", _rl_to_lower (UNCTRL (key))((((unsigned char)(((((unsigned char)(((key)|0x40)) == (((key
)|0x40))) && (isascii(((key)|0x40)) && islower
 (((key)|0x40)))) ? toupper((unsigned char)((key)|0x40)) : ((
(key)|0x40)))) == (((((unsigned char)(((key)|0x40)) == (((key
)|0x40))) && (isascii(((key)|0x40)) && islower
 (((key)|0x40)))) ? toupper((unsigned char)((key)|0x40)) : ((
(key)|0x40))))) && (isascii(((((unsigned char)(((key)
|0x40)) == (((key)|0x40))) && (isascii(((key)|0x40)) &&
 islower (((key)|0x40)))) ? toupper((unsigned char)((key)|0x40
)) : (((key)|0x40)))) && isupper (((((unsigned char)(
((key)|0x40)) == (((key)|0x40))) && (isascii(((key)|0x40
)) && islower (((key)|0x40)))) ? toupper((unsigned char
)((key)|0x40)) : (((key)|0x40)))))) ? tolower((unsigned char)
((((unsigned char)(((key)|0x40)) == (((key)|0x40))) &&
 (isascii(((key)|0x40)) && islower (((key)|0x40)))) ?
 toupper((unsigned char)((key)|0x40)) : (((key)|0x40)))) : ((
(((unsigned char)(((key)|0x40)) == (((key)|0x40))) &&
 (isascii(((key)|0x40)) && islower (((key)|0x40)))) ?
 toupper((unsigned char)((key)|0x40)) : (((key)|0x40))))));
else if (key == RUBOUT0x7f)
  snprintf(keyname, len, "\\C-?");
else if (key == '\\' || key == '"')
  {
    keyname[0] = '\\';
    keyname[1] = (char) key;
    keyname[2] = '\0';
  }
else
  {
    keyname[0] = (char) key;
    keyname[1] = '\0';
  }

strlcat (keyname, seqs[i], len);
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((void *)0);
     }

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

1853/* Return a NULL terminated array of strings which represent the key
 sequences that can be used to invoke FUNCTION using the current keymap. */
1855char **
1856rl_invoking_keyseqs (function)
   rl_command_func_t *function;
1858{
return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
1860}

1862/* 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. */
1865void
1866rl_function_dumper (print_readably)
   int print_readably;
1868{
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);
   }
}
  }
1930}

1932/* 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. */
1935int
1936rl_dump_functions (count, key)
   int count, key;
1938{
if (rl_dispatching)
  fprintf (rl_outstream, "\r\n");
rl_function_dumper (rl_explicit_arg);
rl_on_new_line ();
return (0);
1944}

1946static void
1947_rl_macro_dumper_internal (print_readably, map, prefix)
   int print_readably;
   Keymap map;
   char *prefix;
1951{
register int key;
char *keyname, *out;
int prefix_len;

for (key = 0; key < KEYMAP_SIZE257; key++)
  {
    switch (map[key].type)
{
case ISMACR2:
 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 ISFUNC0:
 break;
case ISKMAP1:
 prefix_len = prefix ? strlen (prefix) : 0;
 if (key == ESC(('[') & 0x1f))
   {
     int len = 3 + prefix_len;
     keyname = (char *)xmalloc (len);
     if (prefix)
strlcpy (keyname, prefix, len);
     keyname[prefix_len] = '\\';
     keyname[prefix_len + 1] = 'e';
     keyname[prefix_len + 2] = '\0';
   }
 else
   {
     keyname = _rl_get_keyname (key);
     if (prefix)
{
  if (asprintf(&out, "%s%s", prefix, keyname) == -1)
    memory_error_and_abort("asprintf");
  free (keyname);
  keyname = out;
}
   }

 _rl_macro_dumper_internal (print_readably, FUNCTION_TO_KEYMAP (map, key)(Keymap)(map[key].function), keyname);
 free (keyname);
 break;
}
  }
2006}

2008void
2009rl_macro_dumper (print_readably)
   int print_readably;
2011{
_rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL((void *)0));
2013}

2015int
2016rl_dump_macros (count, key)
   int count, key;
2018{
if (rl_dispatching)
  fprintf (rl_outstream, "\r\n");
rl_macro_dumper (rl_explicit_arg);
rl_on_new_line ();
return (0);
2024}

2026void
2027rl_variable_dumper (print_readably)
   int print_readably;
2029{
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_BELL0:
    kname = "none"; break;
  case VISIBLE_BELL2:
    kname = "visible"; break;
  case AUDIBLE_BELL1:
  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_mode1) ? "emacs" : "vi");
else
  fprintf (rl_outstream, "editing-mode is set to `%s'\n", (rl_editing_mode == emacs_mode1) ? "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");
2100}

2102/* 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. */
2105int
2106rl_dump_variables (count, key)
   int count, key;
2108{
if (rl_dispatching)
  fprintf (rl_outstream, "\r\n");
rl_variable_dumper (rl_explicit_arg);
rl_on_new_line ();
return (0);
2114}

2116/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound.  Right
 now, this is always used to attempt to bind the arrow keys, hence the
 check for rl_vi_movement_mode. */
2119void
2120_rl_bind_if_unbound (keyseq, default_func)
   const char *keyseq;
   rl_command_func_t *default_func;
2123{
rl_command_func_t *func;

if (keyseq)
1
Assuming 'keyseq' is non-null→
2
←
Taking true branch→
  {
    func = rl_function_of_keyseq (keyseq, _rl_keymap, (int *)NULL((void *)0));
2129#if defined (VI_MODE)
    if (!func || func == rl_do_lowercase_version || func == rl_vi_movement_mode)
3
←
Assuming 'func' is non-null→
4
←
Assuming 'func' is equal to rl_do_lowercase_version→
2131#else
    if (!func || func == rl_do_lowercase_version)
2133#endif
rl_set_key (keyseq, default_func, _rl_keymap);
5
←
Calling 'rl_set_key'→
  }
2136}

2138/* Return non-zero if any members of ARRAY are a substring in STRING. */
2139static int
2140substring_member_of_array (string, array)
   char *string;
   const char **array;
2143{
while (*array)
  {
    if (_rl_strindex (string, *array))
return (1);
    array++;
  }
return (0);
2151}