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