lib/readline/bind.c

   1 /* bind.c -- key binding and startup file support for the readline library. */
   2
   3 /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library, a library for
   6    reading lines of text with interactive input and history editing.
   7
   8    The GNU Readline Library is free software; you can redistribute it
   9    and/or modify it under the terms of the GNU General Public License
  10    as published by the Free Software Foundation; either version 1, or
  11    (at your option) any later version.
  12
  13    The GNU Readline Library is distributed in the hope that it will be
  14    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  15    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    The GNU General Public License is often shipped with GNU software, and
  19    is generally kept in a file called COPYING or LICENSE.  If you do not
  20    have a copy of the license, write to the Free Software Foundation,
  21    675 Mass Ave, Cambridge, MA 02139, USA. */
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30 #include <fcntl.h>
  31 #if defined (HAVE_SYS_FILE_H)
  32 #  include <sys/file.h>
  33 #endif /* HAVE_SYS_FILE_H */
  34
  35 #if defined (HAVE_UNISTD_H)
  36 #  include <unistd.h>
  37 #endif /* HAVE_UNISTD_H */
  38
  39 #if defined (HAVE_STDLIB_H)
  40 #  include <stdlib.h>
  41 #else
  42 #  include "ansi_stdlib.h"
  43 #endif /* HAVE_STDLIB_H */
  44
  45 #include <signal.h>
  46 #include <errno.h>
  47
  48 #if !defined (errno)
  49 extern int errno;
  50 #endif /* !errno */
  51
  52 #include "posixstat.h"
  53
  54 /* System-specific feature definitions and include files. */
  55 #include "rldefs.h"
  56
  57 /* Some standard library routines. */
  58 #include "readline.h"
  59 #include "history.h"
  60
  61 #if !defined (strchr) && !defined (__STDC__)
  62 extern char *strchr (), *strrchr ();
  63 #endif /* !strchr && !__STDC__ */
  64
  65 extern int _rl_horizontal_scroll_mode;
  66 extern int _rl_mark_modified_lines;
  67 extern int _rl_bell_preference;
  68 extern int _rl_meta_flag;
  69 extern int _rl_convert_meta_chars_to_ascii;
  70 extern int _rl_output_meta_chars;
  71 extern int _rl_complete_show_all;
  72 extern int _rl_complete_mark_directories;
  73 extern int _rl_enable_keypad;
  74 #if defined (PAREN_MATCHING)
  75 extern int rl_blink_matching_paren;
  76 #endif /* PAREN_MATCHING */
  77 #if defined (VISIBLE_STATS)
  78 extern int rl_visible_stats;
  79 #endif /* VISIBLE_STATS */
  80 extern int rl_complete_with_tilde_expansion;
  81 extern int rl_completion_query_items;
  82 extern int rl_inhibit_completion;
  83 extern char *_rl_comment_begin;
  84
  85 extern int rl_explicit_arg;
  86 extern int rl_editing_mode;
  87 extern unsigned char _rl_parsing_conditionalized_out;
  88 extern Keymap _rl_keymap;
  89
  90 extern char *possible_control_prefixes[], *possible_meta_prefixes[];
  91
  92 /* Functions imported from funmap.c */
  93 extern char **rl_funmap_names ();
  94 extern int rl_add_funmap_entry ();
  95
  96 /* Functions imported from util.c */
  97 extern char *_rl_strindex ();
  98
  99 /* Functions imported from shell.c */
 100 extern char *get_env_value ();
 101
 102 /* Variables exported by this file. */
 103 Keymap rl_binding_keymap;
 104
 105 /* Forward declarations */
 106 void rl_set_keymap_from_edit_mode ();
 107
 108 static int glean_key_from_name ();
 109 static int substring_member_of_array ();
 110
 111 extern char *xmalloc (), *xrealloc ();
 112
 113 /* **************************************************************** */
 114 /*                                                                  */
 115 /*                      Binding keys                                */
 116 /*                                                                  */
 117 /* **************************************************************** */
 118
 119 /* rl_add_defun (char *name, Function *function, int key)
 120    Add NAME to the list of named functions.  Make FUNCTION be the function
 121    that gets called.  If KEY is not -1, then bind it. */
 122 int
 123 rl_add_defun (name, function, key)
 124      char *name;
 125      Function *function;
 126      int key;
 127 {
 128   if (key != -1)
 129     rl_bind_key (key, function);
 130   rl_add_funmap_entry (name, function);
 131   return 0;
 132 }
 133
 134 /* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
 135 int
 136 rl_bind_key (key, function)
 137      int key;
 138      Function *function;
 139 {
 140   if (key < 0)
 141     return (key);
 142
 143   if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
 144     {
 145       if (_rl_keymap[ESC].type == ISKMAP)
 146         {
 147           Keymap escmap;
 148
 149           escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC);
 150           key = UNMETA (key);
 151           escmap[key].type = ISFUNC;
 152           escmap[key].function = function;
 153           return (0);
 154         }
 155       return (key);
 156     }
 157
 158   _rl_keymap[key].type = ISFUNC;
 159   _rl_keymap[key].function = function;
 160   rl_binding_keymap = _rl_keymap;
 161   return (0);
 162 }
 163
 164 /* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
 165    KEY. */
 166 int
 167 rl_bind_key_in_map (key, function, map)
 168      int key;
 169      Function *function;
 170      Keymap map;
 171 {
 172   int result;
 173   Keymap oldmap;
 174
 175   oldmap = _rl_keymap;
 176   _rl_keymap = map;
 177   result = rl_bind_key (key, function);
 178   _rl_keymap = oldmap;
 179   return (result);
 180 }
 181
 182 /* Make KEY do nothing in the currently selected keymap.
 183    Returns non-zero in case of error. */
 184 int
 185 rl_unbind_key (key)
 186      int key;
 187 {
 188   return (rl_bind_key (key, (Function *)NULL));
 189 }
 190
 191 /* Make KEY do nothing in MAP.
 192    Returns non-zero in case of error. */
 193 int
 194 rl_unbind_key_in_map (key, map)
 195      int key;
 196      Keymap map;
 197 {
 198   return (rl_bind_key_in_map (key, (Function *)NULL, map));
 199 }
 200
 201 /* Bind the key sequence represented by the string KEYSEQ to
 202    FUNCTION.  This makes new keymaps as necessary.  The initial
 203    place to do bindings is in MAP. */
 204 int
 205 rl_set_key (keyseq, function, map)
 206      char *keyseq;
 207      Function *function;
 208      Keymap map;
 209 {
 210   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
 211 }
 212
 213 /* Bind the key sequence represented by the string KEYSEQ to
 214    the string of characters MACRO.  This makes new keymaps as
 215    necessary.  The initial place to do bindings is in MAP. */
 216 int
 217 rl_macro_bind (keyseq, macro, map)
 218      char *keyseq, *macro;
 219      Keymap map;
 220 {
 221   char *macro_keys;
 222   int macro_keys_len;
 223
 224   macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);
 225
 226   if (rl_translate_keyseq (macro, macro_keys, &macro_keys_len))
 227     {
 228       free (macro_keys);
 229       return -1;
 230     }
 231   rl_generic_bind (ISMACR, keyseq, macro_keys, map);
 232   return 0;
 233 }
 234
 235 /* Bind the key sequence represented by the string KEYSEQ to
 236    the arbitrary pointer DATA.  TYPE says what kind of data is
 237    pointed to by DATA, right now this can be a function (ISFUNC),
 238    a macro (ISMACR), or a keymap (ISKMAP).  This makes new keymaps
 239    as necessary.  The initial place to do bindings is in MAP. */
 240 int
 241 rl_generic_bind (type, keyseq, data, map)
 242      int type;
 243      char *keyseq, *data;
 244      Keymap map;
 245 {
 246   char *keys;
 247   int keys_len;
 248   register int i;
 249
 250   /* If no keys to bind to, exit right away. */
 251   if (!keyseq || !*keyseq)
 252     {
 253       if (type == ISMACR)
 254         free (data);
 255       return -1;
 256     }
 257
 258   keys = xmalloc (1 + (2 * strlen (keyseq)));
 259
 260   /* Translate the ASCII representation of KEYSEQ into an array of
 261      characters.  Stuff the characters into KEYS, and the length of
 262      KEYS into KEYS_LEN. */
 263   if (rl_translate_keyseq (keyseq, keys, &keys_len))
 264     {
 265       free (keys);
 266       return -1;
 267     }
 268
 269   /* Bind keys, making new keymaps as necessary. */
 270   for (i = 0; i < keys_len; i++)
 271     {
 272       int ic = (int) ((unsigned char)keys[i]);
 273
 274       if (_rl_convert_meta_chars_to_ascii && META_CHAR (ic))
 275         {
 276           ic = UNMETA (ic);
 277           if (map[ESC].type == ISKMAP)
 278             map = FUNCTION_TO_KEYMAP (map, ESC);
 279         }
 280
 281       if ((i + 1) < keys_len)
 282         {
 283           if (map[ic].type != ISKMAP)
 284             {
 285               if (map[ic].type == ISMACR)
 286                 free ((char *)map[ic].function);
 287
 288               map[ic].type = ISKMAP;
 289               map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
 290             }
 291           map = FUNCTION_TO_KEYMAP (map, ic);
 292         }
 293       else
 294         {
 295           if (map[ic].type == ISMACR)
 296             free ((char *)map[ic].function);
 297
 298           map[ic].function = KEYMAP_TO_FUNCTION (data);
 299           map[ic].type = type;
 300         }
 301
 302       rl_binding_keymap = map;
 303     }
 304   free (keys);
 305   return 0;
 306 }
 307
 308 /* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
 309    an array of characters.  LEN gets the final length of ARRAY.  Return
 310    non-zero if there was an error parsing SEQ. */
 311 int
 312 rl_translate_keyseq (seq, array, len)
 313      char *seq, *array;
 314      int *len;
 315 {
 316   register int i, c, l;
 317
 318   for (i = l = 0; c = seq[i]; i++)
 319     {
 320       if (c == '\\')
 321         {
 322           c = seq[++i];
 323
 324           if (c == 0)
 325             break;
 326
 327           if (((c == 'C' || c == 'M') && seq[i + 1] == '-') || (c == 'e'))
 328             {
 329               /* Handle special case of backwards define. */
 330               if (strncmp (&seq[i], "C-\\M-", 5) == 0)
 331                 {
 332                   array[l++] = ESC;
 333                   i += 5;
 334                   array[l++] = CTRL (_rl_to_upper (seq[i]));
 335                   if (!seq[i])
 336                     i--;
 337                   continue;
 338                 }
 339
 340               switch (c)
 341                 {
 342                 case 'M':
 343                   i++;
 344                   array[l++] = ESC;     /* XXX */
 345                   break;
 346
 347                 case 'C':
 348                   i += 2;
 349                   /* Special hack for C-?... */
 350                   array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
 351                   break;
 352
 353                 case 'e':
 354                   array[l++] = ESC;
 355                 }
 356
 357               continue;
 358             }
 359         }
 360       array[l++] = c;
 361     }
 362
 363   *len = l;
 364   array[l] = '\0';
 365   return (0);
 366 }
 367
 368 char *
 369 rl_untranslate_keyseq (seq)
 370      int seq;
 371 {
 372   static char kseq[16];
 373   int i, c;
 374
 375   i = 0;
 376   c = seq;
 377   if (META_CHAR (c))
 378     {
 379       kseq[i++] = '\\';
 380       kseq[i++] = 'M';
 381       kseq[i++] = '-';
 382       c = UNMETA (c);
 383     }
 384   else if (CTRL_CHAR (c))
 385     {
 386       kseq[i++] = '\\';
 387       kseq[i++] = 'C';
 388       kseq[i++] = '-';
 389       c = _rl_to_lower (UNCTRL (c));
 390     }
 391   else if (c == RUBOUT)
 392     {
 393       kseq[i++] = '\\';
 394       kseq[i++] = 'C';
 395       kseq[i++] = '-';
 396       c = '?';
 397     }
 398
 399   if (c == ESC)
 400     {
 401       kseq[i++] = '\\';
 402       c = 'e';
 403     }
 404   else if (c == '\\' || c == '"')
 405     {
 406       kseq[i++] = '\\';
 407     }
 408
 409   kseq[i++] = (unsigned char) c;
 410   kseq[i] = '\0';
 411   return kseq;
 412 }
 413
 414 static char *
 415 _rl_untranslate_macro_value (seq)
 416      char *seq;
 417 {
 418   char *ret, *r, *s;
 419   int c;
 420
 421   r = ret = xmalloc (7 * strlen (seq) + 1);
 422   for (s = seq; *s; s++)
 423     {
 424       c = *s;
 425       if (META_CHAR (c))
 426         {
 427           *r++ = '\\';
 428           *r++ = 'M';
 429           *r++ = '-';
 430           c = UNMETA (c);
 431         }
 432       else if (CTRL_CHAR (c) && c != ESC)
 433         {
 434           *r++ = '\\';
 435           *r++ = 'C';
 436           *r++ = '-';
 437           c = _rl_to_lower (UNCTRL (c));
 438         }
 439       else if (c == RUBOUT)
 440         {
 441           *r++ = '\\';
 442           *r++ = 'C';
 443           *r++ = '-';
 444           c = '?';
 445         }
 446
 447       if (c == ESC)
 448         {
 449           *r++ = '\\';
 450           c = 'e';
 451         }
 452       else if (c == '\\' || c == '"')
 453         *r++ = '\\';
 454
 455       *r++ = (unsigned char)c;
 456     }
 457   *r = '\0';
 458   return ret;
 459 }
 460
 461 /* Return a pointer to the function that STRING represents.
 462    If STRING doesn't have a matching function, then a NULL pointer
 463    is returned. */
 464 Function *
 465 rl_named_function (string)
 466      char *string;
 467 {
 468   register int i;
 469
 470   rl_initialize_funmap ();
 471
 472   for (i = 0; funmap[i]; i++)
 473     if (_rl_stricmp (funmap[i]->name, string) == 0)
 474       return (funmap[i]->function);
 475   return ((Function *)NULL);
 476 }
 477
 478 /* Return the function (or macro) definition which would be invoked via
 479    KEYSEQ if executed in MAP.  If MAP is NULL, then the current keymap is
 480    used.  TYPE, if non-NULL, is a pointer to an int which will receive the
 481    type of the object pointed to.  One of ISFUNC (function), ISKMAP (keymap),
 482    or ISMACR (macro). */
 483 Function *
 484 rl_function_of_keyseq (keyseq, map, type)
 485      char *keyseq;
 486      Keymap map;
 487      int *type;
 488 {
 489   register int i;
 490
 491   if (!map)
 492     map = _rl_keymap;
 493
 494   for (i = 0; keyseq && keyseq[i]; i++)
 495     {
 496       int ic = keyseq[i];
 497
 498       if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
 499         {
 500           if (map[ESC].type != ISKMAP)
 501             {
 502               if (type)
 503                 *type = map[ESC].type;
 504
 505               return (map[ESC].function);
 506             }
 507           else
 508             {
 509               map = FUNCTION_TO_KEYMAP (map, ESC);
 510               ic = UNMETA (ic);
 511             }
 512         }
 513
 514       if (map[ic].type == ISKMAP)
 515         {
 516           /* If this is the last key in the key sequence, return the
 517              map. */
 518           if (!keyseq[i + 1])
 519             {
 520               if (type)
 521                 *type = ISKMAP;
 522
 523               return (map[ic].function);
 524             }
 525           else
 526             map = FUNCTION_TO_KEYMAP (map, ic);
 527         }
 528       else
 529         {
 530           if (type)
 531             *type = map[ic].type;
 532
 533           return (map[ic].function);
 534         }
 535     }
 536   return ((Function *) NULL);
 537 }
 538
 539 /* The last key bindings file read. */
 540 static char *last_readline_init_file = (char *)NULL;
 541
 542 /* The file we're currently reading key bindings from. */
 543 static char *current_readline_init_file;
 544 static int current_readline_init_lineno;
 545
 546 /* Re-read the current keybindings file. */
 547 int
 548 rl_re_read_init_file (count, ignore)
 549      int count, ignore;
 550 {
 551   int r;
 552   r = rl_read_init_file ((char *)NULL);
 553   rl_set_keymap_from_edit_mode ();
 554   return r;
 555 }
 556
 557 /* Do key bindings from a file.  If FILENAME is NULL it defaults
 558    to the first non-null filename from this list:
 559      1. the filename used for the previous call
 560      2. the value of the shell variable `INPUTRC'
 561      3. ~/.inputrc
 562    If the file existed and could be opened and read, 0 is returned,
 563    otherwise errno is returned. */
 564 int
 565 rl_read_init_file (filename)
 566      char *filename;
 567 {
 568   register int i;
 569   char *buffer, *openname, *line, *end;
 570   struct stat finfo;
 571   int file;
 572
 573   /* Default the filename. */
 574   if (filename == 0)
 575     {
 576       filename = last_readline_init_file;
 577       if (filename == 0)
 578         filename = get_env_value ("INPUTRC");
 579       if (filename == 0)
 580         filename = DEFAULT_INPUTRC;
 581     }
 582
 583   if (*filename == 0)
 584     filename = DEFAULT_INPUTRC;
 585
 586   current_readline_init_file = filename;
 587   openname = tilde_expand (filename);
 588
 589   if ((stat (openname, &finfo) < 0) ||
 590       (file = open (openname, O_RDONLY, 0666)) < 0)
 591     {
 592       free (openname);
 593       return (errno);
 594     }
 595   else
 596     free (openname);
 597
 598   if (filename != last_readline_init_file)
 599     {
 600       if (last_readline_init_file)
 601         free (last_readline_init_file);
 602
 603       last_readline_init_file = savestring (filename);
 604     }
 605
 606   /* Read the file into BUFFER. */
 607   buffer = (char *)xmalloc ((int)finfo.st_size + 1);
 608   i = read (file, buffer, finfo.st_size);
 609   close (file);
 610
 611   if (i != finfo.st_size)
 612     return (errno);
 613
 614   /* Loop over the lines in the file.  Lines that start with `#' are
 615      comments; all other lines are commands for readline initialization. */
 616   current_readline_init_lineno = 1;
 617   line = buffer;
 618   end = buffer + finfo.st_size;
 619   while (line < end)
 620     {
 621       /* Find the end of this line. */
 622       for (i = 0; line + i != end && line[i] != '\n'; i++);
 623
 624       /* Mark end of line. */
 625       line[i] = '\0';
 626
 627       /* Skip leading whitespace. */
 628       while (*line && whitespace (*line))
 629         {
 630           line++;
 631           i--;
 632         }
 633
 634       /* If the line is not a comment, then parse it. */
 635       if (*line && *line != '#')
 636         rl_parse_and_bind (line);
 637
 638       /* Move to the next line. */
 639       line += i + 1;
 640       current_readline_init_lineno++;
 641     }
 642   free (buffer);
 643   return (0);
 644 }
 645
 646 static void
 647 _rl_init_file_error (msg)
 648      char *msg;
 649 {
 650   fprintf (stderr, "readline: %s: line %d: %s\n", current_readline_init_file,
 651                    current_readline_init_lineno,
 652                    msg);
 653 }
 654
 655 /* **************************************************************** */
 656 /*                                                                  */
 657 /*                      Parser Directives                           */
 658 /*                                                                  */
 659 /* **************************************************************** */
 660
 661 /* Conditionals. */
 662
 663 /* Calling programs set this to have their argv[0]. */
 664 char *rl_readline_name = "other";
 665
 666 /* Stack of previous values of parsing_conditionalized_out. */
 667 static unsigned char *if_stack = (unsigned char *)NULL;
 668 static int if_stack_depth;
 669 static int if_stack_size;
 670
 671 /* Push _rl_parsing_conditionalized_out, and set parser state based
 672    on ARGS. */
 673 static int
 674 parser_if (args)
 675      char *args;
 676 {
 677   register int i;
 678
 679   /* Push parser state. */
 680   if (if_stack_depth + 1 >= if_stack_size)
 681     {
 682       if (!if_stack)
 683         if_stack = (unsigned char *)xmalloc (if_stack_size = 20);
 684       else
 685         if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20);
 686     }
 687   if_stack[if_stack_depth++] = _rl_parsing_conditionalized_out;
 688
 689   /* If parsing is turned off, then nothing can turn it back on except
 690      for finding the matching endif.  In that case, return right now. */
 691   if (_rl_parsing_conditionalized_out)
 692     return 0;
 693
 694   /* Isolate first argument. */
 695   for (i = 0; args[i] && !whitespace (args[i]); i++);
 696
 697   if (args[i])
 698     args[i++] = '\0';
 699
 700   /* Handle "if term=foo" and "if mode=emacs" constructs.  If this
 701      isn't term=foo, or mode=emacs, then check to see if the first
 702      word in ARGS is the same as the value stored in rl_readline_name. */
 703   if (rl_terminal_name && _rl_strnicmp (args, "term=", 5) == 0)
 704     {
 705       char *tem, *tname;
 706
 707       /* Terminals like "aaa-60" are equivalent to "aaa". */
 708       tname = savestring (rl_terminal_name);
 709       tem = strchr (tname, '-');
 710       if (tem)
 711         *tem = '\0';
 712
 713       /* Test the `long' and `short' forms of the terminal name so that
 714          if someone has a `sun-cmd' and does not want to have bindings
 715          that will be executed if the terminal is a `sun', they can put
 716          `$if term=sun-cmd' into their .inputrc. */
 717       _rl_parsing_conditionalized_out = _rl_stricmp (args + 5, tname) &&
 718                                         _rl_stricmp (args + 5, rl_terminal_name);
 719       free (tname);
 720     }
 721 #if defined (VI_MODE)
 722   else if (_rl_strnicmp (args, "mode=", 5) == 0)
 723     {
 724       int mode;
 725
 726       if (_rl_stricmp (args + 5, "emacs") == 0)
 727         mode = emacs_mode;
 728       else if (_rl_stricmp (args + 5, "vi") == 0)
 729         mode = vi_mode;
 730       else
 731         mode = no_mode;
 732
 733       _rl_parsing_conditionalized_out = mode != rl_editing_mode;
 734     }
 735 #endif /* VI_MODE */
 736   /* Check to see if the first word in ARGS is the same as the
 737      value stored in rl_readline_name. */
 738   else if (_rl_stricmp (args, rl_readline_name) == 0)
 739     _rl_parsing_conditionalized_out = 0;
 740   else
 741     _rl_parsing_conditionalized_out = 1;
 742   return 0;
 743 }
 744
 745 /* Invert the current parser state if there is anything on the stack. */
 746 static int
 747 parser_else (args)
 748      char *args;
 749 {
 750   register int i;
 751
 752   if (!if_stack_depth)
 753     {
 754       /* Error message? */
 755       return 0;
 756     }
 757
 758   /* Check the previous (n - 1) levels of the stack to make sure that
 759      we haven't previously turned off parsing. */
 760   for (i = 0; i < if_stack_depth - 1; i++)
 761     if (if_stack[i] == 1)
 762       return 0;
 763
 764   /* Invert the state of parsing if at top level. */
 765   _rl_parsing_conditionalized_out = !_rl_parsing_conditionalized_out;
 766   return 0;
 767 }
 768
 769 /* Terminate a conditional, popping the value of
 770    _rl_parsing_conditionalized_out from the stack. */
 771 static int
 772 parser_endif (args)
 773      char *args;
 774 {
 775   if (if_stack_depth)
 776     _rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
 777   else
 778     {
 779       /* *** What, no error message? *** */
 780     }
 781   return 0;
 782 }
 783
 784 /* Associate textual names with actual functions. */
 785 static struct {
 786   char *name;
 787   Function *function;
 788 } parser_directives [] = {
 789   { "if", parser_if },
 790   { "endif", parser_endif },
 791   { "else", parser_else },
 792   { (char *)0x0, (Function *)0x0 }
 793 };
 794
 795 /* Handle a parser directive.  STATEMENT is the line of the directive
 796    without any leading `$'. */
 797 static int
 798 handle_parser_directive (statement)
 799      char *statement;
 800 {
 801   register int i;
 802   char *directive, *args;
 803
 804   /* Isolate the actual directive. */
 805
 806   /* Skip whitespace. */
 807   for (i = 0; whitespace (statement[i]); i++);
 808
 809   directive = &statement[i];
 810
 811   for (; statement[i] && !whitespace (statement[i]); i++);
 812
 813   if (statement[i])
 814     statement[i++] = '\0';
 815
 816   for (; statement[i] && whitespace (statement[i]); i++);
 817
 818   args = &statement[i];
 819
 820   /* Lookup the command, and act on it. */
 821   for (i = 0; parser_directives[i].name; i++)
 822     if (_rl_stricmp (directive, parser_directives[i].name) == 0)
 823       {
 824         (*parser_directives[i].function) (args);
 825         return (0);
 826       }
 827
 828   /* *** Should an error message be output? */
 829   return (1);
 830 }
 831
 832 /* Read the binding command from STRING and perform it.
 833    A key binding command looks like: Keyname: function-name\0,
 834    a variable binding command looks like: set variable value.
 835    A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
 836 int
 837 rl_parse_and_bind (string)
 838      char *string;
 839 {
 840   char *funname, *kname;
 841   register int c, i;
 842   int key, equivalency;
 843
 844   while (string && whitespace (*string))
 845     string++;
 846
 847   if (!string || !*string || *string == '#')
 848     return 0;
 849
 850   /* If this is a parser directive, act on it. */
 851   if (*string == '$')
 852     {
 853       handle_parser_directive (&string[1]);
 854       return 0;
 855     }
 856
 857   /* If we aren't supposed to be parsing right now, then we're done. */
 858   if (_rl_parsing_conditionalized_out)
 859     return 0;
 860
 861   i = 0;
 862   /* If this keyname is a complex key expression surrounded by quotes,
 863      advance to after the matching close quote.  This code allows the
 864      backslash to quote characters in the key expression. */
 865   if (*string == '"')
 866     {
 867       int passc = 0;
 868
 869       for (i = 1; c = string[i]; i++)
 870         {
 871           if (passc)
 872             {
 873               passc = 0;
 874               continue;
 875             }
 876
 877           if (c == '\\')
 878             {
 879               passc++;
 880               continue;
 881             }
 882
 883           if (c == '"')
 884             break;
 885         }
 886       /* If we didn't find a closing quote, abort the line. */
 887       if (string[i] == '\0')
 888         {
 889           _rl_init_file_error ("no closing `\"' in key binding");
 890           return 1;
 891         }
 892     }
 893
 894   /* Advance to the colon (:) or whitespace which separates the two objects. */
 895   for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );
 896
 897   equivalency = (c == ':' && string[i + 1] == '=');
 898
 899   /* Mark the end of the command (or keyname). */
 900   if (string[i])
 901     string[i++] = '\0';
 902
 903   /* If doing assignment, skip the '=' sign as well. */
 904   if (equivalency)
 905     string[i++] = '\0';
 906
 907   /* If this is a command to set a variable, then do that. */
 908   if (_rl_stricmp (string, "set") == 0)
 909     {
 910       char *var = string + i;
 911       char *value;
 912
 913       /* Make VAR point to start of variable name. */
 914       while (*var && whitespace (*var)) var++;
 915
 916       /* Make value point to start of value string. */
 917       value = var;
 918       while (*value && !whitespace (*value)) value++;
 919       if (*value)
 920         *value++ = '\0';
 921       while (*value && whitespace (*value)) value++;
 922
 923       rl_variable_bind (var, value);
 924       return 0;
 925     }
 926
 927   /* Skip any whitespace between keyname and funname. */
 928   for (; string[i] && whitespace (string[i]); i++);
 929   funname = &string[i];
 930
 931   /* Now isolate funname.
 932      For straight function names just look for whitespace, since
 933      that will signify the end of the string.  But this could be a
 934      macro definition.  In that case, the string is quoted, so skip
 935      to the matching delimiter.  We allow the backslash to quote the
 936      delimiter characters in the macro body. */
 937   /* This code exists to allow whitespace in macro expansions, which
 938      would otherwise be gobbled up by the next `for' loop.*/
 939   /* XXX - it may be desirable to allow backslash quoting only if " is
 940      the quoted string delimiter, like the shell. */
 941   if (*funname == '\'' || *funname == '"')
 942     {
 943       int delimiter = string[i++];
 944       int passc = 0;
 945
 946       for (; c = string[i]; i++)
 947         {
 948           if (passc)
 949             {
 950               passc = 0;
 951               continue;
 952             }
 953
 954           if (c == '\\')
 955             {
 956               passc = 1;
 957               continue;
 958             }
 959
 960           if (c == delimiter)
 961             break;
 962         }
 963       if (c)
 964         i++;
 965     }
 966
 967   /* Advance to the end of the string.  */
 968   for (; string[i] && !whitespace (string[i]); i++);
 969
 970   /* No extra whitespace at the end of the string. */
 971   string[i] = '\0';
 972
 973   /* Handle equivalency bindings here.  Make the left-hand side be exactly
 974      whatever the right-hand evaluates to, including keymaps. */
 975   if (equivalency)
 976     {
 977       return 0;
 978     }
 979
 980   /* If this is a new-style key-binding, then do the binding with
 981      rl_set_key ().  Otherwise, let the older code deal with it. */
 982   if (*string == '"')
 983     {
 984       char *seq = xmalloc (1 + strlen (string));
 985       register int j, k = 0;
 986       int passc = 0;
 987
 988       for (j = 1; string[j]; j++)
 989         {
 990           /* Allow backslash to quote characters, but leave them in place.
 991              This allows a string to end with a backslash quoting another
 992              backslash, or with a backslash quoting a double quote.  The
 993              backslashes are left in place for rl_translate_keyseq (). */
 994           if (passc || (string[j] == '\\'))
 995             {
 996               seq[k++] = string[j];
 997               passc = !passc;
 998               continue;
 999             }
1000
1001           if (string[j] == '"')
1002             break;
1003
1004           seq[k++] = string[j];
1005         }
1006       seq[k] = '\0';
1007
1008       /* Binding macro? */
1009       if (*funname == '\'' || *funname == '"')
1010         {
1011           j = strlen (funname);
1012
1013           /* Remove the delimiting quotes from each end of FUNNAME. */
1014           if (j && funname[j - 1] == *funname)
1015             funname[j - 1] = '\0';
1016
1017           rl_macro_bind (seq, &funname[1], _rl_keymap);
1018         }
1019       else
1020         rl_set_key (seq, rl_named_function (funname), _rl_keymap);
1021
1022       free (seq);
1023       return 0;
1024     }
1025
1026   /* Get the actual character we want to deal with. */
1027   kname = strrchr (string, '-');
1028   if (!kname)
1029     kname = string;
1030   else
1031     kname++;
1032
1033   key = glean_key_from_name (kname);
1034
1035   /* Add in control and meta bits. */
1036   if (substring_member_of_array (string, possible_control_prefixes))
1037     key = CTRL (_rl_to_upper (key));
1038
1039   if (substring_member_of_array (string, possible_meta_prefixes))
1040     key = META (key);
1041
1042   /* Temporary.  Handle old-style keyname with macro-binding. */
1043   if (*funname == '\'' || *funname == '"')
1044     {
1045       unsigned char useq[2];
1046       int fl = strlen (funname);
1047
1048       useq[0] = key; useq[1] = '\0';
1049       if (fl && funname[fl - 1] == *funname)
1050         funname[fl - 1] = '\0';
1051
1052       rl_macro_bind (useq, &funname[1], _rl_keymap);
1053     }
1054 #if defined (PREFIX_META_HACK)
1055   /* Ugly, but working hack to keep prefix-meta around. */
1056   else if (_rl_stricmp (funname, "prefix-meta") == 0)
1057     {
1058       char seq[2];
1059
1060       seq[0] = key;
1061       seq[1] = '\0';
1062       rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, _rl_keymap);
1063     }
1064 #endif /* PREFIX_META_HACK */
1065   else
1066     rl_bind_key (key, rl_named_function (funname));
1067   return 0;
1068 }
1069
1070 /* Simple structure for boolean readline variables (i.e., those that can
1071    have one of two values; either "On" or 1 for truth, or "Off" or 0 for
1072    false. */
1073
1074 static struct {
1075   char *name;
1076   int *value;
1077 } boolean_varlist [] = {
1078 #if defined (PAREN_MATCHING)
1079   { "blink-matching-paren",     &rl_blink_matching_paren },
1080 #endif
1081   { "convert-meta",             &_rl_convert_meta_chars_to_ascii },
1082   { "disable-completion",       &rl_inhibit_completion },
1083   { "enable-keypad",            &_rl_enable_keypad },
1084   { "expand-tilde",             &rl_complete_with_tilde_expansion },
1085   { "horizontal-scroll-mode",   &_rl_horizontal_scroll_mode },
1086   { "input-meta",               &_rl_meta_flag },
1087   { "mark-directories",         &_rl_complete_mark_directories },
1088   { "mark-modified-lines",      &_rl_mark_modified_lines },
1089   { "meta-flag",                &_rl_meta_flag },
1090   { "output-meta",              &_rl_output_meta_chars },
1091   { "show-all-if-ambiguous",    &_rl_complete_show_all },
1092 #if defined (VISIBLE_STATS)
1093   { "visible-stats",            &rl_visible_stats },
1094 #endif /* VISIBLE_STATS */
1095   { (char *)NULL, (int *)NULL }
1096 };
1097
1098 int
1099 rl_variable_bind (name, value)
1100      char *name, *value;
1101 {
1102   register int i;
1103
1104   /* Check for simple variables first. */
1105   for (i = 0; boolean_varlist[i].name; i++)
1106     {
1107       if (_rl_stricmp (name, boolean_varlist[i].name) == 0)
1108         {
1109           /* A variable is TRUE if the "value" is "on", "1" or "". */
1110           *boolean_varlist[i].value = *value == 0 ||
1111                                       _rl_stricmp (value, "on") == 0 ||
1112                                       (value[0] == '1' && value[1] == '\0');
1113           return 0;
1114         }
1115     }
1116
1117   /* Not a boolean variable, so check for specials. */
1118
1119   /* Editing mode change? */
1120   if (_rl_stricmp (name, "editing-mode") == 0)
1121     {
1122       if (_rl_strnicmp (value, "vi", 2) == 0)
1123         {
1124 #if defined (VI_MODE)
1125           _rl_keymap = vi_insertion_keymap;
1126           rl_editing_mode = vi_mode;
1127 #endif /* VI_MODE */
1128         }
1129       else if (_rl_strnicmp (value, "emacs", 5) == 0)
1130         {
1131           _rl_keymap = emacs_standard_keymap;
1132           rl_editing_mode = emacs_mode;
1133         }
1134     }
1135
1136   /* Comment string change? */
1137   else if (_rl_stricmp (name, "comment-begin") == 0)
1138     {
1139       if (*value)
1140         {
1141           if (_rl_comment_begin)
1142             free (_rl_comment_begin);
1143
1144           _rl_comment_begin = savestring (value);
1145         }
1146     }
1147   else if (_rl_stricmp (name, "completion-query-items") == 0)
1148     {
1149       int nval = 100;
1150       if (*value)
1151         {
1152           nval = atoi (value);
1153           if (nval < 0)
1154             nval = 0;
1155         }
1156       rl_completion_query_items = nval;
1157     }
1158   else if (_rl_stricmp (name, "keymap") == 0)
1159     {
1160       Keymap kmap;
1161       kmap = rl_get_keymap_by_name (value);
1162       if (kmap)
1163         rl_set_keymap (kmap);
1164     }
1165   else if (_rl_stricmp (name, "bell-style") == 0)
1166     {
1167       if (!*value)
1168         _rl_bell_preference = AUDIBLE_BELL;
1169       else
1170         {
1171           if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
1172             _rl_bell_preference = NO_BELL;
1173           else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
1174             _rl_bell_preference = AUDIBLE_BELL;
1175           else if (_rl_stricmp (value, "visible") == 0)
1176             _rl_bell_preference = VISIBLE_BELL;
1177         }
1178     }
1179   else if (_rl_stricmp (name, "prefer-visible-bell") == 0)
1180     {
1181       /* Backwards compatibility. */
1182       if (*value && (_rl_stricmp (value, "on") == 0 ||
1183                      (*value == '1' && !value[1])))
1184         _rl_bell_preference = VISIBLE_BELL;
1185       else
1186         _rl_bell_preference = AUDIBLE_BELL;
1187     }
1188
1189   return 0;
1190 }
1191
1192 /* Return the character which matches NAME.
1193    For example, `Space' returns ' '. */
1194
1195 typedef struct {
1196   char *name;
1197   int value;
1198 } assoc_list;
1199
1200 static assoc_list name_key_alist[] = {
1201   { "DEL", 0x7f },
1202   { "ESC", '\033' },
1203   { "Escape", '\033' },
1204   { "LFD", '\n' },
1205   { "Newline", '\n' },
1206   { "RET", '\r' },
1207   { "Return", '\r' },
1208   { "Rubout", 0x7f },
1209   { "SPC", ' ' },
1210   { "Space", ' ' },
1211   { "Tab", 0x09 },
1212   { (char *)0x0, 0 }
1213 };
1214
1215 static int
1216 glean_key_from_name (name)
1217      char *name;
1218 {
1219   register int i;
1220
1221   for (i = 0; name_key_alist[i].name; i++)
1222     if (_rl_stricmp (name, name_key_alist[i].name) == 0)
1223       return (name_key_alist[i].value);
1224
1225   return (*(unsigned char *)name);      /* XXX was return (*name) */
1226 }
1227
1228 /* Auxiliary functions to manage keymaps. */
1229 static struct {
1230   char *name;
1231   Keymap map;
1232 } keymap_names[] = {
1233   { "emacs", emacs_standard_keymap },
1234   { "emacs-standard", emacs_standard_keymap },
1235   { "emacs-meta", emacs_meta_keymap },
1236   { "emacs-ctlx", emacs_ctlx_keymap },
1237 #if defined (VI_MODE)
1238   { "vi", vi_movement_keymap },
1239   { "vi-move", vi_movement_keymap },
1240   { "vi-command", vi_movement_keymap },
1241   { "vi-insert", vi_insertion_keymap },
1242 #endif /* VI_MODE */
1243   { (char *)0x0, (Keymap)0x0 }
1244 };
1245
1246 Keymap
1247 rl_get_keymap_by_name (name)
1248      char *name;
1249 {
1250   register int i;
1251
1252   for (i = 0; keymap_names[i].name; i++)
1253     if (strcmp (name, keymap_names[i].name) == 0)
1254       return (keymap_names[i].map);
1255   return ((Keymap) NULL);
1256 }
1257
1258 char *
1259 rl_get_keymap_name (map)
1260      Keymap map;
1261 {
1262   register int i;
1263   for (i = 0; keymap_names[i].name; i++)
1264     if (map == keymap_names[i].map)
1265       return (keymap_names[i].name);
1266   return ((char *)NULL);
1267 }
1268
1269 void
1270 rl_set_keymap (map)
1271      Keymap map;
1272 {
1273   if (map)
1274     _rl_keymap = map;
1275 }
1276
1277 Keymap
1278 rl_get_keymap ()
1279 {
1280   return (_rl_keymap);
1281 }
1282
1283 void
1284 rl_set_keymap_from_edit_mode ()
1285 {
1286   if (rl_editing_mode == emacs_mode)
1287     _rl_keymap = emacs_standard_keymap;
1288 #if defined (VI_MODE)
1289   else if (rl_editing_mode == vi_mode)
1290     _rl_keymap = vi_insertion_keymap;
1291 #endif /* VI_MODE */
1292 }
1293
1294 char *
1295 rl_get_keymap_name_from_edit_mode ()
1296 {
1297   if (rl_editing_mode == emacs_mode)
1298     return "emacs";
1299 #if defined (VI_MODE)
1300   else if (rl_editing_mode == vi_mode)
1301     return "vi";
1302 #endif /* VI_MODE */
1303   else
1304     return "none";
1305 }
1306
1307 /* **************************************************************** */
1308 /*                                                                  */
1309 /*                Key Binding and Function Information              */
1310 /*                                                                  */
1311 /* **************************************************************** */
1312
1313 /* Each of the following functions produces information about the
1314    state of keybindings and functions known to Readline.  The info
1315    is always printed to rl_outstream, and in such a way that it can
1316    be read back in (i.e., passed to rl_parse_and_bind (). */
1317
1318 /* Print the names of functions known to Readline. */
1319 void
1320 rl_list_funmap_names ()
1321 {
1322   register int i;
1323   char **funmap_names;
1324
1325   funmap_names = rl_funmap_names ();
1326
1327   if (!funmap_names)
1328     return;
1329
1330   for (i = 0; funmap_names[i]; i++)
1331     fprintf (rl_outstream, "%s\n", funmap_names[i]);
1332
1333   free (funmap_names);
1334 }
1335
1336 static char *
1337 _rl_get_keyname (key)
1338      int key;
1339 {
1340   char *keyname;
1341   int i, c;
1342
1343   keyname = (char *)xmalloc (8);
1344
1345   c = key;
1346   /* Since this is going to be used to write out keysequence-function
1347      pairs for possible inclusion in an inputrc file, we don't want to
1348      do any special meta processing on KEY. */
1349
1350 #if 0
1351   /* We might want to do this, but the old version of the code did not. */
1352
1353   /* If this is an escape character, we don't want to do any more processing.
1354      Just add the special ESC key sequence and return. */
1355   if (c == ESC)
1356     {
1357       keyseq[0] = '\\';
1358       keyseq[1] = 'e';
1359       keyseq[2] = '\0';
1360       return keyseq;
1361     }
1362 #endif
1363
1364   /* RUBOUT is translated directly into \C-? */
1365   if (key == RUBOUT)
1366     {
1367       keyname[0] = '\\';
1368       keyname[1] = 'C';
1369       keyname[2] = '-';
1370       keyname[3] = '?';
1371       keyname[4] = '\0';
1372       return keyname;
1373     }
1374
1375   i = 0;
1376   /* Now add special prefixes needed for control characters.  This can
1377      potentially change C. */
1378   if (CTRL_CHAR (c))
1379     {
1380       keyname[i++] = '\\';
1381       keyname[i++] = 'C';
1382       keyname[i++] = '-';
1383       c = _rl_to_lower (UNCTRL (c));
1384     }
1385
1386   /* Now, if the character needs to be quoted with a backslash, do that. */
1387   if (c == '\\' || c == '"')
1388     keyname[i++] = '\\';
1389
1390   /* Now add the key, terminate the string, and return it. */
1391   keyname[i++] = (char) c;
1392   keyname[i] = '\0';
1393
1394   return keyname;
1395 }
1396
1397 /* Return a NULL terminated array of strings which represent the key
1398    sequences that are used to invoke FUNCTION in MAP. */
1399 char **
1400 rl_invoking_keyseqs_in_map (function, map)
1401      Function *function;
1402      Keymap map;
1403 {
1404   register int key;
1405   char **result;
1406   int result_index, result_size;
1407
1408   result = (char **)NULL;
1409   result_index = result_size = 0;
1410
1411   for (key = 0; key < KEYMAP_SIZE; key++)
1412     {
1413       switch (map[key].type)
1414         {
1415         case ISMACR:
1416           /* Macros match, if, and only if, the pointers are identical.
1417              Thus, they are treated exactly like functions in here. */
1418         case ISFUNC:
1419           /* If the function in the keymap is the one we are looking for,
1420              then add the current KEY to the list of invoking keys. */
1421           if (map[key].function == function)
1422             {
1423               char *keyname;
1424
1425               keyname = _rl_get_keyname (key);
1426
1427               if (result_index + 2 > result_size)
1428                 {
1429                   result_size += 10;
1430                   result = (char **) xrealloc (result, result_size * sizeof (char *));
1431                 }
1432
1433               result[result_index++] = keyname;
1434               result[result_index] = (char *)NULL;
1435             }
1436           break;
1437
1438         case ISKMAP:
1439           {
1440             char **seqs;
1441             register int i;
1442
1443             /* Find the list of keyseqs in this map which have FUNCTION as
1444                their target.  Add the key sequences found to RESULT. */
1445             if (map[key].function)
1446               seqs =
1447                 rl_invoking_keyseqs_in_map (function, FUNCTION_TO_KEYMAP (map, key));
1448             else
1449               break;
1450
1451             if (seqs == 0)
1452               break;
1453
1454             for (i = 0; seqs[i]; i++)
1455               {
1456                 char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
1457
1458                 if (key == ESC)
1459                   sprintf (keyname, "\\e");
1460                 else if (CTRL_CHAR (key))
1461                   sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
1462                 else if (key == RUBOUT)
1463                   sprintf (keyname, "\\C-?");
1464                 else if (key == '\\' || key == '"')
1465                   {
1466                     keyname[0] = '\\';
1467                     keyname[1] = (char) key;
1468                     keyname[2] = '\0';
1469                   }
1470                 else
1471                   {
1472                     keyname[0] = (char) key;
1473                     keyname[1] = '\0';
1474                   }
1475
1476                 strcat (keyname, seqs[i]);
1477                 free (seqs[i]);
1478
1479                 if (result_index + 2 > result_size)
1480                   {
1481                     result_size += 10;
1482                     result = (char **) xrealloc (result, result_size * sizeof (char *));
1483                   }
1484
1485                 result[result_index++] = keyname;
1486                 result[result_index] = (char *)NULL;
1487               }
1488
1489             free (seqs);
1490           }
1491           break;
1492         }
1493     }
1494   return (result);
1495 }
1496
1497 /* Return a NULL terminated array of strings which represent the key
1498    sequences that can be used to invoke FUNCTION using the current keymap. */
1499 char **
1500 rl_invoking_keyseqs (function)
1501      Function *function;
1502 {
1503   return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
1504 }
1505
1506 /* Print all of the functions and their bindings to rl_outstream.  If
1507    PRINT_READABLY is non-zero, then print the output in such a way
1508    that it can be read back in. */
1509 void
1510 rl_function_dumper (print_readably)
1511      int print_readably;
1512 {
1513   register int i;
1514   char **names;
1515   char *name;
1516
1517   names = rl_funmap_names ();
1518
1519   fprintf (rl_outstream, "\n");
1520
1521   for (i = 0; name = names[i]; i++)
1522     {
1523       Function *function;
1524       char **invokers;
1525
1526       function = rl_named_function (name);
1527       invokers = rl_invoking_keyseqs_in_map (function, _rl_keymap);
1528
1529       if (print_readably)
1530         {
1531           if (!invokers)
1532             fprintf (rl_outstream, "# %s (not bound)\n", name);
1533           else
1534             {
1535               register int j;
1536
1537               for (j = 0; invokers[j]; j++)
1538                 {
1539                   fprintf (rl_outstream, "\"%s\": %s\n",
1540                            invokers[j], name);
1541                   free (invokers[j]);
1542                 }
1543
1544               free (invokers);
1545             }
1546         }
1547       else
1548         {
1549           if (!invokers)
1550             fprintf (rl_outstream, "%s is not bound to any keys\n",
1551                      name);
1552           else
1553             {
1554               register int j;
1555
1556               fprintf (rl_outstream, "%s can be found on ", name);
1557
1558               for (j = 0; invokers[j] && j < 5; j++)
1559                 {
1560                   fprintf (rl_outstream, "\"%s\"%s", invokers[j],
1561                            invokers[j + 1] ? ", " : ".\n");
1562                 }
1563
1564               if (j == 5 && invokers[j])
1565                 fprintf (rl_outstream, "...\n");
1566
1567               for (j = 0; invokers[j]; j++)
1568                 free (invokers[j]);
1569
1570               free (invokers);
1571             }
1572         }
1573     }
1574 }
1575
1576 /* Print all of the current functions and their bindings to
1577    rl_outstream.  If an explicit argument is given, then print
1578    the output in such a way that it can be read back in. */
1579 int
1580 rl_dump_functions (count, key)
1581      int count, key;
1582 {
1583   if (rl_dispatching)
1584     fprintf (rl_outstream, "\r\n");
1585   rl_function_dumper (rl_explicit_arg);
1586   rl_on_new_line ();
1587   return (0);
1588 }
1589
1590 static void
1591 _rl_macro_dumper_internal (print_readably, map, prefix)
1592      int print_readably;
1593      Keymap map;
1594      char *prefix;
1595 {
1596   register int key;
1597   char *keyname, *out;
1598   int prefix_len;
1599
1600   for (key = 0; key < KEYMAP_SIZE; key++)
1601     {
1602       switch (map[key].type)
1603         {
1604         case ISMACR:
1605           keyname = _rl_get_keyname (key);
1606 #if 0
1607           out = (char *)map[key].function;
1608 #else
1609           out = _rl_untranslate_macro_value ((char *)map[key].function);
1610 #endif
1611           if (print_readably)
1612             fprintf (rl_outstream, "\"%s%s\": \"%s\"\n", prefix ? prefix : "",
1613                                                          keyname,
1614                                                          out ? out : "");
1615           else
1616             fprintf (rl_outstream, "%s%s outputs %s\n", prefix ? prefix : "",
1617                                                         keyname,
1618                                                         out ? out : "");
1619           free (keyname);
1620 #if 1
1621           free (out);
1622 #endif
1623           break;
1624         case ISFUNC:
1625           break;
1626         case ISKMAP:
1627           prefix_len = prefix ? strlen (prefix) : 0;
1628           if (key == ESC)
1629             {
1630               keyname = xmalloc (3 + prefix_len);
1631               if (prefix)
1632                 strcpy (keyname, prefix);
1633               keyname[prefix_len] = '\\';
1634               keyname[prefix_len + 1] = 'e';
1635               keyname[prefix_len + 2] = '\0';
1636             }
1637           else
1638             {
1639               keyname = _rl_get_keyname (key);
1640               if (prefix)
1641                 {
1642                   out = xmalloc (strlen (keyname) + prefix_len + 1);
1643                   strcpy (out, prefix);
1644                   strcpy (out + prefix_len, keyname);
1645                   free (keyname);
1646                   keyname = out;
1647                 }
1648             }
1649
1650           _rl_macro_dumper_internal (print_readably, FUNCTION_TO_KEYMAP (map, key), keyname);
1651           free (keyname);
1652           break;
1653         }
1654     }
1655 }
1656
1657 void
1658 rl_macro_dumper (print_readably)
1659      int print_readably;
1660 {
1661   _rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
1662 }
1663
1664 int
1665 rl_dump_macros (count, key)
1666      int count, key;
1667 {
1668   if (rl_dispatching)
1669     fprintf (rl_outstream, "\r\n");
1670   rl_macro_dumper (rl_explicit_arg);
1671   rl_on_new_line ();
1672   return (0);
1673 }
1674
1675 void
1676 rl_variable_dumper (print_readably)
1677      int print_readably;
1678 {
1679   int i;
1680   char *kname;
1681
1682   for (i = 0; boolean_varlist[i].name; i++)
1683     {
1684       if (print_readably)
1685         fprintf (rl_outstream, "set %s %s\n", boolean_varlist[i].name,
1686                                *boolean_varlist[i].value ? "on" : "off");
1687       else
1688         fprintf (rl_outstream, "%s is set to `%s'\n", boolean_varlist[i].name,
1689                                *boolean_varlist[i].value ? "on" : "off");
1690     }
1691
1692   /* bell-style */
1693   switch (_rl_bell_preference)
1694     {
1695     case NO_BELL: kname = "none"; break;
1696     case VISIBLE_BELL: kname = "visible"; break;
1697     case AUDIBLE_BELL:
1698     default: kname = "audible"; break;
1699     }
1700   if (print_readably)
1701     fprintf (rl_outstream, "set bell-style %s\n", kname);
1702   else
1703     fprintf (rl_outstream, "bell-style is set to `%s'\n", kname);
1704
1705   /* comment-begin */
1706   if (print_readably)
1707     fprintf (rl_outstream, "set comment-begin %s\n", _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
1708   else
1709     fprintf (rl_outstream, "comment-begin is set to `%s'\n", _rl_comment_begin ? _rl_comment_begin : "");
1710
1711   /* completion-query-items */
1712   if (print_readably)
1713     fprintf (rl_outstream, "set completion-query-items %d\n", rl_completion_query_items);
1714   else
1715     fprintf (rl_outstream, "completion-query-items is set to `%d'\n", rl_completion_query_items);
1716
1717   /* editing-mode */
1718   if (print_readably)
1719     fprintf (rl_outstream, "set editing-mode %s\n", (rl_editing_mode == emacs_mode) ? "emacs" : "vi");
1720   else
1721     fprintf (rl_outstream, "editing-mode is set to `%s'\n", (rl_editing_mode == emacs_mode) ? "emacs" : "vi");
1722
1723   /* keymap */
1724   kname = rl_get_keymap_name (_rl_keymap);
1725   if (kname == 0)
1726     kname = rl_get_keymap_name_from_edit_mode ();
1727   if (print_readably)
1728     fprintf (rl_outstream, "set keymap %s\n", kname ? kname : "none");
1729   else
1730     fprintf (rl_outstream, "keymap is set to `%s'\n", kname ? kname : "none");
1731 }
1732
1733 /* Print all of the current variables and their values to
1734    rl_outstream.  If an explicit argument is given, then print
1735    the output in such a way that it can be read back in. */
1736 int
1737 rl_dump_variables (count, key)
1738      int count, key;
1739 {
1740   if (rl_dispatching)
1741     fprintf (rl_outstream, "\r\n");
1742   rl_variable_dumper (rl_explicit_arg);
1743   rl_on_new_line ();
1744   return (0);
1745 }
1746
1747 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. */
1748 void
1749 _rl_bind_if_unbound (keyseq, default_func)
1750      char *keyseq;
1751      Function *default_func;
1752 {
1753   Function *func;
1754
1755   if (keyseq)
1756     {
1757       func = rl_function_of_keyseq (keyseq, _rl_keymap, (int *)NULL);
1758       if (!func || func == rl_do_lowercase_version)
1759         rl_set_key (keyseq, default_func, _rl_keymap);
1760     }
1761 }
1762
1763 /* Return non-zero if any members of ARRAY are a substring in STRING. */
1764 static int
1765 substring_member_of_array (string, array)
1766      char *string, **array;
1767 {
1768   while (*array)
1769     {
1770       if (_rl_strindex (string, *array))
1771         return (1);
1772       array++;
1773     }
1774   return (0);
1775 }