Annotation of embedaddon/readline/histexpand.c, revision 1.1.1.1
1.1 misho 1: /* histexpand.c -- history expansion. */
2:
3: /* Copyright (C) 1989-2012 Free Software Foundation, Inc.
4:
5: This file contains the GNU History Library (History), a set of
6: routines for managing the text of previously typed lines.
7:
8: History 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: History 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 History. If not, see <http://www.gnu.org/licenses/>.
20: */
21:
22: #define READLINE_LIBRARY
23:
24: #if defined (HAVE_CONFIG_H)
25: # include <config.h>
26: #endif
27:
28: #include <stdio.h>
29:
30: #if defined (HAVE_STDLIB_H)
31: # include <stdlib.h>
32: #else
33: # include "ansi_stdlib.h"
34: #endif /* HAVE_STDLIB_H */
35:
36: #if defined (HAVE_UNISTD_H)
37: # ifndef _MINIX
38: # include <sys/types.h>
39: # endif
40: # include <unistd.h>
41: #endif
42:
43: #include "rlmbutil.h"
44:
45: #include "history.h"
46: #include "histlib.h"
47:
48: #include "rlshell.h"
49: #include "xmalloc.h"
50:
51: #define HISTORY_WORD_DELIMITERS " \t\n;&()|<>"
52: #define HISTORY_QUOTE_CHARACTERS "\"'`"
53:
54: #define slashify_in_quotes "\\`\"$"
55:
56: typedef int _hist_search_func_t PARAMS((const char *, int));
57:
58: static char error_pointer;
59:
60: static char *subst_lhs;
61: static char *subst_rhs;
62: static int subst_lhs_len;
63: static int subst_rhs_len;
64:
65: static char *get_history_word_specifier PARAMS((char *, char *, int *));
66: static int history_tokenize_word PARAMS((const char *, int));
67: static char **history_tokenize_internal PARAMS((const char *, int, int *));
68: static char *history_substring PARAMS((const char *, int, int));
69: static void freewords PARAMS((char **, int));
70: static char *history_find_word PARAMS((char *, int));
71:
72: static char *quote_breaks PARAMS((char *));
73:
74: /* Variables exported by this file. */
75: /* The character that represents the start of a history expansion
76: request. This is usually `!'. */
77: char history_expansion_char = '!';
78:
79: /* The character that invokes word substitution if found at the start of
80: a line. This is usually `^'. */
81: char history_subst_char = '^';
82:
83: /* During tokenization, if this character is seen as the first character
84: of a word, then it, and all subsequent characters upto a newline are
85: ignored. For a Bourne shell, this should be '#'. Bash special cases
86: the interactive comment character to not be a comment delimiter. */
87: char history_comment_char = '\0';
88:
89: /* The list of characters which inhibit the expansion of text if found
90: immediately following history_expansion_char. */
91: char *history_no_expand_chars = " \t\n\r=";
92:
93: /* If set to a non-zero value, single quotes inhibit history expansion.
94: The default is 0. */
95: int history_quotes_inhibit_expansion = 0;
96:
97: /* Used to split words by history_tokenize_internal. */
98: char *history_word_delimiters = HISTORY_WORD_DELIMITERS;
99:
100: /* If set, this points to a function that is called to verify that a
101: particular history expansion should be performed. */
102: rl_linebuf_func_t *history_inhibit_expansion_function;
103:
104: /* **************************************************************** */
105: /* */
106: /* History Expansion */
107: /* */
108: /* **************************************************************** */
109:
110: /* Hairy history expansion on text, not tokens. This is of general
111: use, and thus belongs in this library. */
112:
113: /* The last string searched for by a !?string? search. */
114: static char *search_string;
115:
116: /* The last string matched by a !?string? search. */
117: static char *search_match;
118:
119: /* Return the event specified at TEXT + OFFSET modifying OFFSET to
120: point to after the event specifier. Just a pointer to the history
121: line is returned; NULL is returned in the event of a bad specifier.
122: You pass STRING with *INDEX equal to the history_expansion_char that
123: begins this specification.
124: DELIMITING_QUOTE is a character that is allowed to end the string
125: specification for what to search for in addition to the normal
126: characters `:', ` ', `\t', `\n', and sometimes `?'.
127: So you might call this function like:
128: line = get_history_event ("!echo:p", &index, 0); */
129: char *
130: get_history_event (string, caller_index, delimiting_quote)
131: const char *string;
132: int *caller_index;
133: int delimiting_quote;
134: {
135: register int i;
136: register char c;
137: HIST_ENTRY *entry;
138: int which, sign, local_index, substring_okay;
139: _hist_search_func_t *search_func;
140: char *temp;
141:
142: /* The event can be specified in a number of ways.
143:
144: !! the previous command
145: !n command line N
146: !-n current command-line minus N
147: !str the most recent command starting with STR
148: !?str[?]
149: the most recent command containing STR
150:
151: All values N are determined via HISTORY_BASE. */
152:
153: i = *caller_index;
154:
155: if (string[i] != history_expansion_char)
156: return ((char *)NULL);
157:
158: /* Move on to the specification. */
159: i++;
160:
161: sign = 1;
162: substring_okay = 0;
163:
164: #define RETURN_ENTRY(e, w) \
165: return ((e = history_get (w)) ? e->line : (char *)NULL)
166:
167: /* Handle !! case. */
168: if (string[i] == history_expansion_char)
169: {
170: i++;
171: which = history_base + (history_length - 1);
172: *caller_index = i;
173: RETURN_ENTRY (entry, which);
174: }
175:
176: /* Hack case of numeric line specification. */
177: if (string[i] == '-')
178: {
179: sign = -1;
180: i++;
181: }
182:
183: if (_rl_digit_p (string[i]))
184: {
185: /* Get the extent of the digits and compute the value. */
186: for (which = 0; _rl_digit_p (string[i]); i++)
187: which = (which * 10) + _rl_digit_value (string[i]);
188:
189: *caller_index = i;
190:
191: if (sign < 0)
192: which = (history_length + history_base) - which;
193:
194: RETURN_ENTRY (entry, which);
195: }
196:
197: /* This must be something to search for. If the spec begins with
198: a '?', then the string may be anywhere on the line. Otherwise,
199: the string must be found at the start of a line. */
200: if (string[i] == '?')
201: {
202: substring_okay++;
203: i++;
204: }
205:
206: /* Only a closing `?' or a newline delimit a substring search string. */
207: for (local_index = i; c = string[i]; i++)
208: {
209: #if defined (HANDLE_MULTIBYTE)
210: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
211: {
212: int v;
213: mbstate_t ps;
214:
215: memset (&ps, 0, sizeof (mbstate_t));
216: /* These produce warnings because we're passing a const string to a
217: function that takes a non-const string. */
218: _rl_adjust_point ((char *)string, i, &ps);
219: if ((v = _rl_get_char_len ((char *)string + i, &ps)) > 1)
220: {
221: i += v - 1;
222: continue;
223: }
224: }
225:
226: #endif /* HANDLE_MULTIBYTE */
227: if ((!substring_okay && (whitespace (c) || c == ':' ||
228: (history_search_delimiter_chars && member (c, history_search_delimiter_chars)) ||
229: string[i] == delimiting_quote)) ||
230: string[i] == '\n' ||
231: (substring_okay && string[i] == '?'))
232: break;
233: }
234:
235: which = i - local_index;
236: temp = (char *)xmalloc (1 + which);
237: if (which)
238: strncpy (temp, string + local_index, which);
239: temp[which] = '\0';
240:
241: if (substring_okay && string[i] == '?')
242: i++;
243:
244: *caller_index = i;
245:
246: #define FAIL_SEARCH() \
247: do { \
248: history_offset = history_length; xfree (temp) ; return (char *)NULL; \
249: } while (0)
250:
251: /* If there is no search string, try to use the previous search string,
252: if one exists. If not, fail immediately. */
253: if (*temp == '\0' && substring_okay)
254: {
255: if (search_string)
256: {
257: xfree (temp);
258: temp = savestring (search_string);
259: }
260: else
261: FAIL_SEARCH ();
262: }
263:
264: search_func = substring_okay ? history_search : history_search_prefix;
265: while (1)
266: {
267: local_index = (*search_func) (temp, -1);
268:
269: if (local_index < 0)
270: FAIL_SEARCH ();
271:
272: if (local_index == 0 || substring_okay)
273: {
274: entry = current_history ();
275: if (entry == 0)
276: FAIL_SEARCH ();
277: history_offset = history_length;
278:
279: /* If this was a substring search, then remember the
280: string that we matched for word substitution. */
281: if (substring_okay)
282: {
283: FREE (search_string);
284: search_string = temp;
285:
286: FREE (search_match);
287: search_match = history_find_word (entry->line, local_index);
288: }
289: else
290: xfree (temp);
291:
292: return (entry->line);
293: }
294:
295: if (history_offset)
296: history_offset--;
297: else
298: FAIL_SEARCH ();
299: }
300: #undef FAIL_SEARCH
301: #undef RETURN_ENTRY
302: }
303:
304: /* Function for extracting single-quoted strings. Used for inhibiting
305: history expansion within single quotes. */
306:
307: /* Extract the contents of STRING as if it is enclosed in single quotes.
308: SINDEX, when passed in, is the offset of the character immediately
309: following the opening single quote; on exit, SINDEX is left pointing
310: to the closing single quote. FLAGS currently used to allow backslash
311: to escape a single quote (e.g., for bash $'...'). */
312: static void
313: hist_string_extract_single_quoted (string, sindex, flags)
314: char *string;
315: int *sindex, flags;
316: {
317: register int i;
318:
319: for (i = *sindex; string[i] && string[i] != '\''; i++)
320: {
321: if ((flags & 1) && string[i] == '\\' && string[i+1])
322: i++;
323: }
324:
325: *sindex = i;
326: }
327:
328: static char *
329: quote_breaks (s)
330: char *s;
331: {
332: register char *p, *r;
333: char *ret;
334: int len = 3;
335:
336: for (p = s; p && *p; p++, len++)
337: {
338: if (*p == '\'')
339: len += 3;
340: else if (whitespace (*p) || *p == '\n')
341: len += 2;
342: }
343:
344: r = ret = (char *)xmalloc (len);
345: *r++ = '\'';
346: for (p = s; p && *p; )
347: {
348: if (*p == '\'')
349: {
350: *r++ = '\'';
351: *r++ = '\\';
352: *r++ = '\'';
353: *r++ = '\'';
354: p++;
355: }
356: else if (whitespace (*p) || *p == '\n')
357: {
358: *r++ = '\'';
359: *r++ = *p++;
360: *r++ = '\'';
361: }
362: else
363: *r++ = *p++;
364: }
365: *r++ = '\'';
366: *r = '\0';
367: return ret;
368: }
369:
370: static char *
371: hist_error(s, start, current, errtype)
372: char *s;
373: int start, current, errtype;
374: {
375: char *temp;
376: const char *emsg;
377: int ll, elen;
378:
379: ll = current - start;
380:
381: switch (errtype)
382: {
383: case EVENT_NOT_FOUND:
384: emsg = "event not found";
385: elen = 15;
386: break;
387: case BAD_WORD_SPEC:
388: emsg = "bad word specifier";
389: elen = 18;
390: break;
391: case SUBST_FAILED:
392: emsg = "substitution failed";
393: elen = 19;
394: break;
395: case BAD_MODIFIER:
396: emsg = "unrecognized history modifier";
397: elen = 29;
398: break;
399: case NO_PREV_SUBST:
400: emsg = "no previous substitution";
401: elen = 24;
402: break;
403: default:
404: emsg = "unknown expansion error";
405: elen = 23;
406: break;
407: }
408:
409: temp = (char *)xmalloc (ll + elen + 3);
410: strncpy (temp, s + start, ll);
411: temp[ll] = ':';
412: temp[ll + 1] = ' ';
413: strcpy (temp + ll + 2, emsg);
414: return (temp);
415: }
416:
417: /* Get a history substitution string from STR starting at *IPTR
418: and return it. The length is returned in LENPTR.
419:
420: A backslash can quote the delimiter. If the string is the
421: empty string, the previous pattern is used. If there is
422: no previous pattern for the lhs, the last history search
423: string is used.
424:
425: If IS_RHS is 1, we ignore empty strings and set the pattern
426: to "" anyway. subst_lhs is not changed if the lhs is empty;
427: subst_rhs is allowed to be set to the empty string. */
428:
429: static char *
430: get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
431: char *str;
432: int *iptr, delimiter, is_rhs, *lenptr;
433: {
434: register int si, i, j, k;
435: char *s;
436: #if defined (HANDLE_MULTIBYTE)
437: mbstate_t ps;
438: #endif
439:
440: s = (char *)NULL;
441: i = *iptr;
442:
443: #if defined (HANDLE_MULTIBYTE)
444: memset (&ps, 0, sizeof (mbstate_t));
445: _rl_adjust_point (str, i, &ps);
446: #endif
447:
448: for (si = i; str[si] && str[si] != delimiter; si++)
449: #if defined (HANDLE_MULTIBYTE)
450: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
451: {
452: int v;
453: if ((v = _rl_get_char_len (str + si, &ps)) > 1)
454: si += v - 1;
455: else if (str[si] == '\\' && str[si + 1] == delimiter)
456: si++;
457: }
458: else
459: #endif /* HANDLE_MULTIBYTE */
460: if (str[si] == '\\' && str[si + 1] == delimiter)
461: si++;
462:
463: if (si > i || is_rhs)
464: {
465: s = (char *)xmalloc (si - i + 1);
466: for (j = 0, k = i; k < si; j++, k++)
467: {
468: /* Remove a backslash quoting the search string delimiter. */
469: if (str[k] == '\\' && str[k + 1] == delimiter)
470: k++;
471: s[j] = str[k];
472: }
473: s[j] = '\0';
474: if (lenptr)
475: *lenptr = j;
476: }
477:
478: i = si;
479: if (str[i])
480: i++;
481: *iptr = i;
482:
483: return s;
484: }
485:
486: static void
487: postproc_subst_rhs ()
488: {
489: char *new;
490: int i, j, new_size;
491:
492: new = (char *)xmalloc (new_size = subst_rhs_len + subst_lhs_len);
493: for (i = j = 0; i < subst_rhs_len; i++)
494: {
495: if (subst_rhs[i] == '&')
496: {
497: if (j + subst_lhs_len >= new_size)
498: new = (char *)xrealloc (new, (new_size = new_size * 2 + subst_lhs_len));
499: strcpy (new + j, subst_lhs);
500: j += subst_lhs_len;
501: }
502: else
503: {
504: /* a single backslash protects the `&' from lhs interpolation */
505: if (subst_rhs[i] == '\\' && subst_rhs[i + 1] == '&')
506: i++;
507: if (j >= new_size)
508: new = (char *)xrealloc (new, new_size *= 2);
509: new[j++] = subst_rhs[i];
510: }
511: }
512: new[j] = '\0';
513: xfree (subst_rhs);
514: subst_rhs = new;
515: subst_rhs_len = j;
516: }
517:
518: /* Expand the bulk of a history specifier starting at STRING[START].
519: Returns 0 if everything is OK, -1 if an error occurred, and 1
520: if the `p' modifier was supplied and the caller should just print
521: the returned string. Returns the new index into string in
522: *END_INDEX_PTR, and the expanded specifier in *RET_STRING. */
523: static int
524: history_expand_internal (string, start, qc, end_index_ptr, ret_string, current_line)
525: char *string;
526: int start, qc, *end_index_ptr;
527: char **ret_string;
528: char *current_line; /* for !# */
529: {
530: int i, n, starting_index;
531: int substitute_globally, subst_bywords, want_quotes, print_only;
532: char *event, *temp, *result, *tstr, *t, c, *word_spec;
533: int result_len;
534: #if defined (HANDLE_MULTIBYTE)
535: mbstate_t ps;
536:
537: memset (&ps, 0, sizeof (mbstate_t));
538: #endif
539:
540: result = (char *)xmalloc (result_len = 128);
541:
542: i = start;
543:
544: /* If it is followed by something that starts a word specifier,
545: then !! is implied as the event specifier. */
546:
547: if (member (string[i + 1], ":$*%^"))
548: {
549: char fake_s[3];
550: int fake_i = 0;
551: i++;
552: fake_s[0] = fake_s[1] = history_expansion_char;
553: fake_s[2] = '\0';
554: event = get_history_event (fake_s, &fake_i, 0);
555: }
556: else if (string[i + 1] == '#')
557: {
558: i += 2;
559: event = current_line;
560: }
561: else
562: event = get_history_event (string, &i, qc);
563:
564: if (event == 0)
565: {
566: *ret_string = hist_error (string, start, i, EVENT_NOT_FOUND);
567: xfree (result);
568: return (-1);
569: }
570:
571: /* If a word specifier is found, then do what that requires. */
572: starting_index = i;
573: word_spec = get_history_word_specifier (string, event, &i);
574:
575: /* There is no such thing as a `malformed word specifier'. However,
576: it is possible for a specifier that has no match. In that case,
577: we complain. */
578: if (word_spec == (char *)&error_pointer)
579: {
580: *ret_string = hist_error (string, starting_index, i, BAD_WORD_SPEC);
581: xfree (result);
582: return (-1);
583: }
584:
585: /* If no word specifier, than the thing of interest was the event. */
586: temp = word_spec ? savestring (word_spec) : savestring (event);
587: FREE (word_spec);
588:
589: /* Perhaps there are other modifiers involved. Do what they say. */
590: want_quotes = substitute_globally = subst_bywords = print_only = 0;
591: starting_index = i;
592:
593: while (string[i] == ':')
594: {
595: c = string[i + 1];
596:
597: if (c == 'g' || c == 'a')
598: {
599: substitute_globally = 1;
600: i++;
601: c = string[i + 1];
602: }
603: else if (c == 'G')
604: {
605: subst_bywords = 1;
606: i++;
607: c = string[i + 1];
608: }
609:
610: switch (c)
611: {
612: default:
613: *ret_string = hist_error (string, i+1, i+2, BAD_MODIFIER);
614: xfree (result);
615: xfree (temp);
616: return -1;
617:
618: case 'q':
619: want_quotes = 'q';
620: break;
621:
622: case 'x':
623: want_quotes = 'x';
624: break;
625:
626: /* :p means make this the last executed line. So we
627: return an error state after adding this line to the
628: history. */
629: case 'p':
630: print_only++;
631: break;
632:
633: /* :t discards all but the last part of the pathname. */
634: case 't':
635: tstr = strrchr (temp, '/');
636: if (tstr)
637: {
638: tstr++;
639: t = savestring (tstr);
640: xfree (temp);
641: temp = t;
642: }
643: break;
644:
645: /* :h discards the last part of a pathname. */
646: case 'h':
647: tstr = strrchr (temp, '/');
648: if (tstr)
649: *tstr = '\0';
650: break;
651:
652: /* :r discards the suffix. */
653: case 'r':
654: tstr = strrchr (temp, '.');
655: if (tstr)
656: *tstr = '\0';
657: break;
658:
659: /* :e discards everything but the suffix. */
660: case 'e':
661: tstr = strrchr (temp, '.');
662: if (tstr)
663: {
664: t = savestring (tstr);
665: xfree (temp);
666: temp = t;
667: }
668: break;
669:
670: /* :s/this/that substitutes `that' for the first
671: occurrence of `this'. :gs/this/that substitutes `that'
672: for each occurrence of `this'. :& repeats the last
673: substitution. :g& repeats the last substitution
674: globally. */
675:
676: case '&':
677: case 's':
678: {
679: char *new_event;
680: int delimiter, failed, si, l_temp, ws, we;
681:
682: if (c == 's')
683: {
684: if (i + 2 < (int)strlen (string))
685: {
686: #if defined (HANDLE_MULTIBYTE)
687: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
688: {
689: _rl_adjust_point (string, i + 2, &ps);
690: if (_rl_get_char_len (string + i + 2, &ps) > 1)
691: delimiter = 0;
692: else
693: delimiter = string[i + 2];
694: }
695: else
696: #endif /* HANDLE_MULTIBYTE */
697: delimiter = string[i + 2];
698: }
699: else
700: break; /* no search delimiter */
701:
702: i += 3;
703:
704: t = get_subst_pattern (string, &i, delimiter, 0, &subst_lhs_len);
705: /* An empty substitution lhs with no previous substitution
706: uses the last search string as the lhs. */
707: if (t)
708: {
709: FREE (subst_lhs);
710: subst_lhs = t;
711: }
712: else if (!subst_lhs)
713: {
714: if (search_string && *search_string)
715: {
716: subst_lhs = savestring (search_string);
717: subst_lhs_len = strlen (subst_lhs);
718: }
719: else
720: {
721: subst_lhs = (char *) NULL;
722: subst_lhs_len = 0;
723: }
724: }
725:
726: FREE (subst_rhs);
727: subst_rhs = get_subst_pattern (string, &i, delimiter, 1, &subst_rhs_len);
728:
729: /* If `&' appears in the rhs, it's supposed to be replaced
730: with the lhs. */
731: if (member ('&', subst_rhs))
732: postproc_subst_rhs ();
733: }
734: else
735: i += 2;
736:
737: /* If there is no lhs, the substitution can't succeed. */
738: if (subst_lhs_len == 0)
739: {
740: *ret_string = hist_error (string, starting_index, i, NO_PREV_SUBST);
741: xfree (result);
742: xfree (temp);
743: return -1;
744: }
745:
746: l_temp = strlen (temp);
747: /* Ignore impossible cases. */
748: if (subst_lhs_len > l_temp)
749: {
750: *ret_string = hist_error (string, starting_index, i, SUBST_FAILED);
751: xfree (result);
752: xfree (temp);
753: return (-1);
754: }
755:
756: /* Find the first occurrence of THIS in TEMP. */
757: /* Substitute SUBST_RHS for SUBST_LHS in TEMP. There are three
758: cases to consider:
759:
760: 1. substitute_globally == subst_bywords == 0
761: 2. substitute_globally == 1 && subst_bywords == 0
762: 3. substitute_globally == 0 && subst_bywords == 1
763:
764: In the first case, we substitute for the first occurrence only.
765: In the second case, we substitute for every occurrence.
766: In the third case, we tokenize into words and substitute the
767: first occurrence of each word. */
768:
769: si = we = 0;
770: for (failed = 1; (si + subst_lhs_len) <= l_temp; si++)
771: {
772: /* First skip whitespace and find word boundaries if
773: we're past the end of the word boundary we found
774: the last time. */
775: if (subst_bywords && si > we)
776: {
777: for (; temp[si] && whitespace (temp[si]); si++)
778: ;
779: ws = si;
780: we = history_tokenize_word (temp, si);
781: }
782:
783: if (STREQN (temp+si, subst_lhs, subst_lhs_len))
784: {
785: int len = subst_rhs_len - subst_lhs_len + l_temp;
786: new_event = (char *)xmalloc (1 + len);
787: strncpy (new_event, temp, si);
788: strncpy (new_event + si, subst_rhs, subst_rhs_len);
789: strncpy (new_event + si + subst_rhs_len,
790: temp + si + subst_lhs_len,
791: l_temp - (si + subst_lhs_len));
792: new_event[len] = '\0';
793: xfree (temp);
794: temp = new_event;
795:
796: failed = 0;
797:
798: if (substitute_globally)
799: {
800: /* Reported to fix a bug that causes it to skip every
801: other match when matching a single character. Was
802: si += subst_rhs_len previously. */
803: si += subst_rhs_len - 1;
804: l_temp = strlen (temp);
805: substitute_globally++;
806: continue;
807: }
808: else if (subst_bywords)
809: {
810: si = we;
811: l_temp = strlen (temp);
812: continue;
813: }
814: else
815: break;
816: }
817: }
818:
819: if (substitute_globally > 1)
820: {
821: substitute_globally = 0;
822: continue; /* don't want to increment i */
823: }
824:
825: if (failed == 0)
826: continue; /* don't want to increment i */
827:
828: *ret_string = hist_error (string, starting_index, i, SUBST_FAILED);
829: xfree (result);
830: xfree (temp);
831: return (-1);
832: }
833: }
834: i += 2;
835: }
836: /* Done with modifiers. */
837: /* Believe it or not, we have to back the pointer up by one. */
838: --i;
839:
840: if (want_quotes)
841: {
842: char *x;
843:
844: if (want_quotes == 'q')
845: x = sh_single_quote (temp);
846: else if (want_quotes == 'x')
847: x = quote_breaks (temp);
848: else
849: x = savestring (temp);
850:
851: xfree (temp);
852: temp = x;
853: }
854:
855: n = strlen (temp);
856: if (n >= result_len)
857: result = (char *)xrealloc (result, n + 2);
858: strcpy (result, temp);
859: xfree (temp);
860:
861: *end_index_ptr = i;
862: *ret_string = result;
863: return (print_only);
864: }
865:
866: /* Expand the string STRING, placing the result into OUTPUT, a pointer
867: to a string. Returns:
868:
869: -1) If there was an error in expansion.
870: 0) If no expansions took place (or, if the only change in
871: the text was the de-slashifying of the history expansion
872: character)
873: 1) If expansions did take place
874: 2) If the `p' modifier was given and the caller should print the result
875:
876: If an error ocurred in expansion, then OUTPUT contains a descriptive
877: error message. */
878:
879: #define ADD_STRING(s) \
880: do \
881: { \
882: int sl = strlen (s); \
883: j += sl; \
884: if (j >= result_len) \
885: { \
886: while (j >= result_len) \
887: result_len += 128; \
888: result = (char *)xrealloc (result, result_len); \
889: } \
890: strcpy (result + j - sl, s); \
891: } \
892: while (0)
893:
894: #define ADD_CHAR(c) \
895: do \
896: { \
897: if (j >= result_len - 1) \
898: result = (char *)xrealloc (result, result_len += 64); \
899: result[j++] = c; \
900: result[j] = '\0'; \
901: } \
902: while (0)
903:
904: int
905: history_expand (hstring, output)
906: char *hstring;
907: char **output;
908: {
909: register int j;
910: int i, r, l, passc, cc, modified, eindex, only_printing, dquote, squote, flag;
911: char *string;
912:
913: /* The output string, and its length. */
914: int result_len;
915: char *result;
916:
917: #if defined (HANDLE_MULTIBYTE)
918: char mb[MB_LEN_MAX];
919: mbstate_t ps;
920: #endif
921:
922: /* Used when adding the string. */
923: char *temp;
924:
925: if (output == 0)
926: return 0;
927:
928: /* Setting the history expansion character to 0 inhibits all
929: history expansion. */
930: if (history_expansion_char == 0)
931: {
932: *output = savestring (hstring);
933: return (0);
934: }
935:
936: /* Prepare the buffer for printing error messages. */
937: result = (char *)xmalloc (result_len = 256);
938: result[0] = '\0';
939:
940: only_printing = modified = 0;
941: l = strlen (hstring);
942:
943: /* Grovel the string. Only backslash and single quotes can quote the
944: history escape character. We also handle arg specifiers. */
945:
946: /* Before we grovel forever, see if the history_expansion_char appears
947: anywhere within the text. */
948:
949: /* The quick substitution character is a history expansion all right. That
950: is to say, "^this^that^" is equivalent to "!!:s^this^that^", and in fact,
951: that is the substitution that we do. */
952: if (hstring[0] == history_subst_char)
953: {
954: string = (char *)xmalloc (l + 5);
955:
956: string[0] = string[1] = history_expansion_char;
957: string[2] = ':';
958: string[3] = 's';
959: strcpy (string + 4, hstring);
960: l += 4;
961: }
962: else
963: {
964: #if defined (HANDLE_MULTIBYTE)
965: memset (&ps, 0, sizeof (mbstate_t));
966: #endif
967:
968: string = hstring;
969: /* If not quick substitution, still maybe have to do expansion. */
970:
971: /* `!' followed by one of the characters in history_no_expand_chars
972: is NOT an expansion. */
973: for (i = dquote = squote = 0; string[i]; i++)
974: {
975: #if defined (HANDLE_MULTIBYTE)
976: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
977: {
978: int v;
979: v = _rl_get_char_len (string + i, &ps);
980: if (v > 1)
981: {
982: i += v - 1;
983: continue;
984: }
985: }
986: #endif /* HANDLE_MULTIBYTE */
987:
988: cc = string[i + 1];
989: /* The history_comment_char, if set, appearing at the beginning
990: of a word signifies that the rest of the line should not have
991: history expansion performed on it.
992: Skip the rest of the line and break out of the loop. */
993: if (history_comment_char && string[i] == history_comment_char &&
994: (i == 0 || member (string[i - 1], history_word_delimiters)))
995: {
996: while (string[i])
997: i++;
998: break;
999: }
1000: else if (string[i] == history_expansion_char)
1001: {
1002: if (cc == 0 || member (cc, history_no_expand_chars))
1003: continue;
1004: /* DQUOTE won't be set unless history_quotes_inhibit_expansion
1005: is set. The idea here is to treat double-quoted strings the
1006: same as the word outside double quotes; in effect making the
1007: double quote part of history_no_expand_chars when DQUOTE is
1008: set. */
1009: else if (dquote && cc == '"')
1010: continue;
1011: /* If the calling application has set
1012: history_inhibit_expansion_function to a function that checks
1013: for special cases that should not be history expanded,
1014: call the function and skip the expansion if it returns a
1015: non-zero value. */
1016: else if (history_inhibit_expansion_function &&
1017: (*history_inhibit_expansion_function) (string, i))
1018: continue;
1019: else
1020: break;
1021: }
1022: /* Shell-like quoting: allow backslashes to quote double quotes
1023: inside a double-quoted string. */
1024: else if (dquote && string[i] == '\\' && cc == '"')
1025: i++;
1026: /* More shell-like quoting: if we're paying attention to single
1027: quotes and letting them quote the history expansion character,
1028: then we need to pay attention to double quotes, because single
1029: quotes are not special inside double-quoted strings. */
1030: else if (history_quotes_inhibit_expansion && string[i] == '"')
1031: {
1032: dquote = 1 - dquote;
1033: }
1034: else if (dquote == 0 && history_quotes_inhibit_expansion && string[i] == '\'')
1035: {
1036: /* If this is bash, single quotes inhibit history expansion. */
1037: flag = (i > 0 && string[i - 1] == '$');
1038: i++;
1039: hist_string_extract_single_quoted (string, &i, flag);
1040: }
1041: else if (history_quotes_inhibit_expansion && string[i] == '\\')
1042: {
1043: /* If this is bash, allow backslashes to quote single
1044: quotes and the history expansion character. */
1045: if (cc == '\'' || cc == history_expansion_char)
1046: i++;
1047: }
1048:
1049: }
1050:
1051: if (string[i] != history_expansion_char)
1052: {
1053: xfree (result);
1054: *output = savestring (string);
1055: return (0);
1056: }
1057: }
1058:
1059: /* Extract and perform the substitution. */
1060: for (passc = dquote = squote = i = j = 0; i < l; i++)
1061: {
1062: int qc, tchar = string[i];
1063:
1064: if (passc)
1065: {
1066: passc = 0;
1067: ADD_CHAR (tchar);
1068: continue;
1069: }
1070:
1071: #if defined (HANDLE_MULTIBYTE)
1072: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1073: {
1074: int k, c;
1075:
1076: c = tchar;
1077: memset (mb, 0, sizeof (mb));
1078: for (k = 0; k < MB_LEN_MAX; k++)
1079: {
1080: mb[k] = (char)c;
1081: memset (&ps, 0, sizeof (mbstate_t));
1082: if (_rl_get_char_len (mb, &ps) == -2)
1083: c = string[++i];
1084: else
1085: break;
1086: }
1087: if (strlen (mb) > 1)
1088: {
1089: ADD_STRING (mb);
1090: continue;
1091: }
1092: }
1093: #endif /* HANDLE_MULTIBYTE */
1094:
1095: if (tchar == history_expansion_char)
1096: tchar = -3;
1097: else if (tchar == history_comment_char)
1098: tchar = -2;
1099:
1100: switch (tchar)
1101: {
1102: default:
1103: ADD_CHAR (string[i]);
1104: break;
1105:
1106: case '\\':
1107: passc++;
1108: ADD_CHAR (tchar);
1109: break;
1110:
1111: case '"':
1112: dquote = 1 - dquote;
1113: ADD_CHAR (tchar);
1114: break;
1115:
1116: case '\'':
1117: {
1118: /* If history_quotes_inhibit_expansion is set, single quotes
1119: inhibit history expansion, otherwise they are treated like
1120: double quotes. */
1121: if (squote)
1122: {
1123: squote = 0;
1124: ADD_CHAR (tchar);
1125: }
1126: else if (dquote == 0 && history_quotes_inhibit_expansion)
1127: {
1128: int quote, slen;
1129:
1130: flag = (i > 0 && string[i - 1] == '$');
1131: quote = i++;
1132: hist_string_extract_single_quoted (string, &i, flag);
1133:
1134: slen = i - quote + 2;
1135: temp = (char *)xmalloc (slen);
1136: strncpy (temp, string + quote, slen);
1137: temp[slen - 1] = '\0';
1138: ADD_STRING (temp);
1139: xfree (temp);
1140: }
1141: else if (dquote == 0 && squote == 0 && history_quotes_inhibit_expansion == 0)
1142: {
1143: squote = 1;
1144: ADD_CHAR (string[i]);
1145: }
1146: else
1147: ADD_CHAR (string[i]);
1148: break;
1149: }
1150:
1151: case -2: /* history_comment_char */
1152: if (i == 0 || member (string[i - 1], history_word_delimiters))
1153: {
1154: temp = (char *)xmalloc (l - i + 1);
1155: strcpy (temp, string + i);
1156: ADD_STRING (temp);
1157: xfree (temp);
1158: i = l;
1159: }
1160: else
1161: ADD_CHAR (string[i]);
1162: break;
1163:
1164: case -3: /* history_expansion_char */
1165: cc = string[i + 1];
1166:
1167: /* If the history_expansion_char is followed by one of the
1168: characters in history_no_expand_chars, then it is not a
1169: candidate for expansion of any kind. */
1170: if (cc == 0 || member (cc, history_no_expand_chars) ||
1171: (dquote && cc == '"') ||
1172: (history_inhibit_expansion_function && (*history_inhibit_expansion_function) (string, i)))
1173: {
1174: ADD_CHAR (string[i]);
1175: break;
1176: }
1177:
1178: #if defined (NO_BANG_HASH_MODIFIERS)
1179: /* There is something that is listed as a `word specifier' in csh
1180: documentation which means `the expanded text to this point'.
1181: That is not a word specifier, it is an event specifier. If we
1182: don't want to allow modifiers with `!#', just stick the current
1183: output line in again. */
1184: if (cc == '#')
1185: {
1186: if (result)
1187: {
1188: temp = (char *)xmalloc (1 + strlen (result));
1189: strcpy (temp, result);
1190: ADD_STRING (temp);
1191: xfree (temp);
1192: }
1193: i++;
1194: break;
1195: }
1196: #endif
1197: qc = squote ? '\'' : (dquote ? '"' : 0);
1198: r = history_expand_internal (string, i, qc, &eindex, &temp, result);
1199: if (r < 0)
1200: {
1201: *output = temp;
1202: xfree (result);
1203: if (string != hstring)
1204: xfree (string);
1205: return -1;
1206: }
1207: else
1208: {
1209: if (temp)
1210: {
1211: modified++;
1212: if (*temp)
1213: ADD_STRING (temp);
1214: xfree (temp);
1215: }
1216: only_printing = r == 1;
1217: i = eindex;
1218: }
1219: break;
1220: }
1221: }
1222:
1223: *output = result;
1224: if (string != hstring)
1225: xfree (string);
1226:
1227: if (only_printing)
1228: {
1229: #if 0
1230: add_history (result);
1231: #endif
1232: return (2);
1233: }
1234:
1235: return (modified != 0);
1236: }
1237:
1238: /* Return a consed string which is the word specified in SPEC, and found
1239: in FROM. NULL is returned if there is no spec. The address of
1240: ERROR_POINTER is returned if the word specified cannot be found.
1241: CALLER_INDEX is the offset in SPEC to start looking; it is updated
1242: to point to just after the last character parsed. */
1243: static char *
1244: get_history_word_specifier (spec, from, caller_index)
1245: char *spec, *from;
1246: int *caller_index;
1247: {
1248: register int i = *caller_index;
1249: int first, last;
1250: int expecting_word_spec = 0;
1251: char *result;
1252:
1253: /* The range of words to return doesn't exist yet. */
1254: first = last = 0;
1255: result = (char *)NULL;
1256:
1257: /* If we found a colon, then this *must* be a word specification. If
1258: it isn't, then it is an error. */
1259: if (spec[i] == ':')
1260: {
1261: i++;
1262: expecting_word_spec++;
1263: }
1264:
1265: /* Handle special cases first. */
1266:
1267: /* `%' is the word last searched for. */
1268: if (spec[i] == '%')
1269: {
1270: *caller_index = i + 1;
1271: return (search_match ? savestring (search_match) : savestring (""));
1272: }
1273:
1274: /* `*' matches all of the arguments, but not the command. */
1275: if (spec[i] == '*')
1276: {
1277: *caller_index = i + 1;
1278: result = history_arg_extract (1, '$', from);
1279: return (result ? result : savestring (""));
1280: }
1281:
1282: /* `$' is last arg. */
1283: if (spec[i] == '$')
1284: {
1285: *caller_index = i + 1;
1286: return (history_arg_extract ('$', '$', from));
1287: }
1288:
1289: /* Try to get FIRST and LAST figured out. */
1290:
1291: if (spec[i] == '-')
1292: first = 0;
1293: else if (spec[i] == '^')
1294: {
1295: first = 1;
1296: i++;
1297: }
1298: else if (_rl_digit_p (spec[i]) && expecting_word_spec)
1299: {
1300: for (first = 0; _rl_digit_p (spec[i]); i++)
1301: first = (first * 10) + _rl_digit_value (spec[i]);
1302: }
1303: else
1304: return ((char *)NULL); /* no valid `first' for word specifier */
1305:
1306: if (spec[i] == '^' || spec[i] == '*')
1307: {
1308: last = (spec[i] == '^') ? 1 : '$'; /* x* abbreviates x-$ */
1309: i++;
1310: }
1311: else if (spec[i] != '-')
1312: last = first;
1313: else
1314: {
1315: i++;
1316:
1317: if (_rl_digit_p (spec[i]))
1318: {
1319: for (last = 0; _rl_digit_p (spec[i]); i++)
1320: last = (last * 10) + _rl_digit_value (spec[i]);
1321: }
1322: else if (spec[i] == '$')
1323: {
1324: i++;
1325: last = '$';
1326: }
1327: #if 0
1328: else if (!spec[i] || spec[i] == ':')
1329: /* check against `:' because there could be a modifier separator */
1330: #else
1331: else
1332: /* csh seems to allow anything to terminate the word spec here,
1333: leaving it as an abbreviation. */
1334: #endif
1335: last = -1; /* x- abbreviates x-$ omitting word `$' */
1336: }
1337:
1338: *caller_index = i;
1339:
1340: if (last >= first || last == '$' || last < 0)
1341: result = history_arg_extract (first, last, from);
1342:
1343: return (result ? result : (char *)&error_pointer);
1344: }
1345:
1346: /* Extract the args specified, starting at FIRST, and ending at LAST.
1347: The args are taken from STRING. If either FIRST or LAST is < 0,
1348: then make that arg count from the right (subtract from the number of
1349: tokens, so that FIRST = -1 means the next to last token on the line).
1350: If LAST is `$' the last arg from STRING is used. */
1351: char *
1352: history_arg_extract (first, last, string)
1353: int first, last;
1354: const char *string;
1355: {
1356: register int i, len;
1357: char *result;
1358: int size, offset;
1359: char **list;
1360:
1361: /* XXX - think about making history_tokenize return a struct array,
1362: each struct in array being a string and a length to avoid the
1363: calls to strlen below. */
1364: if ((list = history_tokenize (string)) == NULL)
1365: return ((char *)NULL);
1366:
1367: for (len = 0; list[len]; len++)
1368: ;
1369:
1370: if (last < 0)
1371: last = len + last - 1;
1372:
1373: if (first < 0)
1374: first = len + first - 1;
1375:
1376: if (last == '$')
1377: last = len - 1;
1378:
1379: if (first == '$')
1380: first = len - 1;
1381:
1382: last++;
1383:
1384: if (first >= len || last > len || first < 0 || last < 0 || first > last)
1385: result = ((char *)NULL);
1386: else
1387: {
1388: for (size = 0, i = first; i < last; i++)
1389: size += strlen (list[i]) + 1;
1390: result = (char *)xmalloc (size + 1);
1391: result[0] = '\0';
1392:
1393: for (i = first, offset = 0; i < last; i++)
1394: {
1395: strcpy (result + offset, list[i]);
1396: offset += strlen (list[i]);
1397: if (i + 1 < last)
1398: {
1399: result[offset++] = ' ';
1400: result[offset] = 0;
1401: }
1402: }
1403: }
1404:
1405: for (i = 0; i < len; i++)
1406: xfree (list[i]);
1407: xfree (list);
1408:
1409: return (result);
1410: }
1411:
1412: static int
1413: history_tokenize_word (string, ind)
1414: const char *string;
1415: int ind;
1416: {
1417: register int i;
1418: int delimiter, nestdelim, delimopen;
1419:
1420: i = ind;
1421: delimiter = nestdelim = 0;
1422:
1423: if (member (string[i], "()\n"))
1424: {
1425: i++;
1426: return i;
1427: }
1428:
1429: if (member (string[i], "<>;&|$"))
1430: {
1431: int peek = string[i + 1];
1432:
1433: if (peek == string[i] && peek != '$')
1434: {
1435: if (peek == '<' && string[i + 2] == '-')
1436: i++;
1437: else if (peek == '<' && string[i + 2] == '<')
1438: i++;
1439: i += 2;
1440: return i;
1441: }
1442: else if ((peek == '&' && (string[i] == '>' || string[i] == '<')) ||
1443: (peek == '>' && string[i] == '&'))
1444: {
1445: i += 2;
1446: return i;
1447: }
1448: /* XXX - separated out for later -- bash-4.2 */
1449: else if ((peek == '(' && (string[i] == '>' || string[i] == '<')) || /* ) */
1450: (peek == '(' && string[i] == '$')) /*)*/
1451: {
1452: i += 2;
1453: delimopen = '(';
1454: delimiter = ')';
1455: nestdelim = 1;
1456: goto get_word;
1457: }
1458: #if 0
1459: else if (peek == '\'' && string[i] == '$')
1460: {
1461: i += 2; /* XXX */
1462: return i;
1463: }
1464: #endif
1465:
1466: if (string[i] != '$')
1467: {
1468: i++;
1469: return i;
1470: }
1471: }
1472:
1473: /* same code also used for $(...)/<(...)/>(...) above */
1474: if (member (string[i], "!@?+*"))
1475: {
1476: int peek = string[i + 1];
1477:
1478: if (peek == '(') /*)*/
1479: {
1480: /* Shell extended globbing patterns */
1481: i += 2;
1482: delimopen = '(';
1483: delimiter = ')'; /* XXX - not perfect */
1484: nestdelim = 1;
1485: }
1486: }
1487:
1488: get_word:
1489: /* Get word from string + i; */
1490:
1491: if (delimiter == 0 && member (string[i], HISTORY_QUOTE_CHARACTERS))
1492: delimiter = string[i++];
1493:
1494: for (; string[i]; i++)
1495: {
1496: if (string[i] == '\\' && string[i + 1] == '\n')
1497: {
1498: i++;
1499: continue;
1500: }
1501:
1502: if (string[i] == '\\' && delimiter != '\'' &&
1503: (delimiter != '"' || member (string[i], slashify_in_quotes)))
1504: {
1505: i++;
1506: continue;
1507: }
1508:
1509: /* delimiter must be set and set to something other than a quote if
1510: nestdelim is set, so these tests are safe. */
1511: if (nestdelim && string[i] == delimopen)
1512: {
1513: nestdelim++;
1514: continue;
1515: }
1516: if (nestdelim && string[i] == delimiter)
1517: {
1518: nestdelim--;
1519: if (nestdelim == 0)
1520: delimiter = 0;
1521: continue;
1522: }
1523:
1524: if (delimiter && string[i] == delimiter)
1525: {
1526: delimiter = 0;
1527: continue;
1528: }
1529:
1530: if (delimiter == 0 && (member (string[i], history_word_delimiters)))
1531: break;
1532:
1533: if (delimiter == 0 && member (string[i], HISTORY_QUOTE_CHARACTERS))
1534: delimiter = string[i];
1535: }
1536:
1537: return i;
1538: }
1539:
1540: static char *
1541: history_substring (string, start, end)
1542: const char *string;
1543: int start, end;
1544: {
1545: register int len;
1546: register char *result;
1547:
1548: len = end - start;
1549: result = (char *)xmalloc (len + 1);
1550: strncpy (result, string + start, len);
1551: result[len] = '\0';
1552: return result;
1553: }
1554:
1555: /* Parse STRING into tokens and return an array of strings. If WIND is
1556: not -1 and INDP is not null, we also want the word surrounding index
1557: WIND. The position in the returned array of strings is returned in
1558: *INDP. */
1559: static char **
1560: history_tokenize_internal (string, wind, indp)
1561: const char *string;
1562: int wind, *indp;
1563: {
1564: char **result;
1565: register int i, start, result_index, size;
1566:
1567: /* If we're searching for a string that's not part of a word (e.g., " "),
1568: make sure we set *INDP to a reasonable value. */
1569: if (indp && wind != -1)
1570: *indp = -1;
1571:
1572: /* Get a token, and stuff it into RESULT. The tokens are split
1573: exactly where the shell would split them. */
1574: for (i = result_index = size = 0, result = (char **)NULL; string[i]; )
1575: {
1576: /* Skip leading whitespace. */
1577: for (; string[i] && whitespace (string[i]); i++)
1578: ;
1579: if (string[i] == 0 || string[i] == history_comment_char)
1580: return (result);
1581:
1582: start = i;
1583:
1584: i = history_tokenize_word (string, start);
1585:
1586: /* If we have a non-whitespace delimiter character (which would not be
1587: skipped by the loop above), use it and any adjacent delimiters to
1588: make a separate field. Any adjacent white space will be skipped the
1589: next time through the loop. */
1590: if (i == start && history_word_delimiters)
1591: {
1592: i++;
1593: while (string[i] && member (string[i], history_word_delimiters))
1594: i++;
1595: }
1596:
1597: /* If we are looking for the word in which the character at a
1598: particular index falls, remember it. */
1599: if (indp && wind != -1 && wind >= start && wind < i)
1600: *indp = result_index;
1601:
1602: if (result_index + 2 >= size)
1603: result = (char **)xrealloc (result, ((size += 10) * sizeof (char *)));
1604:
1605: result[result_index++] = history_substring (string, start, i);
1606: result[result_index] = (char *)NULL;
1607: }
1608:
1609: return (result);
1610: }
1611:
1612: /* Return an array of tokens, much as the shell might. The tokens are
1613: parsed out of STRING. */
1614: char **
1615: history_tokenize (string)
1616: const char *string;
1617: {
1618: return (history_tokenize_internal (string, -1, (int *)NULL));
1619: }
1620:
1621: /* Free members of WORDS from START to an empty string */
1622: static void
1623: freewords (words, start)
1624: char **words;
1625: int start;
1626: {
1627: register int i;
1628:
1629: for (i = start; words[i]; i++)
1630: xfree (words[i]);
1631: }
1632:
1633: /* Find and return the word which contains the character at index IND
1634: in the history line LINE. Used to save the word matched by the
1635: last history !?string? search. */
1636: static char *
1637: history_find_word (line, ind)
1638: char *line;
1639: int ind;
1640: {
1641: char **words, *s;
1642: int i, wind;
1643:
1644: words = history_tokenize_internal (line, ind, &wind);
1645: if (wind == -1 || words == 0)
1646: {
1647: if (words)
1648: freewords (words, 0);
1649: FREE (words);
1650: return ((char *)NULL);
1651: }
1652: s = words[wind];
1653: for (i = 0; i < wind; i++)
1654: xfree (words[i]);
1655: freewords (words, wind + 1);
1656: xfree (words);
1657: return s;
1658: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to histexpand.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