1 /* bind.c -- key binding and startup file support for the readline library. */
3 /* Copyright (C) 1987-2010 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
22 #define READLINE_LIBRARY
24 #if defined (__TANDEM)
28 #if defined (HAVE_CONFIG_H)
33 #include <sys/types.h>
35 #if defined (HAVE_SYS_FILE_H)
36 # include <sys/file.h>
37 #endif /* HAVE_SYS_FILE_H */
39 #if defined (HAVE_UNISTD_H)
41 #endif /* HAVE_UNISTD_H */
43 #if defined (HAVE_STDLIB_H)
46 # include "ansi_stdlib.h"
47 #endif /* HAVE_STDLIB_H */
55 #include "posixstat.h"
57 /* System-specific feature definitions and include files. */
60 /* Some standard library routines. */
64 #include "rlprivate.h"
68 #if !defined (strchr) && !defined (__STDC__)
69 extern char *strchr (), *strrchr ();
70 #endif /* !strchr && !__STDC__ */
72 /* Variables exported by this file. */
73 Keymap rl_binding_keymap
;
75 static int _rl_skip_to_delim
PARAMS((char *, int, int));
77 static char *_rl_read_file
PARAMS((char *, size_t *));
78 static void _rl_init_file_error
PARAMS((const char *));
79 static int _rl_read_init_file
PARAMS((const char *, int));
80 static int glean_key_from_name
PARAMS((char *));
82 static int find_boolean_var
PARAMS((const char *));
83 static int find_string_var
PARAMS((const char *));
85 static char *_rl_get_string_variable_value
PARAMS((const char *));
86 static int substring_member_of_array
PARAMS((const char *, const char * const *));
88 static int currently_reading_init_file
;
90 /* used only in this file */
91 static int _rl_prefer_visible_bell
= 1;
93 /* **************************************************************** */
97 /* **************************************************************** */
99 /* rl_add_defun (char *name, rl_command_func_t *function, int key)
100 Add NAME to the list of named functions. Make FUNCTION be the function
101 that gets called. If KEY is not -1, then bind it. */
103 rl_add_defun (name
, function
, key
)
105 rl_command_func_t
*function
;
109 rl_bind_key (key
, function
);
110 rl_add_funmap_entry (name
, function
);
114 /* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */
116 rl_bind_key (key
, function
)
118 rl_command_func_t
*function
;
123 if (META_CHAR (key
) && _rl_convert_meta_chars_to_ascii
)
125 if (_rl_keymap
[ESC
].type
== ISKMAP
)
129 escmap
= FUNCTION_TO_KEYMAP (_rl_keymap
, ESC
);
131 escmap
[key
].type
= ISFUNC
;
132 escmap
[key
].function
= function
;
138 _rl_keymap
[key
].type
= ISFUNC
;
139 _rl_keymap
[key
].function
= function
;
140 rl_binding_keymap
= _rl_keymap
;
144 /* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid
147 rl_bind_key_in_map (key
, function
, map
)
149 rl_command_func_t
*function
;
157 result
= rl_bind_key (key
, function
);
162 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
163 now, this is always used to attempt to bind the arrow keys, hence the
164 check for rl_vi_movement_mode. */
166 rl_bind_key_if_unbound_in_map (key
, default_func
, kmap
)
168 rl_command_func_t
*default_func
;
173 keyseq
[0] = (unsigned char)key
;
175 return (rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, kmap
));
179 rl_bind_key_if_unbound (key
, default_func
)
181 rl_command_func_t
*default_func
;
185 keyseq
[0] = (unsigned char)key
;
187 return (rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, _rl_keymap
));
190 /* Make KEY do nothing in the currently selected keymap.
191 Returns non-zero in case of error. */
196 return (rl_bind_key (key
, (rl_command_func_t
*)NULL
));
199 /* Make KEY do nothing in MAP.
200 Returns non-zero in case of error. */
202 rl_unbind_key_in_map (key
, map
)
206 return (rl_bind_key_in_map (key
, (rl_command_func_t
*)NULL
, map
));
209 /* Unbind all keys bound to FUNCTION in MAP. */
211 rl_unbind_function_in_map (func
, map
)
212 rl_command_func_t
*func
;
215 register int i
, rval
;
217 for (i
= rval
= 0; i
< KEYMAP_SIZE
; i
++)
219 if (map
[i
].type
== ISFUNC
&& map
[i
].function
== func
)
221 map
[i
].function
= (rl_command_func_t
*)NULL
;
229 rl_unbind_command_in_map (command
, map
)
233 rl_command_func_t
*func
;
235 func
= rl_named_function (command
);
238 return (rl_unbind_function_in_map (func
, map
));
241 /* Bind the key sequence represented by the string KEYSEQ to
242 FUNCTION, starting in the current keymap. This makes new
243 keymaps as necessary. */
245 rl_bind_keyseq (keyseq
, function
)
247 rl_command_func_t
*function
;
249 return (rl_generic_bind (ISFUNC
, keyseq
, (char *)function
, _rl_keymap
));
252 /* Bind the key sequence represented by the string KEYSEQ to
253 FUNCTION. This makes new keymaps as necessary. The initial
254 place to do bindings is in MAP. */
256 rl_bind_keyseq_in_map (keyseq
, function
, map
)
258 rl_command_func_t
*function
;
261 return (rl_generic_bind (ISFUNC
, keyseq
, (char *)function
, map
));
264 /* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
266 rl_set_key (keyseq
, function
, map
)
268 rl_command_func_t
*function
;
271 return (rl_generic_bind (ISFUNC
, keyseq
, (char *)function
, map
));
274 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
275 now, this is always used to attempt to bind the arrow keys, hence the
276 check for rl_vi_movement_mode. */
278 rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, kmap
)
280 rl_command_func_t
*default_func
;
283 rl_command_func_t
*func
;
287 func
= rl_function_of_keyseq (keyseq
, kmap
, (int *)NULL
);
288 #if defined (VI_MODE)
289 if (!func
|| func
== rl_do_lowercase_version
|| func
== rl_vi_movement_mode
)
291 if (!func
|| func
== rl_do_lowercase_version
)
293 return (rl_bind_keyseq_in_map (keyseq
, default_func
, kmap
));
301 rl_bind_keyseq_if_unbound (keyseq
, default_func
)
303 rl_command_func_t
*default_func
;
305 return (rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, _rl_keymap
));
308 /* Bind the key sequence represented by the string KEYSEQ to
309 the string of characters MACRO. This makes new keymaps as
310 necessary. The initial place to do bindings is in MAP. */
312 rl_macro_bind (keyseq
, macro
, map
)
313 const char *keyseq
, *macro
;
319 macro_keys
= (char *)xmalloc ((2 * strlen (macro
)) + 1);
321 if (rl_translate_keyseq (macro
, macro_keys
, ¯o_keys_len
))
326 rl_generic_bind (ISMACR
, keyseq
, macro_keys
, map
);
330 /* Bind the key sequence represented by the string KEYSEQ to
331 the arbitrary pointer DATA. TYPE says what kind of data is
332 pointed to by DATA, right now this can be a function (ISFUNC),
333 a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps
334 as necessary. The initial place to do bindings is in MAP. */
336 rl_generic_bind (type
, keyseq
, data
, map
)
349 /* If no keys to bind to, exit right away. */
350 if (keyseq
== 0 || *keyseq
== 0)
357 keys
= (char *)xmalloc (1 + (2 * strlen (keyseq
)));
359 /* Translate the ASCII representation of KEYSEQ into an array of
360 characters. Stuff the characters into KEYS, and the length of
361 KEYS into KEYS_LEN. */
362 if (rl_translate_keyseq (keyseq
, keys
, &keys_len
))
368 /* Bind keys, making new keymaps as necessary. */
369 for (i
= 0; i
< keys_len
; i
++)
371 unsigned char uc
= keys
[i
];
375 if (ic
< 0 || ic
>= KEYMAP_SIZE
)
381 if (META_CHAR (ic
) && _rl_convert_meta_chars_to_ascii
)
384 if (map
[ESC
].type
== ISKMAP
)
385 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
388 if ((i
+ 1) < keys_len
)
390 if (map
[ic
].type
!= ISKMAP
)
392 /* We allow subsequences of keys. If a keymap is being
393 created that will `shadow' an existing function or macro
394 key binding, we save that keybinding into the ANYOTHERKEY
395 index in the new map. The dispatch code will look there
396 to find the function to execute if the subsequence is not
397 matched. ANYOTHERKEY was chosen to be greater than
401 map
[ic
].type
= ISKMAP
;
402 map
[ic
].function
= KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
404 map
= FUNCTION_TO_KEYMAP (map
, ic
);
405 /* The dispatch code will return this function if no matching
406 key sequence is found in the keymap. This (with a little
407 help from the dispatch code in readline.c) allows `a' to be
408 mapped to something, `abc' to be mapped to something else,
409 and the function bound to `a' to be executed when the user
410 types `abx', leaving `bx' in the input queue. */
411 if (k
.function
&& ((k
.type
== ISFUNC
&& k
.function
!= rl_do_lowercase_version
) || k
.type
== ISMACR
))
413 map
[ANYOTHERKEY
] = k
;
419 if (map
[ic
].type
== ISMACR
)
420 xfree ((char *)map
[ic
].function
);
421 else if (map
[ic
].type
== ISKMAP
)
423 map
= FUNCTION_TO_KEYMAP (map
, ic
);
425 /* If we're trying to override a keymap with a null function
426 (e.g., trying to unbind it), we can't use a null pointer
427 here because that's indistinguishable from having not been
428 overridden. We use a special bindable function that does
430 if (type
== ISFUNC
&& data
== 0)
431 data
= (char *)_rl_null_function
;
434 map
[ic
].function
= KEYMAP_TO_FUNCTION (data
);
438 rl_binding_keymap
= map
;
444 /* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
445 an array of characters. LEN gets the final length of ARRAY. Return
446 non-zero if there was an error parsing SEQ. */
448 rl_translate_keyseq (seq
, array
, len
)
453 register int i
, c
, l
, temp
;
455 for (i
= l
= 0; c
= seq
[i
]; i
++)
464 /* Handle \C- and \M- prefixes. */
465 if ((c
== 'C' || c
== 'M') && seq
[i
+ 1] == '-')
467 /* Handle special case of backwards define. */
468 if (strncmp (&seq
[i
], "C-\\M-", 5) == 0)
470 array
[l
++] = ESC
; /* ESC is meta-prefix */
472 array
[l
++] = CTRL (_rl_to_upper (seq
[i
]));
478 i
++; /* seq[i] == '-' */
479 /* XXX - obey convert-meta setting */
480 if (_rl_convert_meta_chars_to_ascii
&& _rl_keymap
[ESC
].type
== ISKMAP
)
481 array
[l
++] = ESC
; /* ESC is meta-prefix */
482 else if (seq
[i
+1] == '\\' && seq
[i
+2] == 'C' && seq
[i
+3] == '-')
485 temp
= (seq
[i
] == '?') ? RUBOUT
: CTRL (_rl_to_upper (seq
[i
]));
486 array
[l
++] = META (temp
);
490 /* This doesn't yet handle things like \M-\a, which may
491 or may not have any reasonable meaning. You're
492 probably better off using straight octal or hex. */
494 array
[l
++] = META (seq
[i
]);
500 /* Special hack for C-?... */
501 array
[l
++] = (seq
[i
] == '?') ? RUBOUT
: CTRL (_rl_to_upper (seq
[i
]));
506 /* Translate other backslash-escaped characters. These are the
507 same escape sequences that bash's `echo' and `printf' builtins
508 handle, with the addition of \d -> RUBOUT. A backslash
509 preceding a character that is not special is stripped. */
519 array
[l
++] = RUBOUT
; /* readline-specific */
528 array
[l
++] = NEWLINE
;
542 case '0': case '1': case '2': case '3':
543 case '4': case '5': case '6': case '7':
545 for (temp
= 2, c
-= '0'; ISOCTAL (seq
[i
]) && temp
--; i
++)
546 c
= (c
* 8) + OCTVALUE (seq
[i
]);
547 i
--; /* auto-increment in for loop */
548 array
[l
++] = c
& largest_char
;
552 for (temp
= 2, c
= 0; ISXDIGIT ((unsigned char)seq
[i
]) && temp
--; i
++)
553 c
= (c
* 16) + HEXVALUE (seq
[i
]);
556 i
--; /* auto-increment in for loop */
557 array
[l
++] = c
& largest_char
;
559 default: /* backslashes before non-special chars just add the char */
561 break; /* the backslash is stripped */
575 rl_untranslate_keyseq (seq
)
578 static char kseq
[16];
595 else if (CTRL_CHAR (c
))
600 c
= _rl_to_lower (UNCTRL (c
));
602 else if (c
== RUBOUT
)
615 else if (c
== '\\' || c
== '"')
620 kseq
[i
++] = (unsigned char) c
;
626 _rl_untranslate_macro_value (seq
)
632 r
= ret
= (char *)xmalloc (7 * strlen (seq
) + 1);
633 for (s
= seq
; *s
; s
++)
648 else if (CTRL_CHAR (c
))
653 c
= _rl_to_lower (UNCTRL (c
));
655 else if (c
== RUBOUT
)
668 else if (c
== '\\' || c
== '"')
671 *r
++ = (unsigned char)c
;
677 /* Return a pointer to the function that STRING represents.
678 If STRING doesn't have a matching function, then a NULL pointer
681 rl_named_function (string
)
686 rl_initialize_funmap ();
688 for (i
= 0; funmap
[i
]; i
++)
689 if (_rl_stricmp (funmap
[i
]->name
, string
) == 0)
690 return (funmap
[i
]->function
);
691 return ((rl_command_func_t
*)NULL
);
694 /* Return the function (or macro) definition which would be invoked via
695 KEYSEQ if executed in MAP. If MAP is NULL, then the current keymap is
696 used. TYPE, if non-NULL, is a pointer to an int which will receive the
697 type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),
698 or ISMACR (macro). */
700 rl_function_of_keyseq (keyseq
, map
, type
)
710 for (i
= 0; keyseq
&& keyseq
[i
]; i
++)
712 unsigned char ic
= keyseq
[i
];
714 if (META_CHAR (ic
) && _rl_convert_meta_chars_to_ascii
)
716 if (map
[ESC
].type
== ISKMAP
)
718 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
721 /* XXX - should we just return NULL here, since this obviously
726 *type
= map
[ESC
].type
;
728 return (map
[ESC
].function
);
732 if (map
[ic
].type
== ISKMAP
)
734 /* If this is the last key in the key sequence, return the
736 if (keyseq
[i
+ 1] == '\0')
741 return (map
[ic
].function
);
744 map
= FUNCTION_TO_KEYMAP (map
, ic
);
746 /* If we're not at the end of the key sequence, and the current key
747 is bound to something other than a keymap, then the entire key
748 sequence is not bound. */
749 else if (map
[ic
].type
!= ISKMAP
&& keyseq
[i
+1])
750 return ((rl_command_func_t
*)NULL
);
751 else /* map[ic].type != ISKMAP && keyseq[i+1] == 0 */
754 *type
= map
[ic
].type
;
756 return (map
[ic
].function
);
759 return ((rl_command_func_t
*) NULL
);
762 /* The last key bindings file read. */
763 static char *last_readline_init_file
= (char *)NULL
;
765 /* The file we're currently reading key bindings from. */
766 static const char *current_readline_init_file
;
767 static int current_readline_init_include_level
;
768 static int current_readline_init_lineno
;
770 /* Read FILENAME into a locally-allocated buffer and return the buffer.
771 The size of the buffer is returned in *SIZEP. Returns NULL if any
772 errors were encountered. */
774 _rl_read_file (filename
, sizep
)
783 if ((stat (filename
, &finfo
) < 0) || (file
= open (filename
, O_RDONLY
, 0666)) < 0)
784 return ((char *)NULL
);
786 file_size
= (size_t)finfo
.st_size
;
788 /* check for overflow on very large files */
789 if (file_size
!= finfo
.st_size
|| file_size
+ 1 < file_size
)
796 return ((char *)NULL
);
799 /* Read the file into BUFFER. */
800 buffer
= (char *)xmalloc (file_size
+ 1);
801 i
= read (file
, buffer
, file_size
);
807 return ((char *)NULL
);
819 /* Re-read the current keybindings file. */
821 rl_re_read_init_file (count
, ignore
)
825 r
= rl_read_init_file ((const char *)NULL
);
826 rl_set_keymap_from_edit_mode ();
830 /* Do key bindings from a file. If FILENAME is NULL it defaults
831 to the first non-null filename from this list:
832 1. the filename used for the previous call
833 2. the value of the shell variable `INPUTRC'
836 If the file existed and could be opened and read, 0 is returned,
837 otherwise errno is returned. */
839 rl_read_init_file (filename
)
840 const char *filename
;
842 /* Default the filename. */
844 filename
= last_readline_init_file
;
846 filename
= sh_get_env_value ("INPUTRC");
847 if (filename
== 0 || *filename
== 0)
849 filename
= DEFAULT_INPUTRC
;
850 /* Try to read DEFAULT_INPUTRC; fall back to SYS_INPUTRC on failure */
851 if (_rl_read_init_file (filename
, 0) == 0)
853 filename
= SYS_INPUTRC
;
856 #if defined (__MSDOS__)
857 if (_rl_read_init_file (filename
, 0) == 0)
859 filename
= "~/_inputrc";
861 return (_rl_read_init_file (filename
, 0));
865 _rl_read_init_file (filename
, include_level
)
866 const char *filename
;
870 char *buffer
, *openname
, *line
, *end
;
873 current_readline_init_file
= filename
;
874 current_readline_init_include_level
= include_level
;
876 openname
= tilde_expand (filename
);
877 buffer
= _rl_read_file (openname
, &file_size
);
884 if (include_level
== 0 && filename
!= last_readline_init_file
)
886 FREE (last_readline_init_file
);
887 last_readline_init_file
= savestring (filename
);
890 currently_reading_init_file
= 1;
892 /* Loop over the lines in the file. Lines that start with `#' are
893 comments; all other lines are commands for readline initialization. */
894 current_readline_init_lineno
= 1;
896 end
= buffer
+ file_size
;
899 /* Find the end of this line. */
900 for (i
= 0; line
+ i
!= end
&& line
[i
] != '\n'; i
++);
902 #if defined (__CYGWIN__)
903 /* ``Be liberal in what you accept.'' */
904 if (line
[i
] == '\n' && line
[i
-1] == '\r')
908 /* Mark end of line. */
911 /* Skip leading whitespace. */
912 while (*line
&& whitespace (*line
))
918 /* If the line is not a comment, then parse it. */
919 if (*line
&& *line
!= '#')
920 rl_parse_and_bind (line
);
922 /* Move to the next line. */
924 current_readline_init_lineno
++;
928 currently_reading_init_file
= 0;
933 _rl_init_file_error (msg
)
936 if (currently_reading_init_file
)
937 _rl_errmsg ("%s: line %d: %s\n", current_readline_init_file
,
938 current_readline_init_lineno
, msg
);
940 _rl_errmsg ("%s", msg
);
943 /* **************************************************************** */
945 /* Parser Directives */
947 /* **************************************************************** */
949 typedef int _rl_parser_func_t
PARAMS((char *));
951 /* Things that mean `Control'. */
952 const char * const _rl_possible_control_prefixes
[] = {
953 "Control-", "C-", "CTRL-", (const char *)NULL
956 const char * const _rl_possible_meta_prefixes
[] = {
957 "Meta", "M-", (const char *)NULL
962 /* Calling programs set this to have their argv[0]. */
963 const char *rl_readline_name
= "other";
965 /* Stack of previous values of parsing_conditionalized_out. */
966 static unsigned char *if_stack
= (unsigned char *)NULL
;
967 static int if_stack_depth
;
968 static int if_stack_size
;
970 /* Push _rl_parsing_conditionalized_out, and set parser state based
978 /* Push parser state. */
979 if (if_stack_depth
+ 1 >= if_stack_size
)
982 if_stack
= (unsigned char *)xmalloc (if_stack_size
= 20);
984 if_stack
= (unsigned char *)xrealloc (if_stack
, if_stack_size
+= 20);
986 if_stack
[if_stack_depth
++] = _rl_parsing_conditionalized_out
;
988 /* If parsing is turned off, then nothing can turn it back on except
989 for finding the matching endif. In that case, return right now. */
990 if (_rl_parsing_conditionalized_out
)
993 /* Isolate first argument. */
994 for (i
= 0; args
[i
] && !whitespace (args
[i
]); i
++);
999 /* Handle "$if term=foo" and "$if mode=emacs" constructs. If this
1000 isn't term=foo, or mode=emacs, then check to see if the first
1001 word in ARGS is the same as the value stored in rl_readline_name. */
1002 if (rl_terminal_name
&& _rl_strnicmp (args
, "term=", 5) == 0)
1006 /* Terminals like "aaa-60" are equivalent to "aaa". */
1007 tname
= savestring (rl_terminal_name
);
1008 tem
= strchr (tname
, '-');
1012 /* Test the `long' and `short' forms of the terminal name so that
1013 if someone has a `sun-cmd' and does not want to have bindings
1014 that will be executed if the terminal is a `sun', they can put
1015 `$if term=sun-cmd' into their .inputrc. */
1016 _rl_parsing_conditionalized_out
= _rl_stricmp (args
+ 5, tname
) &&
1017 _rl_stricmp (args
+ 5, rl_terminal_name
);
1020 #if defined (VI_MODE)
1021 else if (_rl_strnicmp (args
, "mode=", 5) == 0)
1025 if (_rl_stricmp (args
+ 5, "emacs") == 0)
1027 else if (_rl_stricmp (args
+ 5, "vi") == 0)
1032 _rl_parsing_conditionalized_out
= mode
!= rl_editing_mode
;
1034 #endif /* VI_MODE */
1035 /* Check to see if the first word in ARGS is the same as the
1036 value stored in rl_readline_name. */
1037 else if (_rl_stricmp (args
, rl_readline_name
) == 0)
1038 _rl_parsing_conditionalized_out
= 0;
1040 _rl_parsing_conditionalized_out
= 1;
1044 /* Invert the current parser state if there is anything on the stack. */
1051 if (if_stack_depth
== 0)
1053 _rl_init_file_error ("$else found without matching $if");
1058 /* Check the previous (n - 1) levels of the stack to make sure that
1059 we haven't previously turned off parsing. */
1060 for (i
= 0; i
< if_stack_depth
- 1; i
++)
1062 /* Check the previous (n) levels of the stack to make sure that
1063 we haven't previously turned off parsing. */
1064 for (i
= 0; i
< if_stack_depth
; i
++)
1066 if (if_stack
[i
] == 1)
1069 /* Invert the state of parsing if at top level. */
1070 _rl_parsing_conditionalized_out
= !_rl_parsing_conditionalized_out
;
1074 /* Terminate a conditional, popping the value of
1075 _rl_parsing_conditionalized_out from the stack. */
1081 _rl_parsing_conditionalized_out
= if_stack
[--if_stack_depth
];
1083 _rl_init_file_error ("$endif without matching $if");
1088 parser_include (args
)
1091 const char *old_init_file
;
1093 int old_line_number
, old_include_level
, r
;
1095 if (_rl_parsing_conditionalized_out
)
1098 old_init_file
= current_readline_init_file
;
1099 old_line_number
= current_readline_init_lineno
;
1100 old_include_level
= current_readline_init_include_level
;
1102 e
= strchr (args
, '\n');
1105 r
= _rl_read_init_file ((const char *)args
, old_include_level
+ 1);
1107 current_readline_init_file
= old_init_file
;
1108 current_readline_init_lineno
= old_line_number
;
1109 current_readline_init_include_level
= old_include_level
;
1114 /* Associate textual names with actual functions. */
1115 static const struct {
1116 const char * const name
;
1117 _rl_parser_func_t
*function
;
1118 } parser_directives
[] = {
1119 { "if", parser_if
},
1120 { "endif", parser_endif
},
1121 { "else", parser_else
},
1122 { "include", parser_include
},
1123 { (char *)0x0, (_rl_parser_func_t
*)0x0 }
1126 /* Handle a parser directive. STATEMENT is the line of the directive
1127 without any leading `$'. */
1129 handle_parser_directive (statement
)
1133 char *directive
, *args
;
1135 /* Isolate the actual directive. */
1137 /* Skip whitespace. */
1138 for (i
= 0; whitespace (statement
[i
]); i
++);
1140 directive
= &statement
[i
];
1142 for (; statement
[i
] && !whitespace (statement
[i
]); i
++);
1145 statement
[i
++] = '\0';
1147 for (; statement
[i
] && whitespace (statement
[i
]); i
++);
1149 args
= &statement
[i
];
1151 /* Lookup the command, and act on it. */
1152 for (i
= 0; parser_directives
[i
].name
; i
++)
1153 if (_rl_stricmp (directive
, parser_directives
[i
].name
) == 0)
1155 (*parser_directives
[i
].function
) (args
);
1159 /* display an error message about the unknown parser directive */
1160 _rl_init_file_error ("unknown parser directive");
1164 /* Start at STRING[START] and look for DELIM. Return I where STRING[I] ==
1165 DELIM or STRING[I] == 0. DELIM is usually a double quote. */
1167 _rl_skip_to_delim (string
, start
, delim
)
1173 for (i
= start
,passc
= 0; c
= string
[i
]; i
++)
1196 /* Read the binding command from STRING and perform it.
1197 A key binding command looks like: Keyname: function-name\0,
1198 a variable binding command looks like: set variable value.
1199 A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
1201 rl_parse_and_bind (string
)
1204 char *funname
, *kname
;
1206 int key
, equivalency
;
1208 while (string
&& whitespace (*string
))
1211 if (string
== 0 || *string
== 0 || *string
== '#')
1214 /* If this is a parser directive, act on it. */
1217 handle_parser_directive (&string
[1]);
1221 /* If we aren't supposed to be parsing right now, then we're done. */
1222 if (_rl_parsing_conditionalized_out
)
1226 /* If this keyname is a complex key expression surrounded by quotes,
1227 advance to after the matching close quote. This code allows the
1228 backslash to quote characters in the key expression. */
1231 i
= _rl_skip_to_delim (string
, 1, '"');
1233 /* If we didn't find a closing quote, abort the line. */
1234 if (string
[i
] == '\0')
1236 _rl_init_file_error ("no closing `\"' in key binding");
1240 i
++; /* skip past closing double quote */
1243 /* Advance to the colon (:) or whitespace which separates the two objects. */
1244 for (; (c
= string
[i
]) && c
!= ':' && c
!= ' ' && c
!= '\t'; i
++ );
1246 equivalency
= (c
== ':' && string
[i
+ 1] == '=');
1248 /* Mark the end of the command (or keyname). */
1252 /* If doing assignment, skip the '=' sign as well. */
1256 /* If this is a command to set a variable, then do that. */
1257 if (_rl_stricmp (string
, "set") == 0)
1259 char *var
, *value
, *e
;
1263 /* Make VAR point to start of variable name. */
1264 while (*var
&& whitespace (*var
)) var
++;
1266 /* Make VALUE point to start of value string. */
1268 while (*value
&& whitespace (*value
) == 0) value
++;
1271 while (*value
&& whitespace (*value
)) value
++;
1273 /* Strip trailing whitespace from values of boolean variables. */
1274 if (find_boolean_var (var
) >= 0)
1276 /* remove trailing whitespace */
1278 e
= value
+ strlen (value
) - 1;
1279 while (e
>= value
&& whitespace (*e
))
1281 e
++; /* skip back to whitespace or EOS */
1283 if (*e
&& e
>= value
)
1286 else if ((i
= find_string_var (var
)) >= 0)
1288 /* Allow quoted strings in variable values */
1291 i
= _rl_skip_to_delim (value
, 1, *value
);
1295 goto remove_trailing
;
1298 rl_variable_bind (var
, value
);
1302 /* Skip any whitespace between keyname and funname. */
1303 for (; string
[i
] && whitespace (string
[i
]); i
++);
1304 funname
= &string
[i
];
1306 /* Now isolate funname.
1307 For straight function names just look for whitespace, since
1308 that will signify the end of the string. But this could be a
1309 macro definition. In that case, the string is quoted, so skip
1310 to the matching delimiter. We allow the backslash to quote the
1311 delimiter characters in the macro body. */
1312 /* This code exists to allow whitespace in macro expansions, which
1313 would otherwise be gobbled up by the next `for' loop.*/
1314 /* XXX - it may be desirable to allow backslash quoting only if " is
1315 the quoted string delimiter, like the shell. */
1316 if (*funname
== '\'' || *funname
== '"')
1318 i
= _rl_skip_to_delim (string
, i
+1, *funname
);
1323 /* Advance to the end of the string. */
1324 for (; string
[i
] && whitespace (string
[i
]) == 0; i
++);
1326 /* No extra whitespace at the end of the string. */
1329 /* Handle equivalency bindings here. Make the left-hand side be exactly
1330 whatever the right-hand evaluates to, including keymaps. */
1336 /* If this is a new-style key-binding, then do the binding with
1337 rl_bind_keyseq (). Otherwise, let the older code deal with it. */
1341 register int j
, k
, passc
;
1343 seq
= (char *)xmalloc (1 + strlen (string
));
1344 for (j
= 1, k
= passc
= 0; string
[j
]; j
++)
1346 /* Allow backslash to quote characters, but leave them in place.
1347 This allows a string to end with a backslash quoting another
1348 backslash, or with a backslash quoting a double quote. The
1349 backslashes are left in place for rl_translate_keyseq (). */
1350 if (passc
|| (string
[j
] == '\\'))
1352 seq
[k
++] = string
[j
];
1357 if (string
[j
] == '"')
1360 seq
[k
++] = string
[j
];
1364 /* Binding macro? */
1365 if (*funname
== '\'' || *funname
== '"')
1367 j
= strlen (funname
);
1369 /* Remove the delimiting quotes from each end of FUNNAME. */
1370 if (j
&& funname
[j
- 1] == *funname
)
1371 funname
[j
- 1] = '\0';
1373 rl_macro_bind (seq
, &funname
[1], _rl_keymap
);
1376 rl_bind_keyseq (seq
, rl_named_function (funname
));
1382 /* Get the actual character we want to deal with. */
1383 kname
= strrchr (string
, '-');
1389 key
= glean_key_from_name (kname
);
1391 /* Add in control and meta bits. */
1392 if (substring_member_of_array (string
, _rl_possible_control_prefixes
))
1393 key
= CTRL (_rl_to_upper (key
));
1395 if (substring_member_of_array (string
, _rl_possible_meta_prefixes
))
1398 /* Temporary. Handle old-style keyname with macro-binding. */
1399 if (*funname
== '\'' || *funname
== '"')
1402 int fl
= strlen (funname
);
1404 useq
[0] = key
; useq
[1] = '\0';
1405 if (fl
&& funname
[fl
- 1] == *funname
)
1406 funname
[fl
- 1] = '\0';
1408 rl_macro_bind (useq
, &funname
[1], _rl_keymap
);
1410 #if defined (PREFIX_META_HACK)
1411 /* Ugly, but working hack to keep prefix-meta around. */
1412 else if (_rl_stricmp (funname
, "prefix-meta") == 0)
1418 rl_generic_bind (ISKMAP
, seq
, (char *)emacs_meta_keymap
, _rl_keymap
);
1420 #endif /* PREFIX_META_HACK */
1422 rl_bind_key (key
, rl_named_function (funname
));
1426 /* Simple structure for boolean readline variables (i.e., those that can
1427 have one of two values; either "On" or 1 for truth, or "Off" or 0 for
1430 #define V_SPECIAL 0x1
1432 static const struct {
1433 const char * const name
;
1436 } boolean_varlist
[] = {
1437 { "bind-tty-special-chars", &_rl_bind_stty_chars
, 0 },
1438 { "blink-matching-paren", &rl_blink_matching_paren
, V_SPECIAL
},
1439 { "byte-oriented", &rl_byte_oriented
, 0 },
1440 { "completion-ignore-case", &_rl_completion_case_fold
, 0 },
1441 { "completion-map-case", &_rl_completion_case_map
, 0 },
1442 { "convert-meta", &_rl_convert_meta_chars_to_ascii
, 0 },
1443 { "disable-completion", &rl_inhibit_completion
, 0 },
1444 { "echo-control-characters", &_rl_echo_control_chars
, 0 },
1445 { "enable-keypad", &_rl_enable_keypad
, 0 },
1446 { "enable-meta-key", &_rl_enable_meta
, 0 },
1447 { "expand-tilde", &rl_complete_with_tilde_expansion
, 0 },
1448 { "history-preserve-point", &_rl_history_preserve_point
, 0 },
1449 { "horizontal-scroll-mode", &_rl_horizontal_scroll_mode
, 0 },
1450 { "input-meta", &_rl_meta_flag
, 0 },
1451 { "mark-directories", &_rl_complete_mark_directories
, 0 },
1452 { "mark-modified-lines", &_rl_mark_modified_lines
, 0 },
1453 { "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs
, 0 },
1454 { "match-hidden-files", &_rl_match_hidden_files
, 0 },
1455 { "menu-complete-display-prefix", &_rl_menu_complete_prefix_first
, 0 },
1456 { "meta-flag", &_rl_meta_flag
, 0 },
1457 { "output-meta", &_rl_output_meta_chars
, 0 },
1458 { "page-completions", &_rl_page_completions
, 0 },
1459 { "prefer-visible-bell", &_rl_prefer_visible_bell
, V_SPECIAL
},
1460 { "print-completions-horizontally", &_rl_print_completions_horizontally
, 0 },
1461 { "revert-all-at-newline", &_rl_revert_all_at_newline
, 0 },
1462 { "show-all-if-ambiguous", &_rl_complete_show_all
, 0 },
1463 { "show-all-if-unmodified", &_rl_complete_show_unmodified
, 0 },
1464 { "skip-completed-text", &_rl_skip_completed_text
, 0 },
1465 #if defined (VISIBLE_STATS)
1466 { "visible-stats", &rl_visible_stats
, 0 },
1467 #endif /* VISIBLE_STATS */
1468 { (char *)NULL
, (int *)NULL
, 0 }
1472 find_boolean_var (name
)
1477 for (i
= 0; boolean_varlist
[i
].name
; i
++)
1478 if (_rl_stricmp (name
, boolean_varlist
[i
].name
) == 0)
1483 /* Hooks for handling special boolean variables, where a
1484 function needs to be called or another variable needs
1485 to be changed when they're changed. */
1487 hack_special_boolean_var (i
)
1492 name
= boolean_varlist
[i
].name
;
1494 if (_rl_stricmp (name
, "blink-matching-paren") == 0)
1495 _rl_enable_paren_matching (rl_blink_matching_paren
);
1496 else if (_rl_stricmp (name
, "prefer-visible-bell") == 0)
1498 if (_rl_prefer_visible_bell
)
1499 _rl_bell_preference
= VISIBLE_BELL
;
1501 _rl_bell_preference
= AUDIBLE_BELL
;
1505 typedef int _rl_sv_func_t
PARAMS((const char *));
1507 /* These *must* correspond to the array indices for the appropriate
1508 string variable. (Though they're not used right now.) */
1509 #define V_BELLSTYLE 0
1510 #define V_COMBEGIN 1
1511 #define V_EDITMODE 2
1512 #define V_ISRCHTERM 3
1518 /* Forward declarations */
1519 static int sv_bell_style
PARAMS((const char *));
1520 static int sv_combegin
PARAMS((const char *));
1521 static int sv_dispprefix
PARAMS((const char *));
1522 static int sv_compquery
PARAMS((const char *));
1523 static int sv_compwidth
PARAMS((const char *));
1524 static int sv_editmode
PARAMS((const char *));
1525 static int sv_histsize
PARAMS((const char *));
1526 static int sv_isrchterm
PARAMS((const char *));
1527 static int sv_keymap
PARAMS((const char *));
1529 static const struct {
1530 const char * const name
;
1532 _rl_sv_func_t
*set_func
;
1533 } string_varlist
[] = {
1534 { "bell-style", V_STRING
, sv_bell_style
},
1535 { "comment-begin", V_STRING
, sv_combegin
},
1536 { "completion-display-width", V_INT
, sv_compwidth
},
1537 { "completion-prefix-display-length", V_INT
, sv_dispprefix
},
1538 { "completion-query-items", V_INT
, sv_compquery
},
1539 { "editing-mode", V_STRING
, sv_editmode
},
1540 { "history-size", V_INT
, sv_histsize
},
1541 { "isearch-terminators", V_STRING
, sv_isrchterm
},
1542 { "keymap", V_STRING
, sv_keymap
},
1543 { (char *)NULL
, 0, (_rl_sv_func_t
*)0 }
1547 find_string_var (name
)
1552 for (i
= 0; string_varlist
[i
].name
; i
++)
1553 if (_rl_stricmp (name
, string_varlist
[i
].name
) == 0)
1558 /* A boolean value that can appear in a `set variable' command is true if
1559 the value is null or empty, `on' (case-insenstive), or "1". Any other
1560 values result in 0 (false). */
1565 return (value
== 0 || *value
== '\0' ||
1566 (_rl_stricmp (value
, "on") == 0) ||
1567 (value
[0] == '1' && value
[1] == '\0'));
1571 rl_variable_value (name
)
1576 /* Check for simple variables first. */
1577 i
= find_boolean_var (name
);
1579 return (*boolean_varlist
[i
].value
? "on" : "off");
1581 i
= find_string_var (name
);
1583 return (_rl_get_string_variable_value (string_varlist
[i
].name
));
1585 /* Unknown variable names return NULL. */
1590 rl_variable_bind (name
, value
)
1591 const char *name
, *value
;
1596 /* Check for simple variables first. */
1597 i
= find_boolean_var (name
);
1600 *boolean_varlist
[i
].value
= bool_to_int (value
);
1601 if (boolean_varlist
[i
].flags
& V_SPECIAL
)
1602 hack_special_boolean_var (i
);
1606 i
= find_string_var (name
);
1608 /* For the time being, unknown variable names or string names without a
1609 handler function are simply ignored. */
1610 if (i
< 0 || string_varlist
[i
].set_func
== 0)
1613 v
= (*string_varlist
[i
].set_func
) (value
);
1621 if (_rl_strnicmp (value
, "vi", 2) == 0)
1623 #if defined (VI_MODE)
1624 _rl_keymap
= vi_insertion_keymap
;
1625 rl_editing_mode
= vi_mode
;
1626 #endif /* VI_MODE */
1629 else if (_rl_strnicmp (value
, "emacs", 5) == 0)
1631 _rl_keymap
= emacs_standard_keymap
;
1632 rl_editing_mode
= emacs_mode
;
1642 if (value
&& *value
)
1644 FREE (_rl_comment_begin
);
1645 _rl_comment_begin
= savestring (value
);
1652 sv_dispprefix (value
)
1657 if (value
&& *value
)
1659 nval
= atoi (value
);
1663 _rl_completion_prefix_display_length
= nval
;
1668 sv_compquery (value
)
1673 if (value
&& *value
)
1675 nval
= atoi (value
);
1679 rl_completion_query_items
= nval
;
1684 sv_compwidth (value
)
1689 if (value
&& *value
)
1690 nval
= atoi (value
);
1692 _rl_completion_columns
= nval
;
1702 if (value
&& *value
)
1704 nval
= atoi (value
);
1708 stifle_history (nval
);
1718 kmap
= rl_get_keymap_by_name (value
);
1721 rl_set_keymap (kmap
);
1728 sv_bell_style (value
)
1731 if (value
== 0 || *value
== '\0')
1732 _rl_bell_preference
= AUDIBLE_BELL
;
1733 else if (_rl_stricmp (value
, "none") == 0 || _rl_stricmp (value
, "off") == 0)
1734 _rl_bell_preference
= NO_BELL
;
1735 else if (_rl_stricmp (value
, "audible") == 0 || _rl_stricmp (value
, "on") == 0)
1736 _rl_bell_preference
= AUDIBLE_BELL
;
1737 else if (_rl_stricmp (value
, "visible") == 0)
1738 _rl_bell_preference
= VISIBLE_BELL
;
1745 sv_isrchterm (value
)
1748 int beg
, end
, delim
;
1754 /* Isolate the value and translate it into a character string. */
1755 v
= savestring (value
);
1756 FREE (_rl_isearch_terminators
);
1757 if (v
[0] == '"' || v
[0] == '\'')
1760 for (beg
= end
= 1; v
[end
] && v
[end
] != delim
; end
++)
1765 for (beg
= end
= 0; whitespace (v
[end
]) == 0; end
++)
1771 /* The value starts at v + beg. Translate it into a character string. */
1772 _rl_isearch_terminators
= (char *)xmalloc (2 * strlen (v
) + 1);
1773 rl_translate_keyseq (v
+ beg
, _rl_isearch_terminators
, &end
);
1774 _rl_isearch_terminators
[end
] = '\0';
1780 /* Return the character which matches NAME.
1781 For example, `Space' returns ' '. */
1784 const char * const name
;
1788 static const assoc_list name_key_alist
[] = {
1791 { "Escape", '\033' },
1793 { "Newline", '\n' },
1804 glean_key_from_name (name
)
1809 for (i
= 0; name_key_alist
[i
].name
; i
++)
1810 if (_rl_stricmp (name
, name_key_alist
[i
].name
) == 0)
1811 return (name_key_alist
[i
].value
);
1813 return (*(unsigned char *)name
); /* XXX was return (*name) */
1816 /* Auxiliary functions to manage keymaps. */
1817 static const struct {
1818 const char * const name
;
1820 } keymap_names
[] = {
1821 { "emacs", emacs_standard_keymap
},
1822 { "emacs-standard", emacs_standard_keymap
},
1823 { "emacs-meta", emacs_meta_keymap
},
1824 { "emacs-ctlx", emacs_ctlx_keymap
},
1825 #if defined (VI_MODE)
1826 { "vi", vi_movement_keymap
},
1827 { "vi-move", vi_movement_keymap
},
1828 { "vi-command", vi_movement_keymap
},
1829 { "vi-insert", vi_insertion_keymap
},
1830 #endif /* VI_MODE */
1831 { (char *)0x0, (Keymap
)0x0 }
1835 rl_get_keymap_by_name (name
)
1840 for (i
= 0; keymap_names
[i
].name
; i
++)
1841 if (_rl_stricmp (name
, keymap_names
[i
].name
) == 0)
1842 return (keymap_names
[i
].map
);
1843 return ((Keymap
) NULL
);
1847 rl_get_keymap_name (map
)
1851 for (i
= 0; keymap_names
[i
].name
; i
++)
1852 if (map
== keymap_names
[i
].map
)
1853 return ((char *)keymap_names
[i
].name
);
1854 return ((char *)NULL
);
1868 return (_rl_keymap
);
1872 rl_set_keymap_from_edit_mode ()
1874 if (rl_editing_mode
== emacs_mode
)
1875 _rl_keymap
= emacs_standard_keymap
;
1876 #if defined (VI_MODE)
1877 else if (rl_editing_mode
== vi_mode
)
1878 _rl_keymap
= vi_insertion_keymap
;
1879 #endif /* VI_MODE */
1883 rl_get_keymap_name_from_edit_mode ()
1885 if (rl_editing_mode
== emacs_mode
)
1887 #if defined (VI_MODE)
1888 else if (rl_editing_mode
== vi_mode
)
1890 #endif /* VI_MODE */
1895 /* **************************************************************** */
1897 /* Key Binding and Function Information */
1899 /* **************************************************************** */
1901 /* Each of the following functions produces information about the
1902 state of keybindings and functions known to Readline. The info
1903 is always printed to rl_outstream, and in such a way that it can
1904 be read back in (i.e., passed to rl_parse_and_bind ()). */
1906 /* Print the names of functions known to Readline. */
1908 rl_list_funmap_names ()
1911 const char **funmap_names
;
1913 funmap_names
= rl_funmap_names ();
1918 for (i
= 0; funmap_names
[i
]; i
++)
1919 fprintf (rl_outstream
, "%s\n", funmap_names
[i
]);
1921 xfree (funmap_names
);
1925 _rl_get_keyname (key
)
1931 keyname
= (char *)xmalloc (8);
1934 /* Since this is going to be used to write out keysequence-function
1935 pairs for possible inclusion in an inputrc file, we don't want to
1936 do any special meta processing on KEY. */
1939 /* XXX - Experimental */
1940 /* We might want to do this, but the old version of the code did not. */
1942 /* If this is an escape character, we don't want to do any more processing.
1943 Just add the special ESC key sequence and return. */
1953 /* RUBOUT is translated directly into \C-? */
1965 /* Now add special prefixes needed for control characters. This can
1966 potentially change C. */
1969 keyname
[i
++] = '\\';
1972 c
= _rl_to_lower (UNCTRL (c
));
1975 /* XXX experimental code. Turn the characters that are not ASCII or
1976 ISO Latin 1 (128 - 159) into octal escape sequences (\200 - \237).
1978 if (c
>= 128 && c
<= 159)
1980 keyname
[i
++] = '\\';
1983 keyname
[i
++] = (c
/ 8) + '0';
1987 /* Now, if the character needs to be quoted with a backslash, do that. */
1988 if (c
== '\\' || c
== '"')
1989 keyname
[i
++] = '\\';
1991 /* Now add the key, terminate the string, and return it. */
1992 keyname
[i
++] = (char) c
;
1998 /* Return a NULL terminated array of strings which represent the key
1999 sequences that are used to invoke FUNCTION in MAP. */
2001 rl_invoking_keyseqs_in_map (function
, map
)
2002 rl_command_func_t
*function
;
2007 int result_index
, result_size
;
2009 result
= (char **)NULL
;
2010 result_index
= result_size
= 0;
2012 for (key
= 0; key
< KEYMAP_SIZE
; key
++)
2014 switch (map
[key
].type
)
2017 /* Macros match, if, and only if, the pointers are identical.
2018 Thus, they are treated exactly like functions in here. */
2020 /* If the function in the keymap is the one we are looking for,
2021 then add the current KEY to the list of invoking keys. */
2022 if (map
[key
].function
== function
)
2026 keyname
= _rl_get_keyname (key
);
2028 if (result_index
+ 2 > result_size
)
2031 result
= (char **)xrealloc (result
, result_size
* sizeof (char *));
2034 result
[result_index
++] = keyname
;
2035 result
[result_index
] = (char *)NULL
;
2044 /* Find the list of keyseqs in this map which have FUNCTION as
2045 their target. Add the key sequences found to RESULT. */
2046 if (map
[key
].function
)
2048 rl_invoking_keyseqs_in_map (function
, FUNCTION_TO_KEYMAP (map
, key
));
2055 for (i
= 0; seqs
[i
]; i
++)
2057 char *keyname
= (char *)xmalloc (6 + strlen (seqs
[i
]));
2061 /* If ESC is the meta prefix and we're converting chars
2062 with the eighth bit set to ESC-prefixed sequences, then
2063 we can use \M-. Otherwise we need to use the sequence
2065 if (_rl_convert_meta_chars_to_ascii
&& map
[ESC
].type
== ISKMAP
)
2066 sprintf (keyname
, "\\M-");
2068 sprintf (keyname
, "\\e");
2070 else if (CTRL_CHAR (key
))
2071 sprintf (keyname
, "\\C-%c", _rl_to_lower (UNCTRL (key
)));
2072 else if (key
== RUBOUT
)
2073 sprintf (keyname
, "\\C-?");
2074 else if (key
== '\\' || key
== '"')
2077 keyname
[1] = (char) key
;
2082 keyname
[0] = (char) key
;
2086 strcat (keyname
, seqs
[i
]);
2089 if (result_index
+ 2 > result_size
)
2092 result
= (char **)xrealloc (result
, result_size
* sizeof (char *));
2095 result
[result_index
++] = keyname
;
2096 result
[result_index
] = (char *)NULL
;
2107 /* Return a NULL terminated array of strings which represent the key
2108 sequences that can be used to invoke FUNCTION using the current keymap. */
2110 rl_invoking_keyseqs (function
)
2111 rl_command_func_t
*function
;
2113 return (rl_invoking_keyseqs_in_map (function
, _rl_keymap
));
2116 /* Print all of the functions and their bindings to rl_outstream. If
2117 PRINT_READABLY is non-zero, then print the output in such a way
2118 that it can be read back in. */
2120 rl_function_dumper (print_readably
)
2127 names
= rl_funmap_names ();
2129 fprintf (rl_outstream
, "\n");
2131 for (i
= 0; name
= names
[i
]; i
++)
2133 rl_command_func_t
*function
;
2136 function
= rl_named_function (name
);
2137 invokers
= rl_invoking_keyseqs_in_map (function
, _rl_keymap
);
2142 fprintf (rl_outstream
, "# %s (not bound)\n", name
);
2147 for (j
= 0; invokers
[j
]; j
++)
2149 fprintf (rl_outstream
, "\"%s\": %s\n",
2151 xfree (invokers
[j
]);
2160 fprintf (rl_outstream
, "%s is not bound to any keys\n",
2166 fprintf (rl_outstream
, "%s can be found on ", name
);
2168 for (j
= 0; invokers
[j
] && j
< 5; j
++)
2170 fprintf (rl_outstream
, "\"%s\"%s", invokers
[j
],
2171 invokers
[j
+ 1] ? ", " : ".\n");
2174 if (j
== 5 && invokers
[j
])
2175 fprintf (rl_outstream
, "...\n");
2177 for (j
= 0; invokers
[j
]; j
++)
2178 xfree (invokers
[j
]);
2188 /* Print all of the current functions and their bindings to
2189 rl_outstream. If an explicit argument is given, then print
2190 the output in such a way that it can be read back in. */
2192 rl_dump_functions (count
, key
)
2196 fprintf (rl_outstream
, "\r\n");
2197 rl_function_dumper (rl_explicit_arg
);
2203 _rl_macro_dumper_internal (print_readably
, map
, prefix
)
2209 char *keyname
, *out
;
2212 for (key
= 0; key
< KEYMAP_SIZE
; key
++)
2214 switch (map
[key
].type
)
2217 keyname
= _rl_get_keyname (key
);
2218 out
= _rl_untranslate_macro_value ((char *)map
[key
].function
);
2221 fprintf (rl_outstream
, "\"%s%s\": \"%s\"\n", prefix
? prefix
: "",
2225 fprintf (rl_outstream
, "%s%s outputs %s\n", prefix
? prefix
: "",
2234 prefix_len
= prefix
? strlen (prefix
) : 0;
2237 keyname
= (char *)xmalloc (3 + prefix_len
);
2239 strcpy (keyname
, prefix
);
2240 keyname
[prefix_len
] = '\\';
2241 keyname
[prefix_len
+ 1] = 'e';
2242 keyname
[prefix_len
+ 2] = '\0';
2246 keyname
= _rl_get_keyname (key
);
2249 out
= (char *)xmalloc (strlen (keyname
) + prefix_len
+ 1);
2250 strcpy (out
, prefix
);
2251 strcpy (out
+ prefix_len
, keyname
);
2257 _rl_macro_dumper_internal (print_readably
, FUNCTION_TO_KEYMAP (map
, key
), keyname
);
2265 rl_macro_dumper (print_readably
)
2268 _rl_macro_dumper_internal (print_readably
, _rl_keymap
, (char *)NULL
);
2272 rl_dump_macros (count
, key
)
2276 fprintf (rl_outstream
, "\r\n");
2277 rl_macro_dumper (rl_explicit_arg
);
2283 _rl_get_string_variable_value (name
)
2286 static char numbuf
[32];
2289 if (_rl_stricmp (name
, "bell-style") == 0)
2291 switch (_rl_bell_preference
)
2302 else if (_rl_stricmp (name
, "comment-begin") == 0)
2303 return (_rl_comment_begin
? _rl_comment_begin
: RL_COMMENT_BEGIN_DEFAULT
);
2304 else if (_rl_stricmp (name
, "completion-display-width") == 0)
2306 sprintf (numbuf
, "%d", _rl_completion_columns
);
2309 else if (_rl_stricmp (name
, "completion-prefix-display-length") == 0)
2311 sprintf (numbuf
, "%d", _rl_completion_prefix_display_length
);
2314 else if (_rl_stricmp (name
, "completion-query-items") == 0)
2316 sprintf (numbuf
, "%d", rl_completion_query_items
);
2319 else if (_rl_stricmp (name
, "editing-mode") == 0)
2320 return (rl_get_keymap_name_from_edit_mode ());
2321 else if (_rl_stricmp (name
, "history-size") == 0)
2323 sprintf (numbuf
, "%d", history_is_stifled() ? history_max_entries
: 0);
2326 else if (_rl_stricmp (name
, "isearch-terminators") == 0)
2328 if (_rl_isearch_terminators
== 0)
2330 ret
= _rl_untranslate_macro_value (_rl_isearch_terminators
);
2333 strncpy (numbuf
, ret
, sizeof (numbuf
) - 1);
2335 numbuf
[sizeof(numbuf
) - 1] = '\0';
2341 else if (_rl_stricmp (name
, "keymap") == 0)
2343 ret
= rl_get_keymap_name (_rl_keymap
);
2345 ret
= rl_get_keymap_name_from_edit_mode ();
2346 return (ret
? ret
: "none");
2353 rl_variable_dumper (print_readably
)
2359 for (i
= 0; boolean_varlist
[i
].name
; i
++)
2362 fprintf (rl_outstream
, "set %s %s\n", boolean_varlist
[i
].name
,
2363 *boolean_varlist
[i
].value
? "on" : "off");
2365 fprintf (rl_outstream
, "%s is set to `%s'\n", boolean_varlist
[i
].name
,
2366 *boolean_varlist
[i
].value
? "on" : "off");
2369 for (i
= 0; string_varlist
[i
].name
; i
++)
2371 v
= _rl_get_string_variable_value (string_varlist
[i
].name
);
2372 if (v
== 0) /* _rl_isearch_terminators can be NULL */
2375 fprintf (rl_outstream
, "set %s %s\n", string_varlist
[i
].name
, v
);
2377 fprintf (rl_outstream
, "%s is set to `%s'\n", string_varlist
[i
].name
, v
);
2381 /* Print all of the current variables and their values to
2382 rl_outstream. If an explicit argument is given, then print
2383 the output in such a way that it can be read back in. */
2385 rl_dump_variables (count
, key
)
2389 fprintf (rl_outstream
, "\r\n");
2390 rl_variable_dumper (rl_explicit_arg
);
2395 /* Return non-zero if any members of ARRAY are a substring in STRING. */
2397 substring_member_of_array (string
, array
)
2399 const char * const *array
;
2403 if (_rl_strindex (string
, *array
))