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