1 /* bind.c -- key binding and startup file support for the readline library. */
3 /* Copyright (C) 1987-2009 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 char *_rl_read_file
PARAMS((char *, size_t *));
76 static void _rl_init_file_error
PARAMS((const char *));
77 static int _rl_read_init_file
PARAMS((const char *, int));
78 static int glean_key_from_name
PARAMS((char *));
79 static int find_boolean_var
PARAMS((const char *));
81 static char *_rl_get_string_variable_value
PARAMS((const char *));
82 static int substring_member_of_array
PARAMS((const char *, const char * const *));
84 static int currently_reading_init_file
;
86 /* used only in this file */
87 static int _rl_prefer_visible_bell
= 1;
89 /* **************************************************************** */
93 /* **************************************************************** */
95 /* rl_add_defun (char *name, rl_command_func_t *function, int key)
96 Add NAME to the list of named functions. Make FUNCTION be the function
97 that gets called. If KEY is not -1, then bind it. */
99 rl_add_defun (name
, function
, key
)
101 rl_command_func_t
*function
;
105 rl_bind_key (key
, function
);
106 rl_add_funmap_entry (name
, function
);
110 /* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */
112 rl_bind_key (key
, function
)
114 rl_command_func_t
*function
;
119 if (META_CHAR (key
) && _rl_convert_meta_chars_to_ascii
)
121 if (_rl_keymap
[ESC
].type
== ISKMAP
)
125 escmap
= FUNCTION_TO_KEYMAP (_rl_keymap
, ESC
);
127 escmap
[key
].type
= ISFUNC
;
128 escmap
[key
].function
= function
;
134 _rl_keymap
[key
].type
= ISFUNC
;
135 _rl_keymap
[key
].function
= function
;
136 rl_binding_keymap
= _rl_keymap
;
140 /* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid
143 rl_bind_key_in_map (key
, function
, map
)
145 rl_command_func_t
*function
;
153 result
= rl_bind_key (key
, function
);
158 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
159 now, this is always used to attempt to bind the arrow keys, hence the
160 check for rl_vi_movement_mode. */
162 rl_bind_key_if_unbound_in_map (key
, default_func
, kmap
)
164 rl_command_func_t
*default_func
;
169 keyseq
[0] = (unsigned char)key
;
171 return (rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, kmap
));
175 rl_bind_key_if_unbound (key
, default_func
)
177 rl_command_func_t
*default_func
;
181 keyseq
[0] = (unsigned char)key
;
183 return (rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, _rl_keymap
));
186 /* Make KEY do nothing in the currently selected keymap.
187 Returns non-zero in case of error. */
192 return (rl_bind_key (key
, (rl_command_func_t
*)NULL
));
195 /* Make KEY do nothing in MAP.
196 Returns non-zero in case of error. */
198 rl_unbind_key_in_map (key
, map
)
202 return (rl_bind_key_in_map (key
, (rl_command_func_t
*)NULL
, map
));
205 /* Unbind all keys bound to FUNCTION in MAP. */
207 rl_unbind_function_in_map (func
, map
)
208 rl_command_func_t
*func
;
211 register int i
, rval
;
213 for (i
= rval
= 0; i
< KEYMAP_SIZE
; i
++)
215 if (map
[i
].type
== ISFUNC
&& map
[i
].function
== func
)
217 map
[i
].function
= (rl_command_func_t
*)NULL
;
225 rl_unbind_command_in_map (command
, map
)
229 rl_command_func_t
*func
;
231 func
= rl_named_function (command
);
234 return (rl_unbind_function_in_map (func
, map
));
237 /* Bind the key sequence represented by the string KEYSEQ to
238 FUNCTION, starting in the current keymap. This makes new
239 keymaps as necessary. */
241 rl_bind_keyseq (keyseq
, function
)
243 rl_command_func_t
*function
;
245 return (rl_generic_bind (ISFUNC
, keyseq
, (char *)function
, _rl_keymap
));
248 /* Bind the key sequence represented by the string KEYSEQ to
249 FUNCTION. This makes new keymaps as necessary. The initial
250 place to do bindings is in MAP. */
252 rl_bind_keyseq_in_map (keyseq
, function
, map
)
254 rl_command_func_t
*function
;
257 return (rl_generic_bind (ISFUNC
, keyseq
, (char *)function
, map
));
260 /* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
262 rl_set_key (keyseq
, function
, map
)
264 rl_command_func_t
*function
;
267 return (rl_generic_bind (ISFUNC
, keyseq
, (char *)function
, map
));
270 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
271 now, this is always used to attempt to bind the arrow keys, hence the
272 check for rl_vi_movement_mode. */
274 rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, kmap
)
276 rl_command_func_t
*default_func
;
279 rl_command_func_t
*func
;
283 func
= rl_function_of_keyseq (keyseq
, kmap
, (int *)NULL
);
284 #if defined (VI_MODE)
285 if (!func
|| func
== rl_do_lowercase_version
|| func
== rl_vi_movement_mode
)
287 if (!func
|| func
== rl_do_lowercase_version
)
289 return (rl_bind_keyseq_in_map (keyseq
, default_func
, kmap
));
297 rl_bind_keyseq_if_unbound (keyseq
, default_func
)
299 rl_command_func_t
*default_func
;
301 return (rl_bind_keyseq_if_unbound_in_map (keyseq
, default_func
, _rl_keymap
));
304 /* Bind the key sequence represented by the string KEYSEQ to
305 the string of characters MACRO. This makes new keymaps as
306 necessary. The initial place to do bindings is in MAP. */
308 rl_macro_bind (keyseq
, macro
, map
)
309 const char *keyseq
, *macro
;
315 macro_keys
= (char *)xmalloc ((2 * strlen (macro
)) + 1);
317 if (rl_translate_keyseq (macro
, macro_keys
, ¯o_keys_len
))
322 rl_generic_bind (ISMACR
, keyseq
, macro_keys
, map
);
326 /* Bind the key sequence represented by the string KEYSEQ to
327 the arbitrary pointer DATA. TYPE says what kind of data is
328 pointed to by DATA, right now this can be a function (ISFUNC),
329 a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps
330 as necessary. The initial place to do bindings is in MAP. */
332 rl_generic_bind (type
, keyseq
, data
, map
)
345 /* If no keys to bind to, exit right away. */
346 if (keyseq
== 0 || *keyseq
== 0)
353 keys
= (char *)xmalloc (1 + (2 * strlen (keyseq
)));
355 /* Translate the ASCII representation of KEYSEQ into an array of
356 characters. Stuff the characters into KEYS, and the length of
357 KEYS into KEYS_LEN. */
358 if (rl_translate_keyseq (keyseq
, keys
, &keys_len
))
364 /* Bind keys, making new keymaps as necessary. */
365 for (i
= 0; i
< keys_len
; i
++)
367 unsigned char uc
= keys
[i
];
371 if (ic
< 0 || ic
>= KEYMAP_SIZE
)
377 if (META_CHAR (ic
) && _rl_convert_meta_chars_to_ascii
)
380 if (map
[ESC
].type
== ISKMAP
)
381 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
384 if ((i
+ 1) < keys_len
)
386 if (map
[ic
].type
!= ISKMAP
)
388 /* We allow subsequences of keys. If a keymap is being
389 created that will `shadow' an existing function or macro
390 key binding, we save that keybinding into the ANYOTHERKEY
391 index in the new map. The dispatch code will look there
392 to find the function to execute if the subsequence is not
393 matched. ANYOTHERKEY was chosen to be greater than
397 map
[ic
].type
= ISKMAP
;
398 map
[ic
].function
= KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
400 map
= FUNCTION_TO_KEYMAP (map
, ic
);
401 /* The dispatch code will return this function if no matching
402 key sequence is found in the keymap. This (with a little
403 help from the dispatch code in readline.c) allows `a' to be
404 mapped to something, `abc' to be mapped to something else,
405 and the function bound to `a' to be executed when the user
406 types `abx', leaving `bx' in the input queue. */
407 if (k
.function
&& ((k
.type
== ISFUNC
&& k
.function
!= rl_do_lowercase_version
) || k
.type
== ISMACR
))
409 map
[ANYOTHERKEY
] = k
;
415 if (map
[ic
].type
== ISMACR
)
416 xfree ((char *)map
[ic
].function
);
417 else if (map
[ic
].type
== ISKMAP
)
419 map
= FUNCTION_TO_KEYMAP (map
, ic
);
423 map
[ic
].function
= KEYMAP_TO_FUNCTION (data
);
427 rl_binding_keymap
= map
;
433 /* Translate the ASCII representation of SEQ, stuffing the values into ARRAY,
434 an array of characters. LEN gets the final length of ARRAY. Return
435 non-zero if there was an error parsing SEQ. */
437 rl_translate_keyseq (seq
, array
, len
)
442 register int i
, c
, l
, temp
;
444 for (i
= l
= 0; c
= seq
[i
]; i
++)
453 /* Handle \C- and \M- prefixes. */
454 if ((c
== 'C' || c
== 'M') && seq
[i
+ 1] == '-')
456 /* Handle special case of backwards define. */
457 if (strncmp (&seq
[i
], "C-\\M-", 5) == 0)
459 array
[l
++] = ESC
; /* ESC is meta-prefix */
461 array
[l
++] = CTRL (_rl_to_upper (seq
[i
]));
467 i
++; /* seq[i] == '-' */
468 /* XXX - obey convert-meta setting */
469 if (_rl_convert_meta_chars_to_ascii
&& _rl_keymap
[ESC
].type
== ISKMAP
)
470 array
[l
++] = ESC
; /* ESC is meta-prefix */
471 else if (seq
[i
+1] == '\\' && seq
[i
+2] == 'C' && seq
[i
+3] == '-')
474 temp
= (seq
[i
] == '?') ? RUBOUT
: CTRL (_rl_to_upper (seq
[i
]));
475 array
[l
++] = META (temp
);
479 /* This doesn't yet handle things like \M-\a, which may
480 or may not have any reasonable meaning. You're
481 probably better off using straight octal or hex. */
483 array
[l
++] = META (seq
[i
]);
489 /* Special hack for C-?... */
490 array
[l
++] = (seq
[i
] == '?') ? RUBOUT
: CTRL (_rl_to_upper (seq
[i
]));
495 /* Translate other backslash-escaped characters. These are the
496 same escape sequences that bash's `echo' and `printf' builtins
497 handle, with the addition of \d -> RUBOUT. A backslash
498 preceding a character that is not special is stripped. */
508 array
[l
++] = RUBOUT
; /* readline-specific */
517 array
[l
++] = NEWLINE
;
531 case '0': case '1': case '2': case '3':
532 case '4': case '5': case '6': case '7':
534 for (temp
= 2, c
-= '0'; ISOCTAL (seq
[i
]) && temp
--; i
++)
535 c
= (c
* 8) + OCTVALUE (seq
[i
]);
536 i
--; /* auto-increment in for loop */
537 array
[l
++] = c
& largest_char
;
541 for (temp
= 2, c
= 0; ISXDIGIT ((unsigned char)seq
[i
]) && temp
--; i
++)
542 c
= (c
* 16) + HEXVALUE (seq
[i
]);
545 i
--; /* auto-increment in for loop */
546 array
[l
++] = c
& largest_char
;
548 default: /* backslashes before non-special chars just add the char */
550 break; /* the backslash is stripped */
564 rl_untranslate_keyseq (seq
)
567 static char kseq
[16];
584 else if (CTRL_CHAR (c
))
589 c
= _rl_to_lower (UNCTRL (c
));
591 else if (c
== RUBOUT
)
604 else if (c
== '\\' || c
== '"')
609 kseq
[i
++] = (unsigned char) c
;
615 _rl_untranslate_macro_value (seq
)
621 r
= ret
= (char *)xmalloc (7 * strlen (seq
) + 1);
622 for (s
= seq
; *s
; s
++)
637 else if (CTRL_CHAR (c
))
642 c
= _rl_to_lower (UNCTRL (c
));
644 else if (c
== RUBOUT
)
657 else if (c
== '\\' || c
== '"')
660 *r
++ = (unsigned char)c
;
666 /* Return a pointer to the function that STRING represents.
667 If STRING doesn't have a matching function, then a NULL pointer
670 rl_named_function (string
)
675 rl_initialize_funmap ();
677 for (i
= 0; funmap
[i
]; i
++)
678 if (_rl_stricmp (funmap
[i
]->name
, string
) == 0)
679 return (funmap
[i
]->function
);
680 return ((rl_command_func_t
*)NULL
);
683 /* Return the function (or macro) definition which would be invoked via
684 KEYSEQ if executed in MAP. If MAP is NULL, then the current keymap is
685 used. TYPE, if non-NULL, is a pointer to an int which will receive the
686 type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),
687 or ISMACR (macro). */
689 rl_function_of_keyseq (keyseq
, map
, type
)
699 for (i
= 0; keyseq
&& keyseq
[i
]; i
++)
701 unsigned char ic
= keyseq
[i
];
703 if (META_CHAR (ic
) && _rl_convert_meta_chars_to_ascii
)
705 if (map
[ESC
].type
== ISKMAP
)
707 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
710 /* XXX - should we just return NULL here, since this obviously
715 *type
= map
[ESC
].type
;
717 return (map
[ESC
].function
);
721 if (map
[ic
].type
== ISKMAP
)
723 /* If this is the last key in the key sequence, return the
725 if (keyseq
[i
+ 1] == '\0')
730 return (map
[ic
].function
);
733 map
= FUNCTION_TO_KEYMAP (map
, ic
);
735 /* If we're not at the end of the key sequence, and the current key
736 is bound to something other than a keymap, then the entire key
737 sequence is not bound. */
738 else if (map
[ic
].type
!= ISKMAP
&& keyseq
[i
+1])
739 return ((rl_command_func_t
*)NULL
);
740 else /* map[ic].type != ISKMAP && keyseq[i+1] == 0 */
743 *type
= map
[ic
].type
;
745 return (map
[ic
].function
);
748 return ((rl_command_func_t
*) NULL
);
751 /* The last key bindings file read. */
752 static char *last_readline_init_file
= (char *)NULL
;
754 /* The file we're currently reading key bindings from. */
755 static const char *current_readline_init_file
;
756 static int current_readline_init_include_level
;
757 static int current_readline_init_lineno
;
759 /* Read FILENAME into a locally-allocated buffer and return the buffer.
760 The size of the buffer is returned in *SIZEP. Returns NULL if any
761 errors were encountered. */
763 _rl_read_file (filename
, sizep
)
772 if ((stat (filename
, &finfo
) < 0) || (file
= open (filename
, O_RDONLY
, 0666)) < 0)
773 return ((char *)NULL
);
775 file_size
= (size_t)finfo
.st_size
;
777 /* check for overflow on very large files */
778 if (file_size
!= finfo
.st_size
|| file_size
+ 1 < file_size
)
785 return ((char *)NULL
);
788 /* Read the file into BUFFER. */
789 buffer
= (char *)xmalloc (file_size
+ 1);
790 i
= read (file
, buffer
, file_size
);
796 return ((char *)NULL
);
806 /* Re-read the current keybindings file. */
808 rl_re_read_init_file (count
, ignore
)
812 r
= rl_read_init_file ((const char *)NULL
);
813 rl_set_keymap_from_edit_mode ();
817 /* Do key bindings from a file. If FILENAME is NULL it defaults
818 to the first non-null filename from this list:
819 1. the filename used for the previous call
820 2. the value of the shell variable `INPUTRC'
823 If the file existed and could be opened and read, 0 is returned,
824 otherwise errno is returned. */
826 rl_read_init_file (filename
)
827 const char *filename
;
829 /* Default the filename. */
831 filename
= last_readline_init_file
;
833 filename
= sh_get_env_value ("INPUTRC");
834 if (filename
== 0 || *filename
== 0)
836 filename
= DEFAULT_INPUTRC
;
837 /* Try to read DEFAULT_INPUTRC; fall back to SYS_INPUTRC on failure */
838 if (_rl_read_init_file (filename
, 0) == 0)
840 filename
= SYS_INPUTRC
;
843 #if defined (__MSDOS__)
844 if (_rl_read_init_file (filename
, 0) == 0)
846 filename
= "~/_inputrc";
848 return (_rl_read_init_file (filename
, 0));
852 _rl_read_init_file (filename
, include_level
)
853 const char *filename
;
857 char *buffer
, *openname
, *line
, *end
;
860 current_readline_init_file
= filename
;
861 current_readline_init_include_level
= include_level
;
863 openname
= tilde_expand (filename
);
864 buffer
= _rl_read_file (openname
, &file_size
);
870 if (include_level
== 0 && filename
!= last_readline_init_file
)
872 FREE (last_readline_init_file
);
873 last_readline_init_file
= savestring (filename
);
876 currently_reading_init_file
= 1;
878 /* Loop over the lines in the file. Lines that start with `#' are
879 comments; all other lines are commands for readline initialization. */
880 current_readline_init_lineno
= 1;
882 end
= buffer
+ file_size
;
885 /* Find the end of this line. */
886 for (i
= 0; line
+ i
!= end
&& line
[i
] != '\n'; i
++);
888 #if defined (__CYGWIN__)
889 /* ``Be liberal in what you accept.'' */
890 if (line
[i
] == '\n' && line
[i
-1] == '\r')
894 /* Mark end of line. */
897 /* Skip leading whitespace. */
898 while (*line
&& whitespace (*line
))
904 /* If the line is not a comment, then parse it. */
905 if (*line
&& *line
!= '#')
906 rl_parse_and_bind (line
);
908 /* Move to the next line. */
910 current_readline_init_lineno
++;
914 currently_reading_init_file
= 0;
919 _rl_init_file_error (msg
)
922 if (currently_reading_init_file
)
923 _rl_errmsg ("%s: line %d: %s\n", current_readline_init_file
,
924 current_readline_init_lineno
, msg
);
926 _rl_errmsg ("%s", msg
);
929 /* **************************************************************** */
931 /* Parser Directives */
933 /* **************************************************************** */
935 typedef int _rl_parser_func_t
PARAMS((char *));
937 /* Things that mean `Control'. */
938 const char * const _rl_possible_control_prefixes
[] = {
939 "Control-", "C-", "CTRL-", (const char *)NULL
942 const char * const _rl_possible_meta_prefixes
[] = {
943 "Meta", "M-", (const char *)NULL
948 /* Calling programs set this to have their argv[0]. */
949 const char *rl_readline_name
= "other";
951 /* Stack of previous values of parsing_conditionalized_out. */
952 static unsigned char *if_stack
= (unsigned char *)NULL
;
953 static int if_stack_depth
;
954 static int if_stack_size
;
956 /* Push _rl_parsing_conditionalized_out, and set parser state based
964 /* Push parser state. */
965 if (if_stack_depth
+ 1 >= if_stack_size
)
968 if_stack
= (unsigned char *)xmalloc (if_stack_size
= 20);
970 if_stack
= (unsigned char *)xrealloc (if_stack
, if_stack_size
+= 20);
972 if_stack
[if_stack_depth
++] = _rl_parsing_conditionalized_out
;
974 /* If parsing is turned off, then nothing can turn it back on except
975 for finding the matching endif. In that case, return right now. */
976 if (_rl_parsing_conditionalized_out
)
979 /* Isolate first argument. */
980 for (i
= 0; args
[i
] && !whitespace (args
[i
]); i
++);
985 /* Handle "$if term=foo" and "$if mode=emacs" constructs. If this
986 isn't term=foo, or mode=emacs, then check to see if the first
987 word in ARGS is the same as the value stored in rl_readline_name. */
988 if (rl_terminal_name
&& _rl_strnicmp (args
, "term=", 5) == 0)
992 /* Terminals like "aaa-60" are equivalent to "aaa". */
993 tname
= savestring (rl_terminal_name
);
994 tem
= strchr (tname
, '-');
998 /* Test the `long' and `short' forms of the terminal name so that
999 if someone has a `sun-cmd' and does not want to have bindings
1000 that will be executed if the terminal is a `sun', they can put
1001 `$if term=sun-cmd' into their .inputrc. */
1002 _rl_parsing_conditionalized_out
= _rl_stricmp (args
+ 5, tname
) &&
1003 _rl_stricmp (args
+ 5, rl_terminal_name
);
1006 #if defined (VI_MODE)
1007 else if (_rl_strnicmp (args
, "mode=", 5) == 0)
1011 if (_rl_stricmp (args
+ 5, "emacs") == 0)
1013 else if (_rl_stricmp (args
+ 5, "vi") == 0)
1018 _rl_parsing_conditionalized_out
= mode
!= rl_editing_mode
;
1020 #endif /* VI_MODE */
1021 /* Check to see if the first word in ARGS is the same as the
1022 value stored in rl_readline_name. */
1023 else if (_rl_stricmp (args
, rl_readline_name
) == 0)
1024 _rl_parsing_conditionalized_out
= 0;
1026 _rl_parsing_conditionalized_out
= 1;
1030 /* Invert the current parser state if there is anything on the stack. */
1037 if (if_stack_depth
== 0)
1039 _rl_init_file_error ("$else found without matching $if");
1044 /* Check the previous (n - 1) levels of the stack to make sure that
1045 we haven't previously turned off parsing. */
1046 for (i
= 0; i
< if_stack_depth
- 1; i
++)
1048 /* Check the previous (n) levels of the stack to make sure that
1049 we haven't previously turned off parsing. */
1050 for (i
= 0; i
< if_stack_depth
; i
++)
1052 if (if_stack
[i
] == 1)
1055 /* Invert the state of parsing if at top level. */
1056 _rl_parsing_conditionalized_out
= !_rl_parsing_conditionalized_out
;
1060 /* Terminate a conditional, popping the value of
1061 _rl_parsing_conditionalized_out from the stack. */
1067 _rl_parsing_conditionalized_out
= if_stack
[--if_stack_depth
];
1069 _rl_init_file_error ("$endif without matching $if");
1074 parser_include (args
)
1077 const char *old_init_file
;
1079 int old_line_number
, old_include_level
, r
;
1081 if (_rl_parsing_conditionalized_out
)
1084 old_init_file
= current_readline_init_file
;
1085 old_line_number
= current_readline_init_lineno
;
1086 old_include_level
= current_readline_init_include_level
;
1088 e
= strchr (args
, '\n');
1091 r
= _rl_read_init_file ((const char *)args
, old_include_level
+ 1);
1093 current_readline_init_file
= old_init_file
;
1094 current_readline_init_lineno
= old_line_number
;
1095 current_readline_init_include_level
= old_include_level
;
1100 /* Associate textual names with actual functions. */
1101 static const struct {
1102 const char * const name
;
1103 _rl_parser_func_t
*function
;
1104 } parser_directives
[] = {
1105 { "if", parser_if
},
1106 { "endif", parser_endif
},
1107 { "else", parser_else
},
1108 { "include", parser_include
},
1109 { (char *)0x0, (_rl_parser_func_t
*)0x0 }
1112 /* Handle a parser directive. STATEMENT is the line of the directive
1113 without any leading `$'. */
1115 handle_parser_directive (statement
)
1119 char *directive
, *args
;
1121 /* Isolate the actual directive. */
1123 /* Skip whitespace. */
1124 for (i
= 0; whitespace (statement
[i
]); i
++);
1126 directive
= &statement
[i
];
1128 for (; statement
[i
] && !whitespace (statement
[i
]); i
++);
1131 statement
[i
++] = '\0';
1133 for (; statement
[i
] && whitespace (statement
[i
]); i
++);
1135 args
= &statement
[i
];
1137 /* Lookup the command, and act on it. */
1138 for (i
= 0; parser_directives
[i
].name
; i
++)
1139 if (_rl_stricmp (directive
, parser_directives
[i
].name
) == 0)
1141 (*parser_directives
[i
].function
) (args
);
1145 /* display an error message about the unknown parser directive */
1146 _rl_init_file_error ("unknown parser directive");
1150 /* Read the binding command from STRING and perform it.
1151 A key binding command looks like: Keyname: function-name\0,
1152 a variable binding command looks like: set variable value.
1153 A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
1155 rl_parse_and_bind (string
)
1158 char *funname
, *kname
;
1160 int key
, equivalency
;
1162 while (string
&& whitespace (*string
))
1165 if (!string
|| !*string
|| *string
== '#')
1168 /* If this is a parser directive, act on it. */
1171 handle_parser_directive (&string
[1]);
1175 /* If we aren't supposed to be parsing right now, then we're done. */
1176 if (_rl_parsing_conditionalized_out
)
1180 /* If this keyname is a complex key expression surrounded by quotes,
1181 advance to after the matching close quote. This code allows the
1182 backslash to quote characters in the key expression. */
1187 for (i
= 1; c
= string
[i
]; i
++)
1204 /* If we didn't find a closing quote, abort the line. */
1205 if (string
[i
] == '\0')
1207 _rl_init_file_error ("no closing `\"' in key binding");
1212 /* Advance to the colon (:) or whitespace which separates the two objects. */
1213 for (; (c
= string
[i
]) && c
!= ':' && c
!= ' ' && c
!= '\t'; i
++ );
1215 equivalency
= (c
== ':' && string
[i
+ 1] == '=');
1217 /* Mark the end of the command (or keyname). */
1221 /* If doing assignment, skip the '=' sign as well. */
1225 /* If this is a command to set a variable, then do that. */
1226 if (_rl_stricmp (string
, "set") == 0)
1228 char *var
, *value
, *e
;
1231 /* Make VAR point to start of variable name. */
1232 while (*var
&& whitespace (*var
)) var
++;
1234 /* Make VALUE point to start of value string. */
1236 while (*value
&& !whitespace (*value
)) value
++;
1239 while (*value
&& whitespace (*value
)) value
++;
1241 /* Strip trailing whitespace from values to boolean variables. Temp
1242 fix until I get a real quoted-string parser here. */
1243 i
= find_boolean_var (var
);
1246 /* remove trailing whitespace */
1247 e
= value
+ strlen (value
) - 1;
1248 while (e
>= value
&& whitespace (*e
))
1250 e
++; /* skip back to whitespace or EOS */
1251 if (*e
&& e
>= value
)
1255 rl_variable_bind (var
, value
);
1259 /* Skip any whitespace between keyname and funname. */
1260 for (; string
[i
] && whitespace (string
[i
]); i
++);
1261 funname
= &string
[i
];
1263 /* Now isolate funname.
1264 For straight function names just look for whitespace, since
1265 that will signify the end of the string. But this could be a
1266 macro definition. In that case, the string is quoted, so skip
1267 to the matching delimiter. We allow the backslash to quote the
1268 delimiter characters in the macro body. */
1269 /* This code exists to allow whitespace in macro expansions, which
1270 would otherwise be gobbled up by the next `for' loop.*/
1271 /* XXX - it may be desirable to allow backslash quoting only if " is
1272 the quoted string delimiter, like the shell. */
1273 if (*funname
== '\'' || *funname
== '"')
1275 int delimiter
, passc
;
1277 delimiter
= string
[i
++];
1278 for (passc
= 0; c
= string
[i
]; i
++)
1299 /* Advance to the end of the string. */
1300 for (; string
[i
] && !whitespace (string
[i
]); i
++);
1302 /* No extra whitespace at the end of the string. */
1305 /* Handle equivalency bindings here. Make the left-hand side be exactly
1306 whatever the right-hand evaluates to, including keymaps. */
1312 /* If this is a new-style key-binding, then do the binding with
1313 rl_bind_keyseq (). Otherwise, let the older code deal with it. */
1317 register int j
, k
, passc
;
1319 seq
= (char *)xmalloc (1 + strlen (string
));
1320 for (j
= 1, k
= passc
= 0; string
[j
]; j
++)
1322 /* Allow backslash to quote characters, but leave them in place.
1323 This allows a string to end with a backslash quoting another
1324 backslash, or with a backslash quoting a double quote. The
1325 backslashes are left in place for rl_translate_keyseq (). */
1326 if (passc
|| (string
[j
] == '\\'))
1328 seq
[k
++] = string
[j
];
1333 if (string
[j
] == '"')
1336 seq
[k
++] = string
[j
];
1340 /* Binding macro? */
1341 if (*funname
== '\'' || *funname
== '"')
1343 j
= strlen (funname
);
1345 /* Remove the delimiting quotes from each end of FUNNAME. */
1346 if (j
&& funname
[j
- 1] == *funname
)
1347 funname
[j
- 1] = '\0';
1349 rl_macro_bind (seq
, &funname
[1], _rl_keymap
);
1352 rl_bind_keyseq (seq
, rl_named_function (funname
));
1358 /* Get the actual character we want to deal with. */
1359 kname
= strrchr (string
, '-');
1365 key
= glean_key_from_name (kname
);
1367 /* Add in control and meta bits. */
1368 if (substring_member_of_array (string
, _rl_possible_control_prefixes
))
1369 key
= CTRL (_rl_to_upper (key
));
1371 if (substring_member_of_array (string
, _rl_possible_meta_prefixes
))
1374 /* Temporary. Handle old-style keyname with macro-binding. */
1375 if (*funname
== '\'' || *funname
== '"')
1378 int fl
= strlen (funname
);
1380 useq
[0] = key
; useq
[1] = '\0';
1381 if (fl
&& funname
[fl
- 1] == *funname
)
1382 funname
[fl
- 1] = '\0';
1384 rl_macro_bind (useq
, &funname
[1], _rl_keymap
);
1386 #if defined (PREFIX_META_HACK)
1387 /* Ugly, but working hack to keep prefix-meta around. */
1388 else if (_rl_stricmp (funname
, "prefix-meta") == 0)
1394 rl_generic_bind (ISKMAP
, seq
, (char *)emacs_meta_keymap
, _rl_keymap
);
1396 #endif /* PREFIX_META_HACK */
1398 rl_bind_key (key
, rl_named_function (funname
));
1402 /* Simple structure for boolean readline variables (i.e., those that can
1403 have one of two values; either "On" or 1 for truth, or "Off" or 0 for
1406 #define V_SPECIAL 0x1
1408 static const struct {
1409 const char * const name
;
1412 } boolean_varlist
[] = {
1413 { "bind-tty-special-chars", &_rl_bind_stty_chars
, 0 },
1414 { "blink-matching-paren", &rl_blink_matching_paren
, V_SPECIAL
},
1415 { "byte-oriented", &rl_byte_oriented
, 0 },
1416 { "completion-ignore-case", &_rl_completion_case_fold
, 0 },
1417 { "convert-meta", &_rl_convert_meta_chars_to_ascii
, 0 },
1418 { "disable-completion", &rl_inhibit_completion
, 0 },
1419 { "enable-keypad", &_rl_enable_keypad
, 0 },
1420 { "expand-tilde", &rl_complete_with_tilde_expansion
, 0 },
1421 { "history-preserve-point", &_rl_history_preserve_point
, 0 },
1422 { "horizontal-scroll-mode", &_rl_horizontal_scroll_mode
, 0 },
1423 { "input-meta", &_rl_meta_flag
, 0 },
1424 { "mark-directories", &_rl_complete_mark_directories
, 0 },
1425 { "mark-modified-lines", &_rl_mark_modified_lines
, 0 },
1426 { "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs
, 0 },
1427 { "match-hidden-files", &_rl_match_hidden_files
, 0 },
1428 { "meta-flag", &_rl_meta_flag
, 0 },
1429 { "output-meta", &_rl_output_meta_chars
, 0 },
1430 { "page-completions", &_rl_page_completions
, 0 },
1431 { "prefer-visible-bell", &_rl_prefer_visible_bell
, V_SPECIAL
},
1432 { "print-completions-horizontally", &_rl_print_completions_horizontally
, 0 },
1433 { "revert-all-at-newline", &_rl_revert_all_at_newline
, 0 },
1434 { "show-all-if-ambiguous", &_rl_complete_show_all
, 0 },
1435 { "show-all-if-unmodified", &_rl_complete_show_unmodified
, 0 },
1436 #if defined (VISIBLE_STATS)
1437 { "visible-stats", &rl_visible_stats
, 0 },
1438 #endif /* VISIBLE_STATS */
1439 { (char *)NULL
, (int *)NULL
}
1443 find_boolean_var (name
)
1448 for (i
= 0; boolean_varlist
[i
].name
; i
++)
1449 if (_rl_stricmp (name
, boolean_varlist
[i
].name
) == 0)
1454 /* Hooks for handling special boolean variables, where a
1455 function needs to be called or another variable needs
1456 to be changed when they're changed. */
1458 hack_special_boolean_var (i
)
1463 name
= boolean_varlist
[i
].name
;
1465 if (_rl_stricmp (name
, "blink-matching-paren") == 0)
1466 _rl_enable_paren_matching (rl_blink_matching_paren
);
1467 else if (_rl_stricmp (name
, "prefer-visible-bell") == 0)
1469 if (_rl_prefer_visible_bell
)
1470 _rl_bell_preference
= VISIBLE_BELL
;
1472 _rl_bell_preference
= AUDIBLE_BELL
;
1476 typedef int _rl_sv_func_t
PARAMS((const char *));
1478 /* These *must* correspond to the array indices for the appropriate
1479 string variable. (Though they're not used right now.) */
1480 #define V_BELLSTYLE 0
1481 #define V_COMBEGIN 1
1482 #define V_EDITMODE 2
1483 #define V_ISRCHTERM 3
1489 /* Forward declarations */
1490 static int sv_bell_style
PARAMS((const char *));
1491 static int sv_combegin
PARAMS((const char *));
1492 static int sv_dispprefix
PARAMS((const char *));
1493 static int sv_compquery
PARAMS((const char *));
1494 static int sv_editmode
PARAMS((const char *));
1495 static int sv_histsize
PARAMS((const char *));
1496 static int sv_isrchterm
PARAMS((const char *));
1497 static int sv_keymap
PARAMS((const char *));
1499 static const struct {
1500 const char * const name
;
1502 _rl_sv_func_t
*set_func
;
1503 } string_varlist
[] = {
1504 { "bell-style", V_STRING
, sv_bell_style
},
1505 { "comment-begin", V_STRING
, sv_combegin
},
1506 { "completion-prefix-display-length", V_INT
, sv_dispprefix
},
1507 { "completion-query-items", V_INT
, sv_compquery
},
1508 { "editing-mode", V_STRING
, sv_editmode
},
1509 { "history-size", V_INT
, sv_histsize
},
1510 { "isearch-terminators", V_STRING
, sv_isrchterm
},
1511 { "keymap", V_STRING
, sv_keymap
},
1516 find_string_var (name
)
1521 for (i
= 0; string_varlist
[i
].name
; i
++)
1522 if (_rl_stricmp (name
, string_varlist
[i
].name
) == 0)
1527 /* A boolean value that can appear in a `set variable' command is true if
1528 the value is null or empty, `on' (case-insenstive), or "1". Any other
1529 values result in 0 (false). */
1534 return (value
== 0 || *value
== '\0' ||
1535 (_rl_stricmp (value
, "on") == 0) ||
1536 (value
[0] == '1' && value
[1] == '\0'));
1540 rl_variable_value (name
)
1545 /* Check for simple variables first. */
1546 i
= find_boolean_var (name
);
1548 return (*boolean_varlist
[i
].value
? "on" : "off");
1550 i
= find_string_var (name
);
1552 return (_rl_get_string_variable_value (string_varlist
[i
].name
));
1554 /* Unknown variable names return NULL. */
1559 rl_variable_bind (name
, value
)
1560 const char *name
, *value
;
1565 /* Check for simple variables first. */
1566 i
= find_boolean_var (name
);
1569 *boolean_varlist
[i
].value
= bool_to_int (value
);
1570 if (boolean_varlist
[i
].flags
& V_SPECIAL
)
1571 hack_special_boolean_var (i
);
1575 i
= find_string_var (name
);
1577 /* For the time being, unknown variable names or string names without a
1578 handler function are simply ignored. */
1579 if (i
< 0 || string_varlist
[i
].set_func
== 0)
1582 v
= (*string_varlist
[i
].set_func
) (value
);
1590 if (_rl_strnicmp (value
, "vi", 2) == 0)
1592 #if defined (VI_MODE)
1593 _rl_keymap
= vi_insertion_keymap
;
1594 rl_editing_mode
= vi_mode
;
1595 #endif /* VI_MODE */
1598 else if (_rl_strnicmp (value
, "emacs", 5) == 0)
1600 _rl_keymap
= emacs_standard_keymap
;
1601 rl_editing_mode
= emacs_mode
;
1611 if (value
&& *value
)
1613 FREE (_rl_comment_begin
);
1614 _rl_comment_begin
= savestring (value
);
1621 sv_dispprefix (value
)
1626 if (value
&& *value
)
1628 nval
= atoi (value
);
1632 _rl_completion_prefix_display_length
= nval
;
1637 sv_compquery (value
)
1642 if (value
&& *value
)
1644 nval
= atoi (value
);
1648 rl_completion_query_items
= nval
;
1658 if (value
&& *value
)
1660 nval
= atoi (value
);
1664 stifle_history (nval
);
1674 kmap
= rl_get_keymap_by_name (value
);
1677 rl_set_keymap (kmap
);
1684 sv_bell_style (value
)
1687 if (value
== 0 || *value
== '\0')
1688 _rl_bell_preference
= AUDIBLE_BELL
;
1689 else if (_rl_stricmp (value
, "none") == 0 || _rl_stricmp (value
, "off") == 0)
1690 _rl_bell_preference
= NO_BELL
;
1691 else if (_rl_stricmp (value
, "audible") == 0 || _rl_stricmp (value
, "on") == 0)
1692 _rl_bell_preference
= AUDIBLE_BELL
;
1693 else if (_rl_stricmp (value
, "visible") == 0)
1694 _rl_bell_preference
= VISIBLE_BELL
;
1701 sv_isrchterm (value
)
1704 int beg
, end
, delim
;
1710 /* Isolate the value and translate it into a character string. */
1711 v
= savestring (value
);
1712 FREE (_rl_isearch_terminators
);
1713 if (v
[0] == '"' || v
[0] == '\'')
1716 for (beg
= end
= 1; v
[end
] && v
[end
] != delim
; end
++)
1721 for (beg
= end
= 0; whitespace (v
[end
]) == 0; end
++)
1727 /* The value starts at v + beg. Translate it into a character string. */
1728 _rl_isearch_terminators
= (char *)xmalloc (2 * strlen (v
) + 1);
1729 rl_translate_keyseq (v
+ beg
, _rl_isearch_terminators
, &end
);
1730 _rl_isearch_terminators
[end
] = '\0';
1736 /* Return the character which matches NAME.
1737 For example, `Space' returns ' '. */
1740 const char * const name
;
1744 static const assoc_list name_key_alist
[] = {
1747 { "Escape", '\033' },
1749 { "Newline", '\n' },
1760 glean_key_from_name (name
)
1765 for (i
= 0; name_key_alist
[i
].name
; i
++)
1766 if (_rl_stricmp (name
, name_key_alist
[i
].name
) == 0)
1767 return (name_key_alist
[i
].value
);
1769 return (*(unsigned char *)name
); /* XXX was return (*name) */
1772 /* Auxiliary functions to manage keymaps. */
1773 static const struct {
1774 const char * const name
;
1776 } keymap_names
[] = {
1777 { "emacs", emacs_standard_keymap
},
1778 { "emacs-standard", emacs_standard_keymap
},
1779 { "emacs-meta", emacs_meta_keymap
},
1780 { "emacs-ctlx", emacs_ctlx_keymap
},
1781 #if defined (VI_MODE)
1782 { "vi", vi_movement_keymap
},
1783 { "vi-move", vi_movement_keymap
},
1784 { "vi-command", vi_movement_keymap
},
1785 { "vi-insert", vi_insertion_keymap
},
1786 #endif /* VI_MODE */
1787 { (char *)0x0, (Keymap
)0x0 }
1791 rl_get_keymap_by_name (name
)
1796 for (i
= 0; keymap_names
[i
].name
; i
++)
1797 if (_rl_stricmp (name
, keymap_names
[i
].name
) == 0)
1798 return (keymap_names
[i
].map
);
1799 return ((Keymap
) NULL
);
1803 rl_get_keymap_name (map
)
1807 for (i
= 0; keymap_names
[i
].name
; i
++)
1808 if (map
== keymap_names
[i
].map
)
1809 return ((char *)keymap_names
[i
].name
);
1810 return ((char *)NULL
);
1824 return (_rl_keymap
);
1828 rl_set_keymap_from_edit_mode ()
1830 if (rl_editing_mode
== emacs_mode
)
1831 _rl_keymap
= emacs_standard_keymap
;
1832 #if defined (VI_MODE)
1833 else if (rl_editing_mode
== vi_mode
)
1834 _rl_keymap
= vi_insertion_keymap
;
1835 #endif /* VI_MODE */
1839 rl_get_keymap_name_from_edit_mode ()
1841 if (rl_editing_mode
== emacs_mode
)
1843 #if defined (VI_MODE)
1844 else if (rl_editing_mode
== vi_mode
)
1846 #endif /* VI_MODE */
1851 /* **************************************************************** */
1853 /* Key Binding and Function Information */
1855 /* **************************************************************** */
1857 /* Each of the following functions produces information about the
1858 state of keybindings and functions known to Readline. The info
1859 is always printed to rl_outstream, and in such a way that it can
1860 be read back in (i.e., passed to rl_parse_and_bind ()). */
1862 /* Print the names of functions known to Readline. */
1864 rl_list_funmap_names ()
1867 const char **funmap_names
;
1869 funmap_names
= rl_funmap_names ();
1874 for (i
= 0; funmap_names
[i
]; i
++)
1875 fprintf (rl_outstream
, "%s\n", funmap_names
[i
]);
1877 xfree (funmap_names
);
1881 _rl_get_keyname (key
)
1887 keyname
= (char *)xmalloc (8);
1890 /* Since this is going to be used to write out keysequence-function
1891 pairs for possible inclusion in an inputrc file, we don't want to
1892 do any special meta processing on KEY. */
1895 /* XXX - Experimental */
1896 /* We might want to do this, but the old version of the code did not. */
1898 /* If this is an escape character, we don't want to do any more processing.
1899 Just add the special ESC key sequence and return. */
1909 /* RUBOUT is translated directly into \C-? */
1921 /* Now add special prefixes needed for control characters. This can
1922 potentially change C. */
1925 keyname
[i
++] = '\\';
1928 c
= _rl_to_lower (UNCTRL (c
));
1931 /* XXX experimental code. Turn the characters that are not ASCII or
1932 ISO Latin 1 (128 - 159) into octal escape sequences (\200 - \237).
1934 if (c
>= 128 && c
<= 159)
1936 keyname
[i
++] = '\\';
1939 keyname
[i
++] = (c
/ 8) + '0';
1943 /* Now, if the character needs to be quoted with a backslash, do that. */
1944 if (c
== '\\' || c
== '"')
1945 keyname
[i
++] = '\\';
1947 /* Now add the key, terminate the string, and return it. */
1948 keyname
[i
++] = (char) c
;
1954 /* Return a NULL terminated array of strings which represent the key
1955 sequences that are used to invoke FUNCTION in MAP. */
1957 rl_invoking_keyseqs_in_map (function
, map
)
1958 rl_command_func_t
*function
;
1963 int result_index
, result_size
;
1965 result
= (char **)NULL
;
1966 result_index
= result_size
= 0;
1968 for (key
= 0; key
< KEYMAP_SIZE
; key
++)
1970 switch (map
[key
].type
)
1973 /* Macros match, if, and only if, the pointers are identical.
1974 Thus, they are treated exactly like functions in here. */
1976 /* If the function in the keymap is the one we are looking for,
1977 then add the current KEY to the list of invoking keys. */
1978 if (map
[key
].function
== function
)
1982 keyname
= _rl_get_keyname (key
);
1984 if (result_index
+ 2 > result_size
)
1987 result
= (char **)xrealloc (result
, result_size
* sizeof (char *));
1990 result
[result_index
++] = keyname
;
1991 result
[result_index
] = (char *)NULL
;
2000 /* Find the list of keyseqs in this map which have FUNCTION as
2001 their target. Add the key sequences found to RESULT. */
2002 if (map
[key
].function
)
2004 rl_invoking_keyseqs_in_map (function
, FUNCTION_TO_KEYMAP (map
, key
));
2011 for (i
= 0; seqs
[i
]; i
++)
2013 char *keyname
= (char *)xmalloc (6 + strlen (seqs
[i
]));
2017 /* If ESC is the meta prefix and we're converting chars
2018 with the eighth bit set to ESC-prefixed sequences, then
2019 we can use \M-. Otherwise we need to use the sequence
2021 if (_rl_convert_meta_chars_to_ascii
&& map
[ESC
].type
== ISKMAP
)
2022 sprintf (keyname
, "\\M-");
2024 sprintf (keyname
, "\\e");
2026 else if (CTRL_CHAR (key
))
2027 sprintf (keyname
, "\\C-%c", _rl_to_lower (UNCTRL (key
)));
2028 else if (key
== RUBOUT
)
2029 sprintf (keyname
, "\\C-?");
2030 else if (key
== '\\' || key
== '"')
2033 keyname
[1] = (char) key
;
2038 keyname
[0] = (char) key
;
2042 strcat (keyname
, seqs
[i
]);
2045 if (result_index
+ 2 > result_size
)
2048 result
= (char **)xrealloc (result
, result_size
* sizeof (char *));
2051 result
[result_index
++] = keyname
;
2052 result
[result_index
] = (char *)NULL
;
2063 /* Return a NULL terminated array of strings which represent the key
2064 sequences that can be used to invoke FUNCTION using the current keymap. */
2066 rl_invoking_keyseqs (function
)
2067 rl_command_func_t
*function
;
2069 return (rl_invoking_keyseqs_in_map (function
, _rl_keymap
));
2072 /* Print all of the functions and their bindings to rl_outstream. If
2073 PRINT_READABLY is non-zero, then print the output in such a way
2074 that it can be read back in. */
2076 rl_function_dumper (print_readably
)
2083 names
= rl_funmap_names ();
2085 fprintf (rl_outstream
, "\n");
2087 for (i
= 0; name
= names
[i
]; i
++)
2089 rl_command_func_t
*function
;
2092 function
= rl_named_function (name
);
2093 invokers
= rl_invoking_keyseqs_in_map (function
, _rl_keymap
);
2098 fprintf (rl_outstream
, "# %s (not bound)\n", name
);
2103 for (j
= 0; invokers
[j
]; j
++)
2105 fprintf (rl_outstream
, "\"%s\": %s\n",
2107 xfree (invokers
[j
]);
2116 fprintf (rl_outstream
, "%s is not bound to any keys\n",
2122 fprintf (rl_outstream
, "%s can be found on ", name
);
2124 for (j
= 0; invokers
[j
] && j
< 5; j
++)
2126 fprintf (rl_outstream
, "\"%s\"%s", invokers
[j
],
2127 invokers
[j
+ 1] ? ", " : ".\n");
2130 if (j
== 5 && invokers
[j
])
2131 fprintf (rl_outstream
, "...\n");
2133 for (j
= 0; invokers
[j
]; j
++)
2134 xfree (invokers
[j
]);
2142 /* Print all of the current functions and their bindings to
2143 rl_outstream. If an explicit argument is given, then print
2144 the output in such a way that it can be read back in. */
2146 rl_dump_functions (count
, key
)
2150 fprintf (rl_outstream
, "\r\n");
2151 rl_function_dumper (rl_explicit_arg
);
2157 _rl_macro_dumper_internal (print_readably
, map
, prefix
)
2163 char *keyname
, *out
;
2166 for (key
= 0; key
< KEYMAP_SIZE
; key
++)
2168 switch (map
[key
].type
)
2171 keyname
= _rl_get_keyname (key
);
2172 out
= _rl_untranslate_macro_value ((char *)map
[key
].function
);
2175 fprintf (rl_outstream
, "\"%s%s\": \"%s\"\n", prefix
? prefix
: "",
2179 fprintf (rl_outstream
, "%s%s outputs %s\n", prefix
? prefix
: "",
2188 prefix_len
= prefix
? strlen (prefix
) : 0;
2191 keyname
= (char *)xmalloc (3 + prefix_len
);
2193 strcpy (keyname
, prefix
);
2194 keyname
[prefix_len
] = '\\';
2195 keyname
[prefix_len
+ 1] = 'e';
2196 keyname
[prefix_len
+ 2] = '\0';
2200 keyname
= _rl_get_keyname (key
);
2203 out
= (char *)xmalloc (strlen (keyname
) + prefix_len
+ 1);
2204 strcpy (out
, prefix
);
2205 strcpy (out
+ prefix_len
, keyname
);
2211 _rl_macro_dumper_internal (print_readably
, FUNCTION_TO_KEYMAP (map
, key
), keyname
);
2219 rl_macro_dumper (print_readably
)
2222 _rl_macro_dumper_internal (print_readably
, _rl_keymap
, (char *)NULL
);
2226 rl_dump_macros (count
, key
)
2230 fprintf (rl_outstream
, "\r\n");
2231 rl_macro_dumper (rl_explicit_arg
);
2237 _rl_get_string_variable_value (name
)
2240 static char numbuf
[32];
2243 if (_rl_stricmp (name
, "bell-style") == 0)
2245 switch (_rl_bell_preference
)
2256 else if (_rl_stricmp (name
, "comment-begin") == 0)
2257 return (_rl_comment_begin
? _rl_comment_begin
: RL_COMMENT_BEGIN_DEFAULT
);
2258 else if (_rl_stricmp (name
, "completion-prefix-display-length") == 0)
2260 sprintf (numbuf
, "%d", _rl_completion_prefix_display_length
);
2263 else if (_rl_stricmp (name
, "completion-query-items") == 0)
2265 sprintf (numbuf
, "%d", rl_completion_query_items
);
2268 else if (_rl_stricmp (name
, "editing-mode") == 0)
2269 return (rl_get_keymap_name_from_edit_mode ());
2270 else if (_rl_stricmp (name
, "history-size") == 0)
2272 sprintf (numbuf
, "%d", history_is_stifled() ? history_max_entries
: 0);
2275 else if (_rl_stricmp (name
, "isearch-terminators") == 0)
2277 if (_rl_isearch_terminators
== 0)
2279 ret
= _rl_untranslate_macro_value (_rl_isearch_terminators
);
2282 strncpy (numbuf
, ret
, sizeof (numbuf
) - 1);
2284 numbuf
[sizeof(numbuf
) - 1] = '\0';
2290 else if (_rl_stricmp (name
, "keymap") == 0)
2292 ret
= rl_get_keymap_name (_rl_keymap
);
2294 ret
= rl_get_keymap_name_from_edit_mode ();
2295 return (ret
? ret
: "none");
2302 rl_variable_dumper (print_readably
)
2308 for (i
= 0; boolean_varlist
[i
].name
; i
++)
2311 fprintf (rl_outstream
, "set %s %s\n", boolean_varlist
[i
].name
,
2312 *boolean_varlist
[i
].value
? "on" : "off");
2314 fprintf (rl_outstream
, "%s is set to `%s'\n", boolean_varlist
[i
].name
,
2315 *boolean_varlist
[i
].value
? "on" : "off");
2318 for (i
= 0; string_varlist
[i
].name
; i
++)
2320 v
= _rl_get_string_variable_value (string_varlist
[i
].name
);
2321 if (v
== 0) /* _rl_isearch_terminators can be NULL */
2324 fprintf (rl_outstream
, "set %s %s\n", string_varlist
[i
].name
, v
);
2326 fprintf (rl_outstream
, "%s is set to `%s'\n", string_varlist
[i
].name
, v
);
2330 /* Print all of the current variables and their values to
2331 rl_outstream. If an explicit argument is given, then print
2332 the output in such a way that it can be read back in. */
2334 rl_dump_variables (count
, key
)
2338 fprintf (rl_outstream
, "\r\n");
2339 rl_variable_dumper (rl_explicit_arg
);
2344 /* Return non-zero if any members of ARRAY are a substring in STRING. */
2346 substring_member_of_array (string
, array
)
2348 const char * const *array
;
2352 if (_rl_strindex (string
, *array
))