lib/readline/bind.c

   1 /* bind.c -- key binding and startup file support for the readline library. */
   2
   3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library (Readline), a library
   6    for reading lines of text with interactive input and history editing.
   7
   8    Readline is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    Readline is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #define READLINE_LIBRARY
  23
  24 #if defined (__TANDEM)
  25 #  include <floss.h>
  26 #endif
  27
  28 #if defined (HAVE_CONFIG_H)
  29 #  include <config.h>
  30 #endif
  31
  32 #include <stdio.h>
  33 #include <sys/types.h>
  34 #include <fcntl.h>
  35 #if defined (HAVE_SYS_FILE_H)
  36 #  include <sys/file.h>
  37 #endif /* HAVE_SYS_FILE_H */
  38
  39 #if defined (HAVE_UNISTD_H)
  40 #  include <unistd.h>
  41 #endif /* HAVE_UNISTD_H */
  42
  43 #if defined (HAVE_STDLIB_H)
  44 #  include <stdlib.h>
  45 #else
  46 #  include "ansi_stdlib.h"
  47 #endif /* HAVE_STDLIB_H */
  48
  49 #include <errno.h>
  50
  51 #if !defined (errno)
  52 extern int errno;
  53 #endif /* !errno */
  54
  55 #include "posixstat.h"
  56
  57 /* System-specific feature definitions and include files. */
  58 #include "rldefs.h"
  59
  60 /* Some standard library routines. */
  61 #include "readline.h"
  62 #include "history.h"
  63
  64 #include "rlprivate.h"
  65 #include "rlshell.h"
  66 #include "xmalloc.h"
  67
  68 #if !defined (strchr) && !defined (__STDC__)
  69 extern char *strchr (), *strrchr ();
  70 #endif /* !strchr && !__STDC__ */
  71
  72 /* Variables exported by this file. */
  73 Keymap rl_binding_keymap;
  74
  75 static char *_rl_read_file PARAMS((char *, size_t *));
  76 static void _rl_init_file_error PARAMS((const char *));
  77 static int _rl_read_init_file PARAMS((const char *, int));
  78 static int glean_key_from_name PARAMS((char *));
  79 static int find_boolean_var PARAMS((const char *));
  80
  81 static char *_rl_get_string_variable_value PARAMS((const char *));
  82 static int substring_member_of_array PARAMS((const char *, const char * const *));
  83
  84 static int currently_reading_init_file;
  85
  86 /* used only in this file */
  87 static int _rl_prefer_visible_bell = 1;
  88
  89 /* **************************************************************** */
  90 /*                                                                  */
  91 /*                      Binding keys                                */
  92 /*                                                                  */
  93 /* **************************************************************** */
  94
  95 /* rl_add_defun (char *name, rl_command_func_t *function, int key)
  96    Add NAME to the list of named functions.  Make FUNCTION be the function
  97    that gets called.  If KEY is not -1, then bind it. */
  98 int
  99 rl_add_defun (name, function, key)
 100      const char *name;
 101      rl_command_func_t *function;
 102      int key;
 103 {
 104   if (key != -1)
 105     rl_bind_key (key, function);
 106   rl_add_funmap_entry (name, function);
 107   return 0;
 108 }
 109
 110 /* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
 111 int
 112 rl_bind_key (key, function)
 113      int key;
 114      rl_command_func_t *function;
 115 {
 116   if (key < 0)
 117     return (key);
 118
 119   if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
 120     {
 121       if (_rl_keymap[ESC].type == ISKMAP)
 122         {
 123           Keymap escmap;
 124
 125           escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC);
 126           key = UNMETA (key);
 127           escmap[key].type = ISFUNC;
 128           escmap[key].function = function;
 129           return (0);
 130         }
 131       return (key);
 132     }
 133
 134   _rl_keymap[key].type = ISFUNC;
 135   _rl_keymap[key].function = function;
 136   rl_binding_keymap = _rl_keymap;
 137   return (0);
 138 }
 139
 140 /* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
 141    KEY. */
 142 int
 143 rl_bind_key_in_map (key, function, map)
 144      int key;
 145      rl_command_func_t *function;
 146      Keymap map;
 147 {
 148   int result;
 149   Keymap oldmap;
 150
 151   oldmap = _rl_keymap;
 152   _rl_keymap = map;
 153   result = rl_bind_key (key, function);
 154   _rl_keymap = oldmap;
 155   return (result);
 156 }
 157
 158 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound.  Right
 159    now, this is always used to attempt to bind the arrow keys, hence the
 160    check for rl_vi_movement_mode. */
 161 int
 162 rl_bind_key_if_unbound_in_map (key, default_func, kmap)
 163      int key;
 164      rl_command_func_t *default_func;
 165      Keymap kmap;
 166 {
 167   char keyseq[2];
 168
 169   keyseq[0] = (unsigned char)key;
 170   keyseq[1] = '\0';
 171   return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap));
 172 }
 173
 174 int
 175 rl_bind_key_if_unbound (key, default_func)
 176      int key;
 177      rl_command_func_t *default_func;
 178 {
 179   char keyseq[2];
 180
 181   keyseq[0] = (unsigned char)key;
 182   keyseq[1] = '\0';
 183   return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
 184 }
 185
 186 /* Make KEY do nothing in the currently selected keymap.
 187    Returns non-zero in case of error. */
 188 int
 189 rl_unbind_key (key)
 190      int key;
 191 {
 192   return (rl_bind_key (key, (rl_command_func_t *)NULL));
 193 }
 194
 195 /* Make KEY do nothing in MAP.
 196    Returns non-zero in case of error. */
 197 int
 198 rl_unbind_key_in_map (key, map)
 199      int key;
 200      Keymap map;
 201 {
 202   return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));
 203 }
 204
 205 /* Unbind all keys bound to FUNCTION in MAP. */
 206 int
 207 rl_unbind_function_in_map (func, map)
 208      rl_command_func_t *func;
 209      Keymap map;
 210 {
 211   register int i, rval;
 212
 213   for (i = rval = 0; i < KEYMAP_SIZE; i++)
 214     {
 215       if (map[i].type == ISFUNC && map[i].function == func)
 216         {
 217           map[i].function = (rl_command_func_t *)NULL;
 218           rval = 1;
 219         }
 220     }
 221   return rval;
 222 }
 223
 224 int
 225 rl_unbind_command_in_map (command, map)
 226      const char *command;
 227      Keymap map;
 228 {
 229   rl_command_func_t *func;
 230
 231   func = rl_named_function (command);
 232   if (func == 0)
 233     return 0;
 234   return (rl_unbind_function_in_map (func, map));
 235 }
 236
 237 /* Bind the key sequence represented by the string KEYSEQ to
 238    FUNCTION, starting in the current keymap.  This makes new
 239    keymaps as necessary. */
 240 int
 241 rl_bind_keyseq (keyseq, function)
 242      const char *keyseq;
 243      rl_command_func_t *function;
 244 {
 245   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));
 246 }
 247
 248 /* Bind the key sequence represented by the string KEYSEQ to
 249    FUNCTION.  This makes new keymaps as necessary.  The initial
 250    place to do bindings is in MAP. */
 251 int
 252 rl_bind_keyseq_in_map (keyseq, function, map)
 253      const char *keyseq;
 254      rl_command_func_t *function;
 255      Keymap map;
 256 {
 257   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
 258 }
 259
 260 /* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
 261 int
 262 rl_set_key (keyseq, function, map)
 263      const char *keyseq;
 264      rl_command_func_t *function;
 265      Keymap map;
 266 {
 267   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
 268 }
 269
 270 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound.  Right
 271    now, this is always used to attempt to bind the arrow keys, hence the
 272    check for rl_vi_movement_mode. */
 273 int
 274 rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap)
 275      const char *keyseq;
 276      rl_command_func_t *default_func;
 277      Keymap kmap;
 278 {
 279   rl_command_func_t *func;
 280
 281   if (keyseq)
 282     {
 283       func = rl_function_of_keyseq (keyseq, kmap, (int *)NULL);
 284 #if defined (VI_MODE)
 285       if (!func || func == rl_do_lowercase_version || func == rl_vi_movement_mode)
 286 #else
 287       if (!func || func == rl_do_lowercase_version)
 288 #endif
 289         return (rl_bind_keyseq_in_map (keyseq, default_func, kmap));
 290       else
 291         return 1;
 292     }
 293   return 0;
 294 }
 295
 296 int
 297 rl_bind_keyseq_if_unbound (keyseq, default_func)
 298      const char *keyseq;
 299      rl_command_func_t *default_func;
 300 {
 301   return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
 302 }
 303
 304 /* Bind the key sequence represented by the string KEYSEQ to
 305    the string of characters MACRO.  This makes new keymaps as
 306    necessary.  The initial place to do bindings is in MAP. */
 307 int
 308 rl_macro_bind (keyseq, macro, map)
 309      const char *keyseq, *macro;
 310      Keymap map;
 311 {
 312   char *macro_keys;
 313   int macro_keys_len;
 314
 315   macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);
 316
 317   if (rl_translate_keyseq (macro, macro_keys, &macro_keys_len))
 318     {
 319       xfree (macro_keys);
 320       return -1;
 321     }
 322   rl_generic_bind (ISMACR, keyseq, macro_keys, map);
 323   return 0;
 324 }
 325
 326 /* Bind the key sequence represented by the string KEYSEQ to
 327    the arbitrary pointer DATA.  TYPE says what kind of data is
 328    pointed to by DATA, right now this can be a function (ISFUNC),
 329    a macro (ISMACR), or a keymap (ISKMAP).  This makes new keymaps
 330    as necessary.  The initial place to do bindings is in MAP. */
 331 int
 332 rl_generic_bind (type, keyseq, data, map)
 333      int type;
 334      const char *keyseq;
 335      char *data;
 336      Keymap map;
 337 {
 338   char *keys;
 339   int keys_len;
 340   register int i;
 341   KEYMAP_ENTRY k;
 342
 343   k.function = 0;
 344
 345   /* If no keys to bind to, exit right away. */
 346   if (keyseq == 0 || *keyseq == 0)
 347     {
 348       if (type == ISMACR)
 349         xfree (data);
 350       return -1;
 351     }
 352
 353   keys = (char *)xmalloc (1 + (2 * strlen (keyseq)));
 354
 355   /* Translate the ASCII representation of KEYSEQ into an array of
 356      characters.  Stuff the characters into KEYS, and the length of
 357      KEYS into KEYS_LEN. */
 358   if (rl_translate_keyseq (keyseq, keys, &keys_len))
 359     {
 360       xfree (keys);
 361       return -1;
 362     }
 363
 364   /* Bind keys, making new keymaps as necessary. */
 365   for (i = 0; i < keys_len; i++)
 366     {
 367       unsigned char uc = keys[i];
 368       int ic;
 369
 370       ic = uc;
 371       if (ic < 0 || ic >= KEYMAP_SIZE)
 372         {
 373           xfree (keys);
 374           return -1;
 375         }
 376
 377       if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
 378         {
 379           ic = UNMETA (ic);
 380           if (map[ESC].type == ISKMAP)
 381             map = FUNCTION_TO_KEYMAP (map, ESC);
 382         }
 383
 384       if ((i + 1) < keys_len)
 385         {
 386           if (map[ic].type != ISKMAP)
 387             {
 388               /* We allow subsequences of keys.  If a keymap is being
 389                  created that will `shadow' an existing function or macro
 390                  key binding, we save that keybinding into the ANYOTHERKEY
 391                  index in the new map.  The dispatch code will look there
 392                  to find the function to execute if the subsequence is not
 393                  matched.  ANYOTHERKEY was chosen to be greater than
 394                  UCHAR_MAX. */
 395               k = map[ic];
 396
 397               map[ic].type = ISKMAP;
 398               map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
 399             }
 400           map = FUNCTION_TO_KEYMAP (map, ic);
 401           /* The dispatch code will return this function if no matching
 402              key sequence is found in the keymap.  This (with a little
 403              help from the dispatch code in readline.c) allows `a' to be
 404              mapped to something, `abc' to be mapped to something else,
 405              and the function bound  to `a' to be executed when the user
 406              types `abx', leaving `bx' in the input queue. */
 407           if (k.function && ((k.type == ISFUNC && k.function != rl_do_lowercase_version) || k.type == ISMACR))
 408             {
 409               map[ANYOTHERKEY] = k;
 410               k.function = 0;
 411             }
 412         }
 413       else
 414         {
 415           if (map[ic].type == ISMACR)
 416             xfree ((char *)map[ic].function);
 417           else if (map[ic].type == ISKMAP)
 418             {
 419               map = FUNCTION_TO_KEYMAP (map, ic);
 420               ic = ANYOTHERKEY;
 421               /* If we're trying to override a keymap with a null function
 422                  (e.g., trying to unbind it), we can't use a null pointer
 423                  here because that's indistinguishable from having not been
 424                  overridden.  We use a special bindable function that does
 425                  nothing. */
 426               if (type == ISFUNC && data == 0)
 427                 data = (char *)_rl_null_function;
 428             }
 429
 430           map[ic].function = KEYMAP_TO_FUNCTION (data);
 431           map[ic].type = type;
 432         }
 433
 434       rl_binding_keymap = map;
 435     }
 436   xfree (keys);
 437   return 0;
 438 }
 439
 440 /* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
 441    an array of characters.  LEN gets the final length of ARRAY.  Return
 442    non-zero if there was an error parsing SEQ. */
 443 int
 444 rl_translate_keyseq (seq, array, len)
 445      const char *seq;
 446      char *array;
 447      int *len;
 448 {
 449   register int i, c, l, temp;
 450
 451   for (i = l = 0; c = seq[i]; i++)
 452     {
 453       if (c == '\\')
 454         {
 455           c = seq[++i];
 456
 457           if (c == 0)
 458             break;
 459
 460           /* Handle \C- and \M- prefixes. */
 461           if ((c == 'C' || c == 'M') && seq[i + 1] == '-')
 462             {
 463               /* Handle special case of backwards define. */
 464               if (strncmp (&seq[i], "C-\\M-", 5) == 0)
 465                 {
 466                   array[l++] = ESC;     /* ESC is meta-prefix */
 467                   i += 5;
 468                   array[l++] = CTRL (_rl_to_upper (seq[i]));
 469                   if (seq[i] == '\0')
 470                     i--;
 471                 }
 472               else if (c == 'M')
 473                 {
 474                   i++;          /* seq[i] == '-' */
 475                   /* XXX - obey convert-meta setting */
 476                   if (_rl_convert_meta_chars_to_ascii && _rl_keymap[ESC].type == ISKMAP)
 477                     array[l++] = ESC;   /* ESC is meta-prefix */
 478                   else if (seq[i+1] == '\\' && seq[i+2] == 'C' && seq[i+3] == '-')
 479                     {
 480                       i += 4;
 481                       temp = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
 482                       array[l++] = META (temp);
 483                     }
 484                   else
 485                     {
 486                       /* This doesn't yet handle things like \M-\a, which may
 487                          or may not have any reasonable meaning.  You're
 488                          probably better off using straight octal or hex. */
 489                       i++;
 490                       array[l++] = META (seq[i]);
 491                     }
 492                 }
 493               else if (c == 'C')
 494                 {
 495                   i += 2;
 496                   /* Special hack for C-?... */
 497                   array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
 498                 }
 499               continue;
 500             }
 501
 502           /* Translate other backslash-escaped characters.  These are the
 503              same escape sequences that bash's `echo' and `printf' builtins
 504              handle, with the addition of \d -> RUBOUT.  A backslash
 505              preceding a character that is not special is stripped. */
 506           switch (c)
 507             {
 508             case 'a':
 509               array[l++] = '\007';
 510               break;
 511             case 'b':
 512               array[l++] = '\b';
 513               break;
 514             case 'd':
 515               array[l++] = RUBOUT;      /* readline-specific */
 516               break;
 517             case 'e':
 518               array[l++] = ESC;
 519               break;
 520             case 'f':
 521               array[l++] = '\f';
 522               break;
 523             case 'n':
 524               array[l++] = NEWLINE;
 525               break;
 526             case 'r':
 527               array[l++] = RETURN;
 528               break;
 529             case 't':
 530               array[l++] = TAB;
 531               break;
 532             case 'v':
 533               array[l++] = 0x0B;
 534               break;
 535             case '\\':
 536               array[l++] = '\\';
 537               break;
 538             case '0': case '1': case '2': case '3':
 539             case '4': case '5': case '6': case '7':
 540               i++;
 541               for (temp = 2, c -= '0'; ISOCTAL (seq[i]) && temp--; i++)
 542                 c = (c * 8) + OCTVALUE (seq[i]);
 543               i--;      /* auto-increment in for loop */
 544               array[l++] = c & largest_char;
 545               break;
 546             case 'x':
 547               i++;
 548               for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i]) && temp--; i++)
 549                 c = (c * 16) + HEXVALUE (seq[i]);
 550               if (temp == 2)
 551                 c = 'x';
 552               i--;      /* auto-increment in for loop */
 553               array[l++] = c & largest_char;
 554               break;
 555             default:    /* backslashes before non-special chars just add the char */
 556               array[l++] = c;
 557               break;    /* the backslash is stripped */
 558             }
 559           continue;
 560         }
 561
 562       array[l++] = c;
 563     }
 564
 565   *len = l;
 566   array[l] = '\0';
 567   return (0);
 568 }
 569
 570 char *
 571 rl_untranslate_keyseq (seq)
 572      int seq;
 573 {
 574   static char kseq[16];
 575   int i, c;
 576
 577   i = 0;
 578   c = seq;
 579   if (META_CHAR (c))
 580     {
 581       kseq[i++] = '\\';
 582       kseq[i++] = 'M';
 583       kseq[i++] = '-';
 584       c = UNMETA (c);
 585     }
 586   else if (c == ESC)
 587     {
 588       kseq[i++] = '\\';
 589       c = 'e';
 590     }
 591   else if (CTRL_CHAR (c))
 592     {
 593       kseq[i++] = '\\';
 594       kseq[i++] = 'C';
 595       kseq[i++] = '-';
 596       c = _rl_to_lower (UNCTRL (c));
 597     }
 598   else if (c == RUBOUT)
 599     {
 600       kseq[i++] = '\\';
 601       kseq[i++] = 'C';
 602       kseq[i++] = '-';
 603       c = '?';
 604     }
 605
 606   if (c == ESC)
 607     {
 608       kseq[i++] = '\\';
 609       c = 'e';
 610     }
 611   else if (c == '\\' || c == '"')
 612     {
 613       kseq[i++] = '\\';
 614     }
 615
 616   kseq[i++] = (unsigned char) c;
 617   kseq[i] = '\0';
 618   return kseq;
 619 }
 620
 621 static char *
 622 _rl_untranslate_macro_value (seq)
 623      char *seq;
 624 {
 625   char *ret, *r, *s;
 626   int c;
 627
 628   r = ret = (char *)xmalloc (7 * strlen (seq) + 1);
 629   for (s = seq; *s; s++)
 630     {
 631       c = *s;
 632       if (META_CHAR (c))
 633         {
 634           *r++ = '\\';
 635           *r++ = 'M';
 636           *r++ = '-';
 637           c = UNMETA (c);
 638         }
 639       else if (c == ESC)
 640         {
 641           *r++ = '\\';
 642           c = 'e';
 643         }
 644       else if (CTRL_CHAR (c))
 645         {
 646           *r++ = '\\';
 647           *r++ = 'C';
 648           *r++ = '-';
 649           c = _rl_to_lower (UNCTRL (c));
 650         }
 651       else if (c == RUBOUT)
 652         {
 653           *r++ = '\\';
 654           *r++ = 'C';
 655           *r++ = '-';
 656           c = '?';
 657         }
 658
 659       if (c == ESC)
 660         {
 661           *r++ = '\\';
 662           c = 'e';
 663         }
 664       else if (c == '\\' || c == '"')
 665         *r++ = '\\';
 666
 667       *r++ = (unsigned char)c;
 668     }
 669   *r = '\0';
 670   return ret;
 671 }
 672
 673 /* Return a pointer to the function that STRING represents.
 674    If STRING doesn't have a matching function, then a NULL pointer
 675    is returned. */
 676 rl_command_func_t *
 677 rl_named_function (string)
 678      const char *string;
 679 {
 680   register int i;
 681
 682   rl_initialize_funmap ();
 683
 684   for (i = 0; funmap[i]; i++)
 685     if (_rl_stricmp (funmap[i]->name, string) == 0)
 686       return (funmap[i]->function);
 687   return ((rl_command_func_t *)NULL);
 688 }
 689
 690 /* Return the function (or macro) definition which would be invoked via
 691    KEYSEQ if executed in MAP.  If MAP is NULL, then the current keymap is
 692    used.  TYPE, if non-NULL, is a pointer to an int which will receive the
 693    type of the object pointed to.  One of ISFUNC (function), ISKMAP (keymap),
 694    or ISMACR (macro). */
 695 rl_command_func_t *
 696 rl_function_of_keyseq (keyseq, map, type)
 697      const char *keyseq;
 698      Keymap map;
 699      int *type;
 700 {
 701   register int i;
 702
 703   if (map == 0)
 704     map = _rl_keymap;
 705
 706   for (i = 0; keyseq && keyseq[i]; i++)
 707     {
 708       unsigned char ic = keyseq[i];
 709
 710       if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
 711         {
 712           if (map[ESC].type == ISKMAP)
 713             {
 714               map = FUNCTION_TO_KEYMAP (map, ESC);
 715               ic = UNMETA (ic);
 716             }
 717           /* XXX - should we just return NULL here, since this obviously
 718              doesn't match? */
 719           else
 720             {
 721               if (type)
 722                 *type = map[ESC].type;
 723
 724               return (map[ESC].function);
 725             }
 726         }
 727
 728       if (map[ic].type == ISKMAP)
 729         {
 730           /* If this is the last key in the key sequence, return the
 731              map. */
 732           if (keyseq[i + 1] == '\0')
 733             {
 734               if (type)
 735                 *type = ISKMAP;
 736
 737               return (map[ic].function);
 738             }
 739           else
 740             map = FUNCTION_TO_KEYMAP (map, ic);
 741         }
 742       /* If we're not at the end of the key sequence, and the current key
 743          is bound to something other than a keymap, then the entire key
 744          sequence is not bound. */
 745       else if (map[ic].type != ISKMAP && keyseq[i+1])
 746         return ((rl_command_func_t *)NULL);
 747       else      /* map[ic].type != ISKMAP && keyseq[i+1] == 0 */
 748         {
 749           if (type)
 750             *type = map[ic].type;
 751
 752           return (map[ic].function);
 753         }
 754     }
 755   return ((rl_command_func_t *) NULL);
 756 }
 757
 758 /* The last key bindings file read. */
 759 static char *last_readline_init_file = (char *)NULL;
 760
 761 /* The file we're currently reading key bindings from. */
 762 static const char *current_readline_init_file;
 763 static int current_readline_init_include_level;
 764 static int current_readline_init_lineno;
 765
 766 /* Read FILENAME into a locally-allocated buffer and return the buffer.
 767    The size of the buffer is returned in *SIZEP.  Returns NULL if any
 768    errors were encountered. */
 769 static char *
 770 _rl_read_file (filename, sizep)
 771      char *filename;
 772      size_t *sizep;
 773 {
 774   struct stat finfo;
 775   size_t file_size;
 776   char *buffer;
 777   int i, file;
 778
 779   if ((stat (filename, &finfo) < 0) || (file = open (filename, O_RDONLY, 0666)) < 0)
 780     return ((char *)NULL);
 781
 782   file_size = (size_t)finfo.st_size;
 783
 784   /* check for overflow on very large files */
 785   if (file_size != finfo.st_size || file_size + 1 < file_size)
 786     {
 787       if (file >= 0)
 788         close (file);
 789 #if defined (EFBIG)
 790       errno = EFBIG;
 791 #endif
 792       return ((char *)NULL);
 793     }
 794
 795   /* Read the file into BUFFER. */
 796   buffer = (char *)xmalloc (file_size + 1);
 797   i = read (file, buffer, file_size);
 798   close (file);
 799
 800   if (i < 0)
 801     {
 802       xfree (buffer);
 803       return ((char *)NULL);
 804     }
 805
 806   RL_CHECK_SIGNALS ();
 807
 808   buffer[i] = '\0';
 809   if (sizep)
 810     *sizep = i;
 811
 812   return (buffer);
 813 }
 814
 815 /* Re-read the current keybindings file. */
 816 int
 817 rl_re_read_init_file (count, ignore)
 818      int count, ignore;
 819 {
 820   int r;
 821   r = rl_read_init_file ((const char *)NULL);
 822   rl_set_keymap_from_edit_mode ();
 823   return r;
 824 }
 825
 826 /* Do key bindings from a file.  If FILENAME is NULL it defaults
 827    to the first non-null filename from this list:
 828      1. the filename used for the previous call
 829      2. the value of the shell variable `INPUTRC'
 830      3. ~/.inputrc
 831      4. /etc/inputrc
 832    If the file existed and could be opened and read, 0 is returned,
 833    otherwise errno is returned. */
 834 int
 835 rl_read_init_file (filename)
 836      const char *filename;
 837 {
 838   /* Default the filename. */
 839   if (filename == 0)
 840     filename = last_readline_init_file;
 841   if (filename == 0)
 842     filename = sh_get_env_value ("INPUTRC");
 843   if (filename == 0 || *filename == 0)
 844     {
 845       filename = DEFAULT_INPUTRC;
 846       /* Try to read DEFAULT_INPUTRC; fall back to SYS_INPUTRC on failure */
 847       if (_rl_read_init_file (filename, 0) == 0)
 848         return 0;
 849       filename = SYS_INPUTRC;
 850     }
 851
 852 #if defined (__MSDOS__)
 853   if (_rl_read_init_file (filename, 0) == 0)
 854     return 0;
 855   filename = "~/_inputrc";
 856 #endif
 857   return (_rl_read_init_file (filename, 0));
 858 }
 859
 860 static int
 861 _rl_read_init_file (filename, include_level)
 862      const char *filename;
 863      int include_level;
 864 {
 865   register int i;
 866   char *buffer, *openname, *line, *end;
 867   size_t file_size;
 868
 869   current_readline_init_file = filename;
 870   current_readline_init_include_level = include_level;
 871
 872   openname = tilde_expand (filename);
 873   buffer = _rl_read_file (openname, &file_size);
 874   xfree (openname);
 875
 876   RL_CHECK_SIGNALS ();
 877   if (buffer == 0)
 878     return (errno);
 879
 880   if (include_level == 0 && filename != last_readline_init_file)
 881     {
 882       FREE (last_readline_init_file);
 883       last_readline_init_file = savestring (filename);
 884     }
 885
 886   currently_reading_init_file = 1;
 887
 888   /* Loop over the lines in the file.  Lines that start with `#' are
 889      comments; all other lines are commands for readline initialization. */
 890   current_readline_init_lineno = 1;
 891   line = buffer;
 892   end = buffer + file_size;
 893   while (line < end)
 894     {
 895       /* Find the end of this line. */
 896       for (i = 0; line + i != end && line[i] != '\n'; i++);
 897
 898 #if defined (__CYGWIN__)
 899       /* ``Be liberal in what you accept.'' */
 900       if (line[i] == '\n' && line[i-1] == '\r')
 901         line[i - 1] = '\0';
 902 #endif
 903
 904       /* Mark end of line. */
 905       line[i] = '\0';
 906
 907       /* Skip leading whitespace. */
 908       while (*line && whitespace (*line))
 909         {
 910           line++;
 911           i--;
 912         }
 913
 914       /* If the line is not a comment, then parse it. */
 915       if (*line && *line != '#')
 916         rl_parse_and_bind (line);
 917
 918       /* Move to the next line. */
 919       line += i + 1;
 920       current_readline_init_lineno++;
 921     }
 922
 923   xfree (buffer);
 924   currently_reading_init_file = 0;
 925   return (0);
 926 }
 927
 928 static void
 929 _rl_init_file_error (msg)
 930      const char *msg;
 931 {
 932   if (currently_reading_init_file)
 933     _rl_errmsg ("%s: line %d: %s\n", current_readline_init_file,
 934                      current_readline_init_lineno, msg);
 935   else
 936     _rl_errmsg ("%s", msg);
 937 }
 938
 939 /* **************************************************************** */
 940 /*                                                                  */
 941 /*                      Parser Directives                           */
 942 /*                                                                  */
 943 /* **************************************************************** */
 944
 945 typedef int _rl_parser_func_t PARAMS((char *));
 946
 947 /* Things that mean `Control'. */
 948 const char * const _rl_possible_control_prefixes[] = {
 949   "Control-", "C-", "CTRL-", (const char *)NULL
 950 };
 951
 952 const char * const _rl_possible_meta_prefixes[] = {
 953   "Meta", "M-", (const char *)NULL
 954 };
 955
 956 /* Conditionals. */
 957
 958 /* Calling programs set this to have their argv[0]. */
 959 const char *rl_readline_name = "other";
 960
 961 /* Stack of previous values of parsing_conditionalized_out. */
 962 static unsigned char *if_stack = (unsigned char *)NULL;
 963 static int if_stack_depth;
 964 static int if_stack_size;
 965
 966 /* Push _rl_parsing_conditionalized_out, and set parser state based
 967    on ARGS. */
 968 static int
 969 parser_if (args)
 970      char *args;
 971 {
 972   register int i;
 973
 974   /* Push parser state. */
 975   if (if_stack_depth + 1 >= if_stack_size)
 976     {
 977       if (!if_stack)
 978         if_stack = (unsigned char *)xmalloc (if_stack_size = 20);
 979       else
 980         if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20);
 981     }
 982   if_stack[if_stack_depth++] = _rl_parsing_conditionalized_out;
 983
 984   /* If parsing is turned off, then nothing can turn it back on except
 985      for finding the matching endif.  In that case, return right now. */
 986   if (_rl_parsing_conditionalized_out)
 987     return 0;
 988
 989   /* Isolate first argument. */
 990   for (i = 0; args[i] && !whitespace (args[i]); i++);
 991
 992   if (args[i])
 993     args[i++] = '\0';
 994
 995   /* Handle "$if term=foo" and "$if mode=emacs" constructs.  If this
 996      isn't term=foo, or mode=emacs, then check to see if the first
 997      word in ARGS is the same as the value stored in rl_readline_name. */
 998   if (rl_terminal_name && _rl_strnicmp (args, "term=", 5) == 0)
 999     {
1000       char *tem, *tname;
1001
1002       /* Terminals like "aaa-60" are equivalent to "aaa". */
1003       tname = savestring (rl_terminal_name);
1004       tem = strchr (tname, '-');
1005       if (tem)
1006         *tem = '\0';
1007
1008       /* Test the `long' and `short' forms of the terminal name so that
1009          if someone has a `sun-cmd' and does not want to have bindings
1010          that will be executed if the terminal is a `sun', they can put
1011          `$if term=sun-cmd' into their .inputrc. */
1012       _rl_parsing_conditionalized_out = _rl_stricmp (args + 5, tname) &&
1013                                         _rl_stricmp (args + 5, rl_terminal_name);
1014       xfree (tname);
1015     }
1016 #if defined (VI_MODE)
1017   else if (_rl_strnicmp (args, "mode=", 5) == 0)
1018     {
1019       int mode;
1020
1021       if (_rl_stricmp (args + 5, "emacs") == 0)
1022         mode = emacs_mode;
1023       else if (_rl_stricmp (args + 5, "vi") == 0)
1024         mode = vi_mode;
1025       else
1026         mode = no_mode;
1027
1028       _rl_parsing_conditionalized_out = mode != rl_editing_mode;
1029     }
1030 #endif /* VI_MODE */
1031   /* Check to see if the first word in ARGS is the same as the
1032      value stored in rl_readline_name. */
1033   else if (_rl_stricmp (args, rl_readline_name) == 0)
1034     _rl_parsing_conditionalized_out = 0;
1035   else
1036     _rl_parsing_conditionalized_out = 1;
1037   return 0;
1038 }
1039
1040 /* Invert the current parser state if there is anything on the stack. */
1041 static int
1042 parser_else (args)
1043      char *args;
1044 {
1045   register int i;
1046
1047   if (if_stack_depth == 0)
1048     {
1049       _rl_init_file_error ("$else found without matching $if");
1050       return 0;
1051     }
1052
1053 #if 0
1054   /* Check the previous (n - 1) levels of the stack to make sure that
1055      we haven't previously turned off parsing. */
1056   for (i = 0; i < if_stack_depth - 1; i++)
1057 #else
1058   /* Check the previous (n) levels of the stack to make sure that
1059      we haven't previously turned off parsing. */
1060   for (i = 0; i < if_stack_depth; i++)
1061 #endif
1062     if (if_stack[i] == 1)
1063       return 0;
1064
1065   /* Invert the state of parsing if at top level. */
1066   _rl_parsing_conditionalized_out = !_rl_parsing_conditionalized_out;
1067   return 0;
1068 }
1069
1070 /* Terminate a conditional, popping the value of
1071    _rl_parsing_conditionalized_out from the stack. */
1072 static int
1073 parser_endif (args)
1074      char *args;
1075 {
1076   if (if_stack_depth)
1077     _rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
1078   else
1079     _rl_init_file_error ("$endif without matching $if");
1080   return 0;
1081 }
1082
1083 static int
1084 parser_include (args)
1085      char *args;
1086 {
1087   const char *old_init_file;
1088   char *e;
1089   int old_line_number, old_include_level, r;
1090
1091   if (_rl_parsing_conditionalized_out)
1092     return (0);
1093
1094   old_init_file = current_readline_init_file;
1095   old_line_number = current_readline_init_lineno;
1096   old_include_level = current_readline_init_include_level;
1097
1098   e = strchr (args, '\n');
1099   if (e)
1100     *e = '\0';
1101   r = _rl_read_init_file ((const char *)args, old_include_level + 1);
1102
1103   current_readline_init_file = old_init_file;
1104   current_readline_init_lineno = old_line_number;
1105   current_readline_init_include_level = old_include_level;
1106
1107   return r;
1108 }
1109
1110 /* Associate textual names with actual functions. */
1111 static const struct {
1112   const char * const name;
1113   _rl_parser_func_t *function;
1114 } parser_directives [] = {
1115   { "if", parser_if },
1116   { "endif", parser_endif },
1117   { "else", parser_else },
1118   { "include", parser_include },
1119   { (char *)0x0, (_rl_parser_func_t *)0x0 }
1120 };
1121
1122 /* Handle a parser directive.  STATEMENT is the line of the directive
1123    without any leading `$'. */
1124 static int
1125 handle_parser_directive (statement)
1126      char *statement;
1127 {
1128   register int i;
1129   char *directive, *args;
1130
1131   /* Isolate the actual directive. */
1132
1133   /* Skip whitespace. */
1134   for (i = 0; whitespace (statement[i]); i++);
1135
1136   directive = &statement[i];
1137
1138   for (; statement[i] && !whitespace (statement[i]); i++);
1139
1140   if (statement[i])
1141     statement[i++] = '\0';
1142
1143   for (; statement[i] && whitespace (statement[i]); i++);
1144
1145   args = &statement[i];
1146
1147   /* Lookup the command, and act on it. */
1148   for (i = 0; parser_directives[i].name; i++)
1149     if (_rl_stricmp (directive, parser_directives[i].name) == 0)
1150       {
1151         (*parser_directives[i].function) (args);
1152         return (0);
1153       }
1154
1155   /* display an error message about the unknown parser directive */
1156   _rl_init_file_error ("unknown parser directive");
1157   return (1);
1158 }
1159
1160 /* Read the binding command from STRING and perform it.
1161    A key binding command looks like: Keyname: function-name\0,
1162    a variable binding command looks like: set variable value.
1163    A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
1164 int
1165 rl_parse_and_bind (string)
1166      char *string;
1167 {
1168   char *funname, *kname;
1169   register int c, i;
1170   int key, equivalency;
1171
1172   while (string && whitespace (*string))
1173     string++;
1174
1175   if (!string || !*string || *string == '#')
1176     return 0;
1177
1178   /* If this is a parser directive, act on it. */
1179   if (*string == '$')
1180     {
1181       handle_parser_directive (&string[1]);
1182       return 0;
1183     }
1184
1185   /* If we aren't supposed to be parsing right now, then we're done. */
1186   if (_rl_parsing_conditionalized_out)
1187     return 0;
1188
1189   i = 0;
1190   /* If this keyname is a complex key expression surrounded by quotes,
1191      advance to after the matching close quote.  This code allows the
1192      backslash to quote characters in the key expression. */
1193   if (*string == '"')
1194     {
1195       int passc = 0;
1196
1197       for (i = 1; c = string[i]; i++)
1198         {
1199           if (passc)
1200             {
1201               passc = 0;
1202               continue;
1203             }
1204
1205           if (c == '\\')
1206             {
1207               passc++;
1208               continue;
1209             }
1210
1211           if (c == '"')
1212             break;
1213         }
1214       /* If we didn't find a closing quote, abort the line. */
1215       if (string[i] == '\0')
1216         {
1217           _rl_init_file_error ("no closing `\"' in key binding");
1218           return 1;
1219         }
1220     }
1221
1222   /* Advance to the colon (:) or whitespace which separates the two objects. */
1223   for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );
1224
1225   equivalency = (c == ':' && string[i + 1] == '=');
1226
1227   /* Mark the end of the command (or keyname). */
1228   if (string[i])
1229     string[i++] = '\0';
1230
1231   /* If doing assignment, skip the '=' sign as well. */
1232   if (equivalency)
1233     string[i++] = '\0';
1234
1235   /* If this is a command to set a variable, then do that. */
1236   if (_rl_stricmp (string, "set") == 0)
1237     {
1238       char *var, *value, *e;
1239
1240       var = string + i;
1241       /* Make VAR point to start of variable name. */
1242       while (*var && whitespace (*var)) var++;
1243
1244       /* Make VALUE point to start of value string. */
1245       value = var;
1246       while (*value && !whitespace (*value)) value++;
1247       if (*value)
1248         *value++ = '\0';
1249       while (*value && whitespace (*value)) value++;
1250
1251       /* Strip trailing whitespace from values to boolean variables.  Temp
1252          fix until I get a real quoted-string parser here. */
1253       i = find_boolean_var (var);
1254       if (i >= 0)
1255         {
1256           /* remove trailing whitespace */
1257           e = value + strlen (value) - 1;
1258           while (e >= value && whitespace (*e))
1259             e--;
1260           e++;          /* skip back to whitespace or EOS */
1261           if (*e && e >= value)
1262             *e = '\0';
1263         }
1264
1265       rl_variable_bind (var, value);
1266       return 0;
1267     }
1268
1269   /* Skip any whitespace between keyname and funname. */
1270   for (; string[i] && whitespace (string[i]); i++);
1271   funname = &string[i];
1272
1273   /* Now isolate funname.
1274      For straight function names just look for whitespace, since
1275      that will signify the end of the string.  But this could be a
1276      macro definition.  In that case, the string is quoted, so skip
1277      to the matching delimiter.  We allow the backslash to quote the
1278      delimiter characters in the macro body. */
1279   /* This code exists to allow whitespace in macro expansions, which
1280      would otherwise be gobbled up by the next `for' loop.*/
1281   /* XXX - it may be desirable to allow backslash quoting only if " is
1282      the quoted string delimiter, like the shell. */
1283   if (*funname == '\'' || *funname == '"')
1284     {
1285       int delimiter, passc;
1286
1287       delimiter = string[i++];
1288       for (passc = 0; c = string[i]; i++)
1289         {
1290           if (passc)
1291             {
1292               passc = 0;
1293               continue;
1294             }
1295
1296           if (c == '\\')
1297             {
1298               passc = 1;
1299               continue;
1300             }
1301
1302           if (c == delimiter)
1303             break;
1304         }
1305       if (c)
1306         i++;
1307     }
1308
1309   /* Advance to the end of the string.  */
1310   for (; string[i] && !whitespace (string[i]); i++);
1311
1312   /* No extra whitespace at the end of the string. */
1313   string[i] = '\0';
1314
1315   /* Handle equivalency bindings here.  Make the left-hand side be exactly
1316      whatever the right-hand evaluates to, including keymaps. */
1317   if (equivalency)
1318     {
1319       return 0;
1320     }
1321
1322   /* If this is a new-style key-binding, then do the binding with
1323      rl_bind_keyseq ().  Otherwise, let the older code deal with it. */
1324   if (*string == '"')
1325     {
1326       char *seq;
1327       register int j, k, passc;
1328
1329       seq = (char *)xmalloc (1 + strlen (string));
1330       for (j = 1, k = passc = 0; string[j]; j++)
1331         {
1332           /* Allow backslash to quote characters, but leave them in place.
1333              This allows a string to end with a backslash quoting another
1334              backslash, or with a backslash quoting a double quote.  The
1335              backslashes are left in place for rl_translate_keyseq (). */
1336           if (passc || (string[j] == '\\'))
1337             {
1338               seq[k++] = string[j];
1339               passc = !passc;
1340               continue;
1341             }
1342
1343           if (string[j] == '"')
1344             break;
1345
1346           seq[k++] = string[j];
1347         }
1348       seq[k] = '\0';
1349
1350       /* Binding macro? */
1351       if (*funname == '\'' || *funname == '"')
1352         {
1353           j = strlen (funname);
1354
1355           /* Remove the delimiting quotes from each end of FUNNAME. */
1356           if (j && funname[j - 1] == *funname)
1357             funname[j - 1] = '\0';
1358
1359           rl_macro_bind (seq, &funname[1], _rl_keymap);
1360         }
1361       else
1362         rl_bind_keyseq (seq, rl_named_function (funname));
1363
1364       xfree (seq);
1365       return 0;
1366     }
1367
1368   /* Get the actual character we want to deal with. */
1369   kname = strrchr (string, '-');
1370   if (!kname)
1371     kname = string;
1372   else
1373     kname++;
1374
1375   key = glean_key_from_name (kname);
1376
1377   /* Add in control and meta bits. */
1378   if (substring_member_of_array (string, _rl_possible_control_prefixes))
1379     key = CTRL (_rl_to_upper (key));
1380
1381   if (substring_member_of_array (string, _rl_possible_meta_prefixes))
1382     key = META (key);
1383
1384   /* Temporary.  Handle old-style keyname with macro-binding. */
1385   if (*funname == '\'' || *funname == '"')
1386     {
1387       char useq[2];
1388       int fl = strlen (funname);
1389
1390       useq[0] = key; useq[1] = '\0';
1391       if (fl && funname[fl - 1] == *funname)
1392         funname[fl - 1] = '\0';
1393
1394       rl_macro_bind (useq, &funname[1], _rl_keymap);
1395     }
1396 #if defined (PREFIX_META_HACK)
1397   /* Ugly, but working hack to keep prefix-meta around. */
1398   else if (_rl_stricmp (funname, "prefix-meta") == 0)
1399     {
1400       char seq[2];
1401
1402       seq[0] = key;
1403       seq[1] = '\0';
1404       rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, _rl_keymap);
1405     }
1406 #endif /* PREFIX_META_HACK */
1407   else
1408     rl_bind_key (key, rl_named_function (funname));
1409   return 0;
1410 }
1411
1412 /* Simple structure for boolean readline variables (i.e., those that can
1413    have one of two values; either "On" or 1 for truth, or "Off" or 0 for
1414    false. */
1415
1416 #define V_SPECIAL       0x1
1417
1418 static const struct {
1419   const char * const name;
1420   int *value;
1421   int flags;
1422 } boolean_varlist [] = {
1423   { "bind-tty-special-chars",   &_rl_bind_stty_chars,           0 },
1424   { "blink-matching-paren",     &rl_blink_matching_paren,       V_SPECIAL },
1425   { "byte-oriented",            &rl_byte_oriented,              0 },
1426   { "completion-ignore-case",   &_rl_completion_case_fold,      0 },
1427   { "convert-meta",             &_rl_convert_meta_chars_to_ascii, 0 },
1428   { "disable-completion",       &rl_inhibit_completion,         0 },
1429   { "echo-control-characters",  &_rl_echo_control_chars,        0 },
1430   { "enable-keypad",            &_rl_enable_keypad,             0 },
1431   { "enable-meta-key",          &_rl_enable_meta,               0 },
1432   { "expand-tilde",             &rl_complete_with_tilde_expansion, 0 },
1433   { "history-preserve-point",   &_rl_history_preserve_point,    0 },
1434   { "horizontal-scroll-mode",   &_rl_horizontal_scroll_mode,    0 },
1435   { "input-meta",               &_rl_meta_flag,                 0 },
1436   { "mark-directories",         &_rl_complete_mark_directories, 0 },
1437   { "mark-modified-lines",      &_rl_mark_modified_lines,       0 },
1438   { "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs, 0 },
1439   { "match-hidden-files",       &_rl_match_hidden_files,        0 },
1440   { "meta-flag",                &_rl_meta_flag,                 0 },
1441   { "output-meta",              &_rl_output_meta_chars,         0 },
1442   { "page-completions",         &_rl_page_completions,          0 },
1443   { "prefer-visible-bell",      &_rl_prefer_visible_bell,       V_SPECIAL },
1444   { "print-completions-horizontally", &_rl_print_completions_horizontally, 0 },
1445   { "revert-all-at-newline",    &_rl_revert_all_at_newline,     0 },
1446   { "show-all-if-ambiguous",    &_rl_complete_show_all,         0 },
1447   { "show-all-if-unmodified",   &_rl_complete_show_unmodified,  0 },
1448   { "skip-completed-text",      &_rl_skip_completed_text,       0 },
1449 #if defined (VISIBLE_STATS)
1450   { "visible-stats",            &rl_visible_stats,              0 },
1451 #endif /* VISIBLE_STATS */
1452   { (char *)NULL, (int *)NULL }
1453 };
1454
1455 static int
1456 find_boolean_var (name)
1457      const char *name;
1458 {
1459   register int i;
1460
1461   for (i = 0; boolean_varlist[i].name; i++)
1462     if (_rl_stricmp (name, boolean_varlist[i].name) == 0)
1463       return i;
1464   return -1;
1465 }
1466
1467 /* Hooks for handling special boolean variables, where a
1468    function needs to be called or another variable needs
1469    to be changed when they're changed. */
1470 static void
1471 hack_special_boolean_var (i)
1472      int i;
1473 {
1474   const char *name;
1475
1476   name = boolean_varlist[i].name;
1477
1478   if (_rl_stricmp (name, "blink-matching-paren") == 0)
1479     _rl_enable_paren_matching (rl_blink_matching_paren);
1480   else if (_rl_stricmp (name, "prefer-visible-bell") == 0)
1481     {
1482       if (_rl_prefer_visible_bell)
1483         _rl_bell_preference = VISIBLE_BELL;
1484       else
1485         _rl_bell_preference = AUDIBLE_BELL;
1486     }
1487 }
1488
1489 typedef int _rl_sv_func_t PARAMS((const char *));
1490
1491 /* These *must* correspond to the array indices for the appropriate
1492    string variable.  (Though they're not used right now.) */
1493 #define V_BELLSTYLE     0
1494 #define V_COMBEGIN      1
1495 #define V_EDITMODE      2
1496 #define V_ISRCHTERM     3
1497 #define V_KEYMAP        4
1498
1499 #define V_STRING        1
1500 #define V_INT           2
1501
1502 /* Forward declarations */
1503 static int sv_bell_style PARAMS((const char *));
1504 static int sv_combegin PARAMS((const char *));
1505 static int sv_dispprefix PARAMS((const char *));
1506 static int sv_compquery PARAMS((const char *));
1507 static int sv_editmode PARAMS((const char *));
1508 static int sv_histsize PARAMS((const char *));
1509 static int sv_isrchterm PARAMS((const char *));
1510 static int sv_keymap PARAMS((const char *));
1511
1512 static const struct {
1513   const char * const name;
1514   int flags;
1515   _rl_sv_func_t *set_func;
1516 } string_varlist[] = {
1517   { "bell-style",       V_STRING,       sv_bell_style },
1518   { "comment-begin",    V_STRING,       sv_combegin },
1519   { "completion-prefix-display-length", V_INT,  sv_dispprefix },
1520   { "completion-query-items", V_INT,    sv_compquery },
1521   { "editing-mode",     V_STRING,       sv_editmode },
1522   { "history-size",     V_INT,          sv_histsize },
1523   { "isearch-terminators", V_STRING,    sv_isrchterm },
1524   { "keymap",           V_STRING,       sv_keymap },
1525   { (char *)NULL,       0 }
1526 };
1527
1528 static int
1529 find_string_var (name)
1530      const char *name;
1531 {
1532   register int i;
1533
1534   for (i = 0; string_varlist[i].name; i++)
1535     if (_rl_stricmp (name, string_varlist[i].name) == 0)
1536       return i;
1537   return -1;
1538 }
1539
1540 /* A boolean value that can appear in a `set variable' command is true if
1541    the value is null or empty, `on' (case-insenstive), or "1".  Any other
1542    values result in 0 (false). */
1543 static int
1544 bool_to_int (value)
1545      const char *value;
1546 {
1547   return (value == 0 || *value == '\0' ||
1548                 (_rl_stricmp (value, "on") == 0) ||
1549                 (value[0] == '1' && value[1] == '\0'));
1550 }
1551
1552 char *
1553 rl_variable_value (name)
1554      const char *name;
1555 {
1556   register int i;
1557
1558   /* Check for simple variables first. */
1559   i = find_boolean_var (name);
1560   if (i >= 0)
1561     return (*boolean_varlist[i].value ? "on" : "off");
1562
1563   i = find_string_var (name);
1564   if (i >= 0)
1565     return (_rl_get_string_variable_value (string_varlist[i].name));
1566
1567   /* Unknown variable names return NULL. */
1568   return 0;
1569 }
1570
1571 int
1572 rl_variable_bind (name, value)
1573      const char *name, *value;
1574 {
1575   register int i;
1576   int   v;
1577
1578   /* Check for simple variables first. */
1579   i = find_boolean_var (name);
1580   if (i >= 0)
1581     {
1582       *boolean_varlist[i].value = bool_to_int (value);
1583       if (boolean_varlist[i].flags & V_SPECIAL)
1584         hack_special_boolean_var (i);
1585       return 0;
1586     }
1587
1588   i = find_string_var (name);
1589
1590   /* For the time being, unknown variable names or string names without a
1591      handler function are simply ignored. */
1592   if (i < 0 || string_varlist[i].set_func == 0)
1593     return 0;
1594
1595   v = (*string_varlist[i].set_func) (value);
1596   return v;
1597 }
1598
1599 static int
1600 sv_editmode (value)
1601      const char *value;
1602 {
1603   if (_rl_strnicmp (value, "vi", 2) == 0)
1604     {
1605 #if defined (VI_MODE)
1606       _rl_keymap = vi_insertion_keymap;
1607       rl_editing_mode = vi_mode;
1608 #endif /* VI_MODE */
1609       return 0;
1610     }
1611   else if (_rl_strnicmp (value, "emacs", 5) == 0)
1612     {
1613       _rl_keymap = emacs_standard_keymap;
1614       rl_editing_mode = emacs_mode;
1615       return 0;
1616     }
1617   return 1;
1618 }
1619
1620 static int
1621 sv_combegin (value)
1622      const char *value;
1623 {
1624   if (value && *value)
1625     {
1626       FREE (_rl_comment_begin);
1627       _rl_comment_begin = savestring (value);
1628       return 0;
1629     }
1630   return 1;
1631 }
1632
1633 static int
1634 sv_dispprefix (value)
1635      const char *value;
1636 {
1637   int nval = 0;
1638
1639   if (value && *value)
1640     {
1641       nval = atoi (value);
1642       if (nval < 0)
1643         nval = 0;
1644     }
1645   _rl_completion_prefix_display_length = nval;
1646   return 0;
1647 }
1648
1649 static int
1650 sv_compquery (value)
1651      const char *value;
1652 {
1653   int nval = 100;
1654
1655   if (value && *value)
1656     {
1657       nval = atoi (value);
1658       if (nval < 0)
1659         nval = 0;
1660     }
1661   rl_completion_query_items = nval;
1662   return 0;
1663 }
1664
1665 static int
1666 sv_histsize (value)
1667      const char *value;
1668 {
1669   int nval = 500;
1670
1671   if (value && *value)
1672     {
1673       nval = atoi (value);
1674       if (nval < 0)
1675         return 1;
1676     }
1677   stifle_history (nval);
1678   return 0;
1679 }
1680
1681 static int
1682 sv_keymap (value)
1683      const char *value;
1684 {
1685   Keymap kmap;
1686
1687   kmap = rl_get_keymap_by_name (value);
1688   if (kmap)
1689     {
1690       rl_set_keymap (kmap);
1691       return 0;
1692     }
1693   return 1;
1694 }
1695
1696 static int
1697 sv_bell_style (value)
1698      const char *value;
1699 {
1700   if (value == 0 || *value == '\0')
1701     _rl_bell_preference = AUDIBLE_BELL;
1702   else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
1703     _rl_bell_preference = NO_BELL;
1704   else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
1705     _rl_bell_preference = AUDIBLE_BELL;
1706   else if (_rl_stricmp (value, "visible") == 0)
1707     _rl_bell_preference = VISIBLE_BELL;
1708   else
1709     return 1;
1710   return 0;
1711 }
1712
1713 static int
1714 sv_isrchterm (value)
1715      const char *value;
1716 {
1717   int beg, end, delim;
1718   char *v;
1719
1720   if (value == 0)
1721     return 1;
1722
1723   /* Isolate the value and translate it into a character string. */
1724   v = savestring (value);
1725   FREE (_rl_isearch_terminators);
1726   if (v[0] == '"' || v[0] == '\'')
1727     {
1728       delim = v[0];
1729       for (beg = end = 1; v[end] && v[end] != delim; end++)
1730         ;
1731     }
1732   else
1733     {
1734       for (beg = end = 0; whitespace (v[end]) == 0; end++)
1735         ;
1736     }
1737
1738   v[end] = '\0';
1739
1740   /* The value starts at v + beg.  Translate it into a character string. */
1741   _rl_isearch_terminators = (char *)xmalloc (2 * strlen (v) + 1);
1742   rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
1743   _rl_isearch_terminators[end] = '\0';
1744
1745   xfree (v);
1746   return 0;
1747 }
1748
1749 /* Return the character which matches NAME.
1750    For example, `Space' returns ' '. */
1751
1752 typedef struct {
1753   const char * const name;
1754   int value;
1755 } assoc_list;
1756
1757 static const assoc_list name_key_alist[] = {
1758   { "DEL", 0x7f },
1759   { "ESC", '\033' },
1760   { "Escape", '\033' },
1761   { "LFD", '\n' },
1762   { "Newline", '\n' },
1763   { "RET", '\r' },
1764   { "Return", '\r' },
1765   { "Rubout", 0x7f },
1766   { "SPC", ' ' },
1767   { "Space", ' ' },
1768   { "Tab", 0x09 },
1769   { (char *)0x0, 0 }
1770 };
1771
1772 static int
1773 glean_key_from_name (name)
1774      char *name;
1775 {
1776   register int i;
1777
1778   for (i = 0; name_key_alist[i].name; i++)
1779     if (_rl_stricmp (name, name_key_alist[i].name) == 0)
1780       return (name_key_alist[i].value);
1781
1782   return (*(unsigned char *)name);      /* XXX was return (*name) */
1783 }
1784
1785 /* Auxiliary functions to manage keymaps. */
1786 static const struct {
1787   const char * const name;
1788   Keymap map;
1789 } keymap_names[] = {
1790   { "emacs", emacs_standard_keymap },
1791   { "emacs-standard", emacs_standard_keymap },
1792   { "emacs-meta", emacs_meta_keymap },
1793   { "emacs-ctlx", emacs_ctlx_keymap },
1794 #if defined (VI_MODE)
1795   { "vi", vi_movement_keymap },
1796   { "vi-move", vi_movement_keymap },
1797   { "vi-command", vi_movement_keymap },
1798   { "vi-insert", vi_insertion_keymap },
1799 #endif /* VI_MODE */
1800   { (char *)0x0, (Keymap)0x0 }
1801 };
1802
1803 Keymap
1804 rl_get_keymap_by_name (name)
1805      const char *name;
1806 {
1807   register int i;
1808
1809   for (i = 0; keymap_names[i].name; i++)
1810     if (_rl_stricmp (name, keymap_names[i].name) == 0)
1811       return (keymap_names[i].map);
1812   return ((Keymap) NULL);
1813 }
1814
1815 char *
1816 rl_get_keymap_name (map)
1817      Keymap map;
1818 {
1819   register int i;
1820   for (i = 0; keymap_names[i].name; i++)
1821     if (map == keymap_names[i].map)
1822       return ((char *)keymap_names[i].name);
1823   return ((char *)NULL);
1824 }
1825
1826 void
1827 rl_set_keymap (map)
1828      Keymap map;
1829 {
1830   if (map)
1831     _rl_keymap = map;
1832 }
1833
1834 Keymap
1835 rl_get_keymap ()
1836 {
1837   return (_rl_keymap);
1838 }
1839
1840 void
1841 rl_set_keymap_from_edit_mode ()
1842 {
1843   if (rl_editing_mode == emacs_mode)
1844     _rl_keymap = emacs_standard_keymap;
1845 #if defined (VI_MODE)
1846   else if (rl_editing_mode == vi_mode)
1847     _rl_keymap = vi_insertion_keymap;
1848 #endif /* VI_MODE */
1849 }
1850
1851 char *
1852 rl_get_keymap_name_from_edit_mode ()
1853 {
1854   if (rl_editing_mode == emacs_mode)
1855     return "emacs";
1856 #if defined (VI_MODE)
1857   else if (rl_editing_mode == vi_mode)
1858     return "vi";
1859 #endif /* VI_MODE */
1860   else
1861     return "none";
1862 }
1863
1864 /* **************************************************************** */
1865 /*                                                                  */
1866 /*                Key Binding and Function Information              */
1867 /*                                                                  */
1868 /* **************************************************************** */
1869
1870 /* Each of the following functions produces information about the
1871    state of keybindings and functions known to Readline.  The info
1872    is always printed to rl_outstream, and in such a way that it can
1873    be read back in (i.e., passed to rl_parse_and_bind ()). */
1874
1875 /* Print the names of functions known to Readline. */
1876 void
1877 rl_list_funmap_names ()
1878 {
1879   register int i;
1880   const char **funmap_names;
1881
1882   funmap_names = rl_funmap_names ();
1883
1884   if (!funmap_names)
1885     return;
1886
1887   for (i = 0; funmap_names[i]; i++)
1888     fprintf (rl_outstream, "%s\n", funmap_names[i]);
1889
1890   xfree (funmap_names);
1891 }
1892
1893 static char *
1894 _rl_get_keyname (key)
1895      int key;
1896 {
1897   char *keyname;
1898   int i, c;
1899
1900   keyname = (char *)xmalloc (8);
1901
1902   c = key;
1903   /* Since this is going to be used to write out keysequence-function
1904      pairs for possible inclusion in an inputrc file, we don't want to
1905      do any special meta processing on KEY. */
1906
1907 #if 1
1908   /* XXX - Experimental */
1909   /* We might want to do this, but the old version of the code did not. */
1910
1911   /* If this is an escape character, we don't want to do any more processing.
1912      Just add the special ESC key sequence and return. */
1913   if (c == ESC)
1914     {
1915       keyname[0] = '\\';
1916       keyname[1] = 'e';
1917       keyname[2] = '\0';
1918       return keyname;
1919     }
1920 #endif
1921
1922   /* RUBOUT is translated directly into \C-? */
1923   if (key == RUBOUT)
1924     {
1925       keyname[0] = '\\';
1926       keyname[1] = 'C';
1927       keyname[2] = '-';
1928       keyname[3] = '?';
1929       keyname[4] = '\0';
1930       return keyname;
1931     }
1932
1933   i = 0;
1934   /* Now add special prefixes needed for control characters.  This can
1935      potentially change C. */
1936   if (CTRL_CHAR (c))
1937     {
1938       keyname[i++] = '\\';
1939       keyname[i++] = 'C';
1940       keyname[i++] = '-';
1941       c = _rl_to_lower (UNCTRL (c));
1942     }
1943
1944   /* XXX experimental code.  Turn the characters that are not ASCII or
1945      ISO Latin 1 (128 - 159) into octal escape sequences (\200 - \237).
1946      This changes C. */
1947   if (c >= 128 && c <= 159)
1948     {
1949       keyname[i++] = '\\';
1950       keyname[i++] = '2';
1951       c -= 128;
1952       keyname[i++] = (c / 8) + '0';
1953       c = (c % 8) + '0';
1954     }
1955
1956   /* Now, if the character needs to be quoted with a backslash, do that. */
1957   if (c == '\\' || c == '"')
1958     keyname[i++] = '\\';
1959
1960   /* Now add the key, terminate the string, and return it. */
1961   keyname[i++] = (char) c;
1962   keyname[i] = '\0';
1963
1964   return keyname;
1965 }
1966
1967 /* Return a NULL terminated array of strings which represent the key
1968    sequences that are used to invoke FUNCTION in MAP. */
1969 char **
1970 rl_invoking_keyseqs_in_map (function, map)
1971      rl_command_func_t *function;
1972      Keymap map;
1973 {
1974   register int key;
1975   char **result;
1976   int result_index, result_size;
1977
1978   result = (char **)NULL;
1979   result_index = result_size = 0;
1980
1981   for (key = 0; key < KEYMAP_SIZE; key++)
1982     {
1983       switch (map[key].type)
1984         {
1985         case ISMACR:
1986           /* Macros match, if, and only if, the pointers are identical.
1987              Thus, they are treated exactly like functions in here. */
1988         case ISFUNC:
1989           /* If the function in the keymap is the one we are looking for,
1990              then add the current KEY to the list of invoking keys. */
1991           if (map[key].function == function)
1992             {
1993               char *keyname;
1994
1995               keyname = _rl_get_keyname (key);
1996
1997               if (result_index + 2 > result_size)
1998                 {
1999                   result_size += 10;
2000                   result = (char **)xrealloc (result, result_size * sizeof (char *));
2001                 }
2002
2003               result[result_index++] = keyname;
2004               result[result_index] = (char *)NULL;
2005             }
2006           break;
2007
2008         case ISKMAP:
2009           {
2010             char **seqs;
2011             register int i;
2012
2013             /* Find the list of keyseqs in this map which have FUNCTION as
2014                their target.  Add the key sequences found to RESULT. */
2015             if (map[key].function)
2016               seqs =
2017                 rl_invoking_keyseqs_in_map (function, FUNCTION_TO_KEYMAP (map, key));
2018             else
2019               break;
2020
2021             if (seqs == 0)
2022               break;
2023
2024             for (i = 0; seqs[i]; i++)
2025               {
2026                 char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
2027
2028                 if (key == ESC)
2029                   {
2030                     /* If ESC is the meta prefix and we're converting chars
2031                        with the eighth bit set to ESC-prefixed sequences, then
2032                        we can use \M-.  Otherwise we need to use the sequence
2033                        for ESC. */
2034                     if (_rl_convert_meta_chars_to_ascii && map[ESC].type == ISKMAP)
2035                       sprintf (keyname, "\\M-");
2036                     else
2037                       sprintf (keyname, "\\e");
2038                   }
2039                 else if (CTRL_CHAR (key))
2040                   sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
2041                 else if (key == RUBOUT)
2042                   sprintf (keyname, "\\C-?");
2043                 else if (key == '\\' || key == '"')
2044                   {
2045                     keyname[0] = '\\';
2046                     keyname[1] = (char) key;
2047                     keyname[2] = '\0';
2048                   }
2049                 else
2050                   {
2051                     keyname[0] = (char) key;
2052                     keyname[1] = '\0';
2053                   }
2054
2055                 strcat (keyname, seqs[i]);
2056                 xfree (seqs[i]);
2057
2058                 if (result_index + 2 > result_size)
2059                   {
2060                     result_size += 10;
2061                     result = (char **)xrealloc (result, result_size * sizeof (char *));
2062                   }
2063
2064                 result[result_index++] = keyname;
2065                 result[result_index] = (char *)NULL;
2066               }
2067
2068             xfree (seqs);
2069           }
2070           break;
2071         }
2072     }
2073   return (result);
2074 }
2075
2076 /* Return a NULL terminated array of strings which represent the key
2077    sequences that can be used to invoke FUNCTION using the current keymap. */
2078 char **
2079 rl_invoking_keyseqs (function)
2080      rl_command_func_t *function;
2081 {
2082   return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
2083 }
2084
2085 /* Print all of the functions and their bindings to rl_outstream.  If
2086    PRINT_READABLY is non-zero, then print the output in such a way
2087    that it can be read back in. */
2088 void
2089 rl_function_dumper (print_readably)
2090      int print_readably;
2091 {
2092   register int i;
2093   const char **names;
2094   const char *name;
2095
2096   names = rl_funmap_names ();
2097
2098   fprintf (rl_outstream, "\n");
2099
2100   for (i = 0; name = names[i]; i++)
2101     {
2102       rl_command_func_t *function;
2103       char **invokers;
2104
2105       function = rl_named_function (name);
2106       invokers = rl_invoking_keyseqs_in_map (function, _rl_keymap);
2107
2108       if (print_readably)
2109         {
2110           if (!invokers)
2111             fprintf (rl_outstream, "# %s (not bound)\n", name);
2112           else
2113             {
2114               register int j;
2115
2116               for (j = 0; invokers[j]; j++)
2117                 {
2118                   fprintf (rl_outstream, "\"%s\": %s\n",
2119                            invokers[j], name);
2120                   xfree (invokers[j]);
2121                 }
2122
2123               xfree (invokers);
2124             }
2125         }
2126       else
2127         {
2128           if (!invokers)
2129             fprintf (rl_outstream, "%s is not bound to any keys\n",
2130                      name);
2131           else
2132             {
2133               register int j;
2134
2135               fprintf (rl_outstream, "%s can be found on ", name);
2136
2137               for (j = 0; invokers[j] && j < 5; j++)
2138                 {
2139                   fprintf (rl_outstream, "\"%s\"%s", invokers[j],
2140                            invokers[j + 1] ? ", " : ".\n");
2141                 }
2142
2143               if (j == 5 && invokers[j])
2144                 fprintf (rl_outstream, "...\n");
2145
2146               for (j = 0; invokers[j]; j++)
2147                 xfree (invokers[j]);
2148
2149               xfree (invokers);
2150             }
2151         }
2152     }
2153 }
2154
2155 /* Print all of the current functions and their bindings to
2156    rl_outstream.  If an explicit argument is given, then print
2157    the output in such a way that it can be read back in. */
2158 int
2159 rl_dump_functions (count, key)
2160      int count, key;
2161 {
2162   if (rl_dispatching)
2163     fprintf (rl_outstream, "\r\n");
2164   rl_function_dumper (rl_explicit_arg);
2165   rl_on_new_line ();
2166   return (0);
2167 }
2168
2169 static void
2170 _rl_macro_dumper_internal (print_readably, map, prefix)
2171      int print_readably;
2172      Keymap map;
2173      char *prefix;
2174 {
2175   register int key;
2176   char *keyname, *out;
2177   int prefix_len;
2178
2179   for (key = 0; key < KEYMAP_SIZE; key++)
2180     {
2181       switch (map[key].type)
2182         {
2183         case ISMACR:
2184           keyname = _rl_get_keyname (key);
2185           out = _rl_untranslate_macro_value ((char *)map[key].function);
2186
2187           if (print_readably)
2188             fprintf (rl_outstream, "\"%s%s\": \"%s\"\n", prefix ? prefix : "",
2189                                                          keyname,
2190                                                          out ? out : "");
2191           else
2192             fprintf (rl_outstream, "%s%s outputs %s\n", prefix ? prefix : "",
2193                                                         keyname,
2194                                                         out ? out : "");
2195           xfree (keyname);
2196           xfree (out);
2197           break;
2198         case ISFUNC:
2199           break;
2200         case ISKMAP:
2201           prefix_len = prefix ? strlen (prefix) : 0;
2202           if (key == ESC)
2203             {
2204               keyname = (char *)xmalloc (3 + prefix_len);
2205               if (prefix)
2206                 strcpy (keyname, prefix);
2207               keyname[prefix_len] = '\\';
2208               keyname[prefix_len + 1] = 'e';
2209               keyname[prefix_len + 2] = '\0';
2210             }
2211           else
2212             {
2213               keyname = _rl_get_keyname (key);
2214               if (prefix)
2215                 {
2216                   out = (char *)xmalloc (strlen (keyname) + prefix_len + 1);
2217                   strcpy (out, prefix);
2218                   strcpy (out + prefix_len, keyname);
2219                   xfree (keyname);
2220                   keyname = out;
2221                 }
2222             }
2223
2224           _rl_macro_dumper_internal (print_readably, FUNCTION_TO_KEYMAP (map, key), keyname);
2225           xfree (keyname);
2226           break;
2227         }
2228     }
2229 }
2230
2231 void
2232 rl_macro_dumper (print_readably)
2233      int print_readably;
2234 {
2235   _rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
2236 }
2237
2238 int
2239 rl_dump_macros (count, key)
2240      int count, key;
2241 {
2242   if (rl_dispatching)
2243     fprintf (rl_outstream, "\r\n");
2244   rl_macro_dumper (rl_explicit_arg);
2245   rl_on_new_line ();
2246   return (0);
2247 }
2248
2249 static char *
2250 _rl_get_string_variable_value (name)
2251      const char *name;
2252 {
2253   static char numbuf[32];
2254   char *ret;
2255
2256   if (_rl_stricmp (name, "bell-style") == 0)
2257     {
2258       switch (_rl_bell_preference)
2259         {
2260           case NO_BELL:
2261             return "none";
2262           case VISIBLE_BELL:
2263             return "visible";
2264           case AUDIBLE_BELL:
2265           default:
2266             return "audible";
2267         }
2268     }
2269   else if (_rl_stricmp (name, "comment-begin") == 0)
2270     return (_rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
2271   else if (_rl_stricmp (name, "completion-prefix-display-length") == 0)
2272     {
2273       sprintf (numbuf, "%d", _rl_completion_prefix_display_length);
2274       return (numbuf);
2275     }
2276   else if (_rl_stricmp (name, "completion-query-items") == 0)
2277     {
2278       sprintf (numbuf, "%d", rl_completion_query_items);
2279       return (numbuf);
2280     }
2281   else if (_rl_stricmp (name, "editing-mode") == 0)
2282     return (rl_get_keymap_name_from_edit_mode ());
2283   else if (_rl_stricmp (name, "history-size") == 0)
2284     {
2285       sprintf (numbuf, "%d", history_is_stifled() ? history_max_entries : 0);
2286       return (numbuf);
2287     }
2288   else if (_rl_stricmp (name, "isearch-terminators") == 0)
2289     {
2290       if (_rl_isearch_terminators == 0)
2291         return 0;
2292       ret = _rl_untranslate_macro_value (_rl_isearch_terminators);
2293       if (ret)
2294         {
2295           strncpy (numbuf, ret, sizeof (numbuf) - 1);
2296           xfree (ret);
2297           numbuf[sizeof(numbuf) - 1] = '\0';
2298         }
2299       else
2300         numbuf[0] = '\0';
2301       return numbuf;
2302     }
2303   else if (_rl_stricmp (name, "keymap") == 0)
2304     {
2305       ret = rl_get_keymap_name (_rl_keymap);
2306       if (ret == 0)
2307         ret = rl_get_keymap_name_from_edit_mode ();
2308       return (ret ? ret : "none");
2309     }
2310   else
2311     return (0);
2312 }
2313
2314 void
2315 rl_variable_dumper (print_readably)
2316      int print_readably;
2317 {
2318   int i;
2319   char *v;
2320
2321   for (i = 0; boolean_varlist[i].name; i++)
2322     {
2323       if (print_readably)
2324         fprintf (rl_outstream, "set %s %s\n", boolean_varlist[i].name,
2325                                *boolean_varlist[i].value ? "on" : "off");
2326       else
2327         fprintf (rl_outstream, "%s is set to `%s'\n", boolean_varlist[i].name,
2328                                *boolean_varlist[i].value ? "on" : "off");
2329     }
2330
2331   for (i = 0; string_varlist[i].name; i++)
2332     {
2333       v = _rl_get_string_variable_value (string_varlist[i].name);
2334       if (v == 0)       /* _rl_isearch_terminators can be NULL */
2335         continue;
2336       if (print_readably)
2337         fprintf (rl_outstream, "set %s %s\n", string_varlist[i].name, v);
2338       else
2339         fprintf (rl_outstream, "%s is set to `%s'\n", string_varlist[i].name, v);
2340     }
2341 }
2342
2343 /* Print all of the current variables and their values to
2344    rl_outstream.  If an explicit argument is given, then print
2345    the output in such a way that it can be read back in. */
2346 int
2347 rl_dump_variables (count, key)
2348      int count, key;
2349 {
2350   if (rl_dispatching)
2351     fprintf (rl_outstream, "\r\n");
2352   rl_variable_dumper (rl_explicit_arg);
2353   rl_on_new_line ();
2354   return (0);
2355 }
2356
2357 /* Return non-zero if any members of ARRAY are a substring in STRING. */
2358 static int
2359 substring_member_of_array (string, array)
2360      const char *string;
2361      const char * const *array;
2362 {
2363   while (*array)
2364     {
2365       if (_rl_strindex (string, *array))
2366         return (1);
2367       array++;
2368     }
2369   return (0);
2370 }