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