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