1
/* histexpand.c -- history expansion. */
3
/* Copyright (C) 1989-2004 Free Software Foundation, Inc.
5
This file contains the GNU History Library (the Library), a set of
6
routines for managing the text of previously typed lines.
8
The Library 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 2, or (at your option)
13
The Library is distributed in the hope that it will be useful, but
14
WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
General Public License for more details.
18
The GNU General Public License is often shipped with GNU software, and
19
is generally kept in a file called COPYING or LICENSE. If you do not
20
have a copy of the license, write to the Free Software Foundation,
21
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
23
#define READLINE_LIBRARY
25
#if defined (HAVE_CONFIG_H)
26
# include "config_readline.h"
31
#if defined (HAVE_STDLIB_H)
34
# include "ansi_stdlib.h"
35
#endif /* HAVE_STDLIB_H */
37
#if defined (HAVE_UNISTD_H)
39
# include <sys/types.h>
52
#define HISTORY_WORD_DELIMITERS " \t\n;&()|<>"
53
#define HISTORY_QUOTE_CHARACTERS "\"'`"
55
#define slashify_in_quotes "\\`\"$"
57
typedef int _hist_search_func_t PARAMS((const char *, int));
59
static char error_pointer;
61
static char *subst_lhs;
62
static char *subst_rhs;
63
static int subst_lhs_len;
64
static int subst_rhs_len;
66
static char *get_history_word_specifier PARAMS((char *, char *, int *));
67
static char *history_find_word PARAMS((char *, int));
68
static int history_tokenize_word PARAMS((const char *, int));
69
static char *history_substring PARAMS((const char *, int, int));
71
static char *quote_breaks PARAMS((char *));
73
/* Variables exported by this file. */
74
/* The character that represents the start of a history expansion
75
request. This is usually `!'. */
76
char history_expansion_char = '!';
78
/* The character that invokes word substitution if found at the start of
79
a line. This is usually `^'. */
80
char history_subst_char = '^';
82
/* During tokenization, if this character is seen as the first character
83
of a word, then it, and all subsequent characters upto a newline are
84
ignored. For a Bourne shell, this should be '#'. Bash special cases
85
the interactive comment character to not be a comment delimiter. */
86
char history_comment_char = '\0';
88
/* The list of characters which inhibit the expansion of text if found
89
immediately following history_expansion_char. */
90
const char *history_no_expand_chars = " \t\n\r=";
92
/* If set to a non-zero value, single quotes inhibit history expansion.
94
int history_quotes_inhibit_expansion = 0;
96
/* Used to split words by history_tokenize_internal. */
97
const char *history_word_delimiters = HISTORY_WORD_DELIMITERS;
99
/* If set, this points to a function that is called to verify that a
100
particular history expansion should be performed. */
101
rl_linebuf_func_t *history_inhibit_expansion_function;
103
/* **************************************************************** */
105
/* History Expansion */
107
/* **************************************************************** */
109
/* Hairy history expansion on text, not tokens. This is of general
110
use, and thus belongs in this library. */
112
/* The last string searched for by a !?string? search. */
113
static char *search_string;
115
/* The last string matched by a !?string? search. */
116
static char *search_match;
118
/* Return the event specified at TEXT + OFFSET modifying OFFSET to
119
point to after the event specifier. Just a pointer to the history
120
line is returned; NULL is returned in the event of a bad specifier.
121
You pass STRING with *INDEX equal to the history_expansion_char that
122
begins this specification.
123
DELIMITING_QUOTE is a character that is allowed to end the string
124
specification for what to search for in addition to the normal
125
characters `:', ` ', `\t', `\n', and sometimes `?'.
126
So you might call this function like:
127
line = get_history_event ("!echo:p", &index, 0); */
129
get_history_event (string, caller_index, delimiting_quote)
132
int delimiting_quote;
137
int which, sign, local_index, substring_okay;
138
_hist_search_func_t *search_func;
141
/* The event can be specified in a number of ways.
143
!! the previous command
145
!-n current command-line minus N
146
!str the most recent command starting with STR
148
the most recent command containing STR
150
All values N are determined via HISTORY_BASE. */
154
if (string[i] != history_expansion_char)
155
return ((char *)NULL);
157
/* Move on to the specification. */
163
#define RETURN_ENTRY(e, w) \
164
return ((e = history_get (w)) ? e->line : (char *)NULL)
166
/* Handle !! case. */
167
if (string[i] == history_expansion_char)
170
which = history_base + (history_length - 1);
172
RETURN_ENTRY (entry, which);
175
/* Hack case of numeric line specification. */
176
if (string[i] == '-')
182
if (_rl_digit_p (string[i]))
184
/* Get the extent of the digits and compute the value. */
185
for (which = 0; _rl_digit_p (string[i]); i++)
186
which = (which * 10) + _rl_digit_value (string[i]);
191
which = (history_length + history_base) - which;
193
RETURN_ENTRY (entry, which);
196
/* This must be something to search for. If the spec begins with
197
a '?', then the string may be anywhere on the line. Otherwise,
198
the string must be found at the start of a line. */
199
if (string[i] == '?')
205
/* Only a closing `?' or a newline delimit a substring search string. */
206
for (local_index = i; (c = string[i]); i++)
208
#if defined (HANDLE_MULTIBYTE)
209
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
214
memset (&ps, 0, sizeof (mbstate_t));
215
/* These produce warnings because we're passing a const string to a
216
function that takes a non-const string. */
217
_rl_adjust_point ((char *)string, i, &ps);
218
if ((v = _rl_get_char_len ((char *)string + i, &ps)) > 1)
225
#endif /* HANDLE_MULTIBYTE */
226
if ((!substring_okay && (whitespace (c) || c == ':' ||
227
(history_search_delimiter_chars && member (c, history_search_delimiter_chars)) ||
228
string[i] == delimiting_quote)) ||
230
(substring_okay && string[i] == '?'))
234
which = i - local_index;
235
temp = (char *)xmalloc (1 + which);
237
strncpy (temp, string + local_index, which);
240
if (substring_okay && string[i] == '?')
245
#define FAIL_SEARCH() \
247
history_offset = history_length; free (temp) ; return (char *)NULL; \
250
/* If there is no search string, try to use the previous search string,
251
if one exists. If not, fail immediately. */
252
if (*temp == '\0' && substring_okay)
257
temp = savestring (search_string);
263
search_func = substring_okay ? history_search : history_search_prefix;
266
local_index = (*search_func) (temp, -1);
271
if (local_index == 0 || substring_okay)
273
entry = current_history ();
274
history_offset = history_length;
276
/* If this was a substring search, then remember the
277
string that we matched for word substitution. */
280
FREE (search_string);
281
search_string = temp;
284
search_match = history_find_word (entry->line, local_index);
289
return (entry->line);
301
/* Function for extracting single-quoted strings. Used for inhibiting
302
history expansion within single quotes. */
304
/* Extract the contents of STRING as if it is enclosed in single quotes.
305
SINDEX, when passed in, is the offset of the character immediately
306
following the opening single quote; on exit, SINDEX is left pointing
307
to the closing single quote. */
309
hist_string_extract_single_quoted (string, sindex)
315
for (i = *sindex; string[i] && string[i] != '\''; i++)
325
register char *p, *r;
329
for (p = s; p && *p; p++, len++)
333
else if (whitespace (*p) || *p == '\n')
337
r = ret = (char *)xmalloc (len);
339
for (p = s; p && *p; )
349
else if (whitespace (*p) || *p == '\n')
364
hist_error(s, start, current, errtype)
366
int start, current, errtype;
372
ll = current - start;
376
case EVENT_NOT_FOUND:
377
emsg = "event not found";
381
emsg = "bad word specifier";
385
emsg = "substitution failed";
389
emsg = "unrecognized history modifier";
393
emsg = "no previous substitution";
397
emsg = "unknown expansion error";
402
temp = (char *)xmalloc (ll + elen + 3);
403
strncpy (temp, s + start, ll);
406
strcpy (temp + ll + 2, emsg);
410
/* Get a history substitution string from STR starting at *IPTR
411
and return it. The length is returned in LENPTR.
413
A backslash can quote the delimiter. If the string is the
414
empty string, the previous pattern is used. If there is
415
no previous pattern for the lhs, the last history search
418
If IS_RHS is 1, we ignore empty strings and set the pattern
419
to "" anyway. subst_lhs is not changed if the lhs is empty;
420
subst_rhs is allowed to be set to the empty string. */
423
get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
425
int *iptr, delimiter, is_rhs, *lenptr;
427
register int si, i, j, k;
429
#if defined (HANDLE_MULTIBYTE)
436
#if defined (HANDLE_MULTIBYTE)
437
memset (&ps, 0, sizeof (mbstate_t));
438
_rl_adjust_point (str, i, &ps);
441
for (si = i; str[si] && str[si] != delimiter; si++)
442
#if defined (HANDLE_MULTIBYTE)
443
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
446
if ((v = _rl_get_char_len (str + si, &ps)) > 1)
448
else if (str[si] == '\\' && str[si + 1] == delimiter)
452
#endif /* HANDLE_MULTIBYTE */
453
if (str[si] == '\\' && str[si + 1] == delimiter)
456
if (si > i || is_rhs)
458
s = (char *)xmalloc (si - i + 1);
459
for (j = 0, k = i; k < si; j++, k++)
461
/* Remove a backslash quoting the search string delimiter. */
462
if (str[k] == '\\' && str[k + 1] == delimiter)
480
postproc_subst_rhs ()
485
new = (char *)xmalloc (new_size = subst_rhs_len + subst_lhs_len);
486
for (i = j = 0; i < subst_rhs_len; i++)
488
if (subst_rhs[i] == '&')
490
if (j + subst_lhs_len >= new_size)
491
new = (char *)xrealloc (new, (new_size = new_size * 2 + subst_lhs_len));
492
strcpy (new + j, subst_lhs);
497
/* a single backslash protects the `&' from lhs interpolation */
498
if (subst_rhs[i] == '\\' && subst_rhs[i + 1] == '&')
501
new = (char *)xrealloc (new, new_size *= 2);
502
new[j++] = subst_rhs[i];
511
/* Expand the bulk of a history specifier starting at STRING[START].
512
Returns 0 if everything is OK, -1 if an error occurred, and 1
513
if the `p' modifier was supplied and the caller should just print
514
the returned string. Returns the new index into string in
515
*END_INDEX_PTR, and the expanded specifier in *RET_STRING. */
517
history_expand_internal (string, start, end_index_ptr, ret_string, current_line)
519
int start, *end_index_ptr;
521
char *current_line; /* for !# */
523
int i, n, starting_index;
524
int substitute_globally, subst_bywords, want_quotes, print_only;
525
char *event, *temp, *result, *tstr, *t, c, *word_spec;
527
#if defined (HANDLE_MULTIBYTE)
530
memset (&ps, 0, sizeof (mbstate_t));
533
result = (char *)xmalloc (result_len = 128);
537
/* If it is followed by something that starts a word specifier,
538
then !! is implied as the event specifier. */
540
if (member (string[i + 1], ":$*%^"))
545
fake_s[0] = fake_s[1] = history_expansion_char;
547
event = get_history_event (fake_s, &fake_i, 0);
549
else if (string[i + 1] == '#')
552
event = current_line;
556
int quoted_search_delimiter = 0;
558
/* If the character before this `!' is a double or single
559
quote, then this expansion takes place inside of the
560
quoted string. If we have to search for some text ("!foo"),
561
allow the delimiter to end the search string. */
562
#if defined (HANDLE_MULTIBYTE)
563
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
566
l = _rl_find_prev_mbchar (string, i, MB_FIND_ANY);
568
/* XXX - original patch had i - 1 ??? If i == 0 it would fail. */
569
if (i && (ch == '\'' || ch == '"'))
570
quoted_search_delimiter = ch;
573
#endif /* HANDLE_MULTIBYTE */
574
if (i && (string[i - 1] == '\'' || string[i - 1] == '"'))
575
quoted_search_delimiter = string[i - 1];
577
event = get_history_event (string, &i, quoted_search_delimiter);
582
*ret_string = hist_error (string, start, i, EVENT_NOT_FOUND);
587
/* If a word specifier is found, then do what that requires. */
589
word_spec = get_history_word_specifier (string, event, &i);
591
/* There is no such thing as a `malformed word specifier'. However,
592
it is possible for a specifier that has no match. In that case,
594
if (word_spec == (char *)&error_pointer)
596
*ret_string = hist_error (string, starting_index, i, BAD_WORD_SPEC);
601
/* If no word specifier, than the thing of interest was the event. */
602
temp = word_spec ? savestring (word_spec) : savestring (event);
605
/* Perhaps there are other modifiers involved. Do what they say. */
606
want_quotes = substitute_globally = subst_bywords = print_only = 0;
609
while (string[i] == ':')
613
if (c == 'g' || c == 'a')
615
substitute_globally = 1;
629
*ret_string = hist_error (string, i+1, i+2, BAD_MODIFIER);
642
/* :p means make this the last executed line. So we
643
return an error state after adding this line to the
649
/* :t discards all but the last part of the pathname. */
651
tstr = strrchr (temp, '/');
655
t = savestring (tstr);
661
/* :h discards the last part of a pathname. */
663
tstr = strrchr (temp, '/');
668
/* :r discards the suffix. */
670
tstr = strrchr (temp, '.');
675
/* :e discards everything but the suffix. */
677
tstr = strrchr (temp, '.');
680
t = savestring (tstr);
686
/* :s/this/that substitutes `that' for the first
687
occurrence of `this'. :gs/this/that substitutes `that'
688
for each occurrence of `this'. :& repeats the last
689
substitution. :g& repeats the last substitution
696
int delimiter, failed, si, l_temp, ws, we;
700
if (i + 2 < (int)strlen (string))
702
#if defined (HANDLE_MULTIBYTE)
703
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
705
_rl_adjust_point (string, i + 2, &ps);
706
if (_rl_get_char_len (string + i + 2, &ps) > 1)
709
delimiter = string[i + 2];
712
#endif /* HANDLE_MULTIBYTE */
713
delimiter = string[i + 2];
716
break; /* no search delimiter */
720
t = get_subst_pattern (string, &i, delimiter, 0, &subst_lhs_len);
721
/* An empty substitution lhs with no previous substitution
722
uses the last search string as the lhs. */
730
if (search_string && *search_string)
732
subst_lhs = savestring (search_string);
733
subst_lhs_len = strlen (subst_lhs);
737
subst_lhs = (char *) NULL;
743
subst_rhs = get_subst_pattern (string, &i, delimiter, 1, &subst_rhs_len);
745
/* If `&' appears in the rhs, it's supposed to be replaced
747
if (member ('&', subst_rhs))
748
postproc_subst_rhs ();
753
/* If there is no lhs, the substitution can't succeed. */
754
if (subst_lhs_len == 0)
756
*ret_string = hist_error (string, starting_index, i, NO_PREV_SUBST);
762
l_temp = strlen (temp);
763
/* Ignore impossible cases. */
764
if (subst_lhs_len > l_temp)
766
*ret_string = hist_error (string, starting_index, i, SUBST_FAILED);
772
/* Find the first occurrence of THIS in TEMP. */
773
/* Substitute SUBST_RHS for SUBST_LHS in TEMP. There are three
776
1. substitute_globally == subst_bywords == 0
777
2. substitute_globally == 1 && subst_bywords == 0
778
3. substitute_globally == 0 && subst_bywords == 1
780
In the first case, we substitute for the first occurrence only.
781
In the second case, we substitute for every occurrence.
782
In the third case, we tokenize into words and substitute the
783
first occurrence of each word. */
786
for (failed = 1; (si + subst_lhs_len) <= l_temp; si++)
788
/* First skip whitespace and find word boundaries if
789
we're past the end of the word boundary we found
791
if (subst_bywords && si > we)
793
for (; temp[si] && whitespace (temp[si]); si++)
796
we = history_tokenize_word (temp, si);
799
if (STREQN (temp+si, subst_lhs, subst_lhs_len))
801
int len = subst_rhs_len - subst_lhs_len + l_temp;
802
new_event = (char *)xmalloc (1 + len);
803
strncpy (new_event, temp, si);
804
strncpy (new_event + si, subst_rhs, subst_rhs_len);
805
strncpy (new_event + si + subst_rhs_len,
806
temp + si + subst_lhs_len,
807
l_temp - (si + subst_lhs_len));
808
new_event[len] = '\0';
814
if (substitute_globally)
816
/* Reported to fix a bug that causes it to skip every
817
other match when matching a single character. Was
818
si += subst_rhs_len previously. */
819
si += subst_rhs_len - 1;
820
l_temp = strlen (temp);
821
substitute_globally++;
824
else if (subst_bywords)
827
l_temp = strlen (temp);
835
if (substitute_globally > 1)
837
substitute_globally = 0;
838
continue; /* don't want to increment i */
842
continue; /* don't want to increment i */
844
*ret_string = hist_error (string, starting_index, i, SUBST_FAILED);
852
/* Done with modfiers. */
853
/* Believe it or not, we have to back the pointer up by one. */
860
if (want_quotes == 'q')
861
x = sh_single_quote (temp);
862
else if (want_quotes == 'x')
863
x = quote_breaks (temp);
865
x = savestring (temp);
873
result = (char *)xrealloc (result, n + 2);
874
strcpy (result, temp);
878
*ret_string = result;
882
/* Expand the string STRING, placing the result into OUTPUT, a pointer
883
to a string. Returns:
885
-1) If there was an error in expansion.
886
0) If no expansions took place (or, if the only change in
887
the text was the de-slashifying of the history expansion
889
1) If expansions did take place
890
2) If the `p' modifier was given and the caller should print the result
892
If an error ocurred in expansion, then OUTPUT contains a descriptive
895
#define ADD_STRING(s) \
898
int sl = strlen (s); \
900
if (j >= result_len) \
902
while (j >= result_len) \
904
result = (char *)xrealloc (result, result_len); \
906
strcpy (result + j - sl, s); \
910
#define ADD_CHAR(c) \
913
if (j >= result_len - 1) \
914
result = (char *)xrealloc (result, result_len += 64); \
921
history_expand (hstring, output)
926
int i, r, l, passc, cc, modified, eindex, only_printing, dquote;
929
/* The output string, and its length. */
933
#if defined (HANDLE_MULTIBYTE)
938
/* Used when adding the string. */
944
/* Setting the history expansion character to 0 inhibits all
945
history expansion. */
946
if (history_expansion_char == 0)
948
*output = savestring (hstring);
952
/* Prepare the buffer for printing error messages. */
953
result = (char *)xmalloc (result_len = 256);
956
only_printing = modified = 0;
957
l = strlen (hstring);
959
/* Grovel the string. Only backslash and single quotes can quote the
960
history escape character. We also handle arg specifiers. */
962
/* Before we grovel forever, see if the history_expansion_char appears
963
anywhere within the text. */
965
/* The quick substitution character is a history expansion all right. That
966
is to say, "^this^that^" is equivalent to "!!:s^this^that^", and in fact,
967
that is the substitution that we do. */
968
if (hstring[0] == history_subst_char)
970
string = (char *)xmalloc (l + 5);
972
string[0] = string[1] = history_expansion_char;
975
strcpy (string + 4, hstring);
980
#if defined (HANDLE_MULTIBYTE)
981
memset (&ps, 0, sizeof (mbstate_t));
985
/* If not quick substitution, still maybe have to do expansion. */
987
/* `!' followed by one of the characters in history_no_expand_chars
988
is NOT an expansion. */
989
for (i = dquote = 0; string[i]; i++)
991
#if defined (HANDLE_MULTIBYTE)
992
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
995
v = _rl_get_char_len (string + i, &ps);
1002
#endif /* HANDLE_MULTIBYTE */
1005
/* The history_comment_char, if set, appearing at the beginning
1006
of a word signifies that the rest of the line should not have
1007
history expansion performed on it.
1008
Skip the rest of the line and break out of the loop. */
1009
if (history_comment_char && string[i] == history_comment_char &&
1010
(i == 0 || member (string[i - 1], history_word_delimiters)))
1016
else if (string[i] == history_expansion_char)
1018
if (!cc || member (cc, history_no_expand_chars))
1020
/* If the calling application has set
1021
history_inhibit_expansion_function to a function that checks
1022
for special cases that should not be history expanded,
1023
call the function and skip the expansion if it returns a
1025
else if (history_inhibit_expansion_function &&
1026
(*history_inhibit_expansion_function) (string, i))
1031
/* Shell-like quoting: allow backslashes to quote double quotes
1032
inside a double-quoted string. */
1033
else if (dquote && string[i] == '\\' && cc == '"')
1035
/* More shell-like quoting: if we're paying attention to single
1036
quotes and letting them quote the history expansion character,
1037
then we need to pay attention to double quotes, because single
1038
quotes are not special inside double-quoted strings. */
1039
else if (history_quotes_inhibit_expansion && string[i] == '"')
1041
dquote = 1 - dquote;
1043
else if (dquote == 0 && history_quotes_inhibit_expansion && string[i] == '\'')
1045
/* If this is bash, single quotes inhibit history expansion. */
1047
hist_string_extract_single_quoted (string, &i);
1049
else if (history_quotes_inhibit_expansion && string[i] == '\\')
1051
/* If this is bash, allow backslashes to quote single
1052
quotes and the history expansion character. */
1053
if (cc == '\'' || cc == history_expansion_char)
1059
if (string[i] != history_expansion_char)
1062
*output = savestring (string);
1067
/* Extract and perform the substitution. */
1068
for (passc = dquote = i = j = 0; i < l; i++)
1070
int tchar = string[i];
1079
#if defined (HANDLE_MULTIBYTE)
1080
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1085
memset (mb, 0, sizeof (mb));
1086
for (k = 0; k < MB_LEN_MAX; k++)
1089
memset (&ps, 0, sizeof (mbstate_t));
1090
if (_rl_get_char_len (mb, &ps) == -2)
1095
if (strlen (mb) > 1)
1101
#endif /* HANDLE_MULTIBYTE */
1103
if (tchar == history_expansion_char)
1105
else if (tchar == history_comment_char)
1111
ADD_CHAR (string[i]);
1120
dquote = 1 - dquote;
1126
/* If history_quotes_inhibit_expansion is set, single quotes
1127
inhibit history expansion. */
1128
if (dquote == 0 && history_quotes_inhibit_expansion)
1133
hist_string_extract_single_quoted (string, &i);
1135
slen = i - quote + 2;
1136
temp = (char *)xmalloc (slen);
1137
strncpy (temp, string + quote, slen);
1138
temp[slen - 1] = '\0';
1143
ADD_CHAR (string[i]);
1147
case -2: /* history_comment_char */
1148
if (i == 0 || member (string[i - 1], history_word_delimiters))
1150
temp = (char *)xmalloc (l - i + 1);
1151
strcpy (temp, string + i);
1157
ADD_CHAR (string[i]);
1160
case -3: /* history_expansion_char */
1163
/* If the history_expansion_char is followed by one of the
1164
characters in history_no_expand_chars, then it is not a
1165
candidate for expansion of any kind. */
1166
if (member (cc, history_no_expand_chars))
1168
ADD_CHAR (string[i]);
1172
#if defined (NO_BANG_HASH_MODIFIERS)
1173
/* There is something that is listed as a `word specifier' in csh
1174
documentation which means `the expanded text to this point'.
1175
That is not a word specifier, it is an event specifier. If we
1176
don't want to allow modifiers with `!#', just stick the current
1177
output line in again. */
1182
temp = (char *)xmalloc (1 + strlen (result));
1183
strcpy (temp, result);
1192
r = history_expand_internal (string, i, &eindex, &temp, result);
1197
if (string != hstring)
1210
only_printing = r == 1;
1218
if (string != hstring)
1224
add_history (result);
1229
return (modified != 0);
1232
/* Return a consed string which is the word specified in SPEC, and found
1233
in FROM. NULL is returned if there is no spec. The address of
1234
ERROR_POINTER is returned if the word specified cannot be found.
1235
CALLER_INDEX is the offset in SPEC to start looking; it is updated
1236
to point to just after the last character parsed. */
1238
get_history_word_specifier (spec, from, caller_index)
1242
register int i = *caller_index;
1244
int expecting_word_spec = 0;
1247
/* The range of words to return doesn't exist yet. */
1249
result = (char *)NULL;
1251
/* If we found a colon, then this *must* be a word specification. If
1252
it isn't, then it is an error. */
1256
expecting_word_spec++;
1259
/* Handle special cases first. */
1261
/* `%' is the word last searched for. */
1264
*caller_index = i + 1;
1265
return (search_match ? savestring (search_match) : savestring (""));
1268
/* `*' matches all of the arguments, but not the command. */
1271
*caller_index = i + 1;
1272
result = history_arg_extract (1, '$', from);
1273
return (result ? result : savestring (""));
1276
/* `$' is last arg. */
1279
*caller_index = i + 1;
1280
return (history_arg_extract ('$', '$', from));
1283
/* Try to get FIRST and LAST figured out. */
1287
else if (spec[i] == '^')
1292
else if (_rl_digit_p (spec[i]) && expecting_word_spec)
1294
for (first = 0; _rl_digit_p (spec[i]); i++)
1295
first = (first * 10) + _rl_digit_value (spec[i]);
1298
return ((char *)NULL); /* no valid `first' for word specifier */
1300
if (spec[i] == '^' || spec[i] == '*')
1302
last = (spec[i] == '^') ? 1 : '$'; /* x* abbreviates x-$ */
1305
else if (spec[i] != '-')
1311
if (_rl_digit_p (spec[i]))
1313
for (last = 0; _rl_digit_p (spec[i]); i++)
1314
last = (last * 10) + _rl_digit_value (spec[i]);
1316
else if (spec[i] == '$')
1322
else if (!spec[i] || spec[i] == ':')
1323
/* check against `:' because there could be a modifier separator */
1326
/* csh seems to allow anything to terminate the word spec here,
1327
leaving it as an abbreviation. */
1329
last = -1; /* x- abbreviates x-$ omitting word `$' */
1334
if (last >= first || last == '$' || last < 0)
1335
result = history_arg_extract (first, last, from);
1337
return (result ? result : (char *)&error_pointer);
1340
/* Extract the args specified, starting at FIRST, and ending at LAST.
1341
The args are taken from STRING. If either FIRST or LAST is < 0,
1342
then make that arg count from the right (subtract from the number of
1343
tokens, so that FIRST = -1 means the next to last token on the line).
1344
If LAST is `$' the last arg from STRING is used. */
1346
history_arg_extract (first, last, string)
1350
register int i, len;
1355
/* XXX - think about making history_tokenize return a struct array,
1356
each struct in array being a string and a length to avoid the
1357
calls to strlen below. */
1358
if ((list = history_tokenize (string)) == NULL)
1359
return ((char *)NULL);
1361
for (len = 0; list[len]; len++)
1365
last = len + last - 1;
1368
first = len + first - 1;
1378
if (first >= len || last > len || first < 0 || last < 0 || first > last)
1379
result = ((char *)NULL);
1382
for (size = 0, i = first; i < last; i++)
1383
size += strlen (list[i]) + 1;
1384
result = (char *)xmalloc (size + 1);
1387
for (i = first, offset = 0; i < last; i++)
1389
strcpy (result + offset, list[i]);
1390
offset += strlen (list[i]);
1393
result[offset++] = ' ';
1399
for (i = 0; i < len; i++)
1407
history_tokenize_word (string, ind)
1417
if (member (string[i], "()\n"))
1423
if (member (string[i], "<>;&|$"))
1425
int peek = string[i + 1];
1427
if (peek == string[i] && peek != '$')
1429
if (peek == '<' && string[i + 2] == '-')
1431
else if (peek == '<' && string[i + 2] == '<')
1438
if ((peek == '&' && (string[i] == '>' || string[i] == '<')) ||
1439
(peek == '>' && string[i] == '&') ||
1440
(peek == '(' && (string[i] == '>' || string[i] == '<')) || /* ) */
1441
(peek == '(' && string[i] == '$')) /* ) */
1448
if (string[i] != '$')
1455
/* Get word from string + i; */
1457
if (member (string[i], HISTORY_QUOTE_CHARACTERS))
1458
delimiter = string[i++];
1460
for (; string[i]; i++)
1462
if (string[i] == '\\' && string[i + 1] == '\n')
1468
if (string[i] == '\\' && delimiter != '\'' &&
1469
(delimiter != '"' || member (string[i], slashify_in_quotes)))
1475
if (delimiter && string[i] == delimiter)
1481
if (!delimiter && (member (string[i], history_word_delimiters)))
1484
if (!delimiter && member (string[i], HISTORY_QUOTE_CHARACTERS))
1485
delimiter = string[i];
1492
history_substring (string, start, end)
1497
register char *result;
1500
result = (char *)xmalloc (len + 1);
1501
strncpy (result, string + start, len);
1506
/* Parse STRING into tokens and return an array of strings. If WIND is
1507
not -1 and INDP is not null, we also want the word surrounding index
1508
WIND. The position in the returned array of strings is returned in
1511
history_tokenize_internal (string, wind, indp)
1516
register int i, start, result_index, size;
1518
/* If we're searching for a string that's not part of a word (e.g., " "),
1519
make sure we set *INDP to a reasonable value. */
1520
if (indp && wind != -1)
1523
/* Get a token, and stuff it into RESULT. The tokens are split
1524
exactly where the shell would split them. */
1525
for (i = result_index = size = 0, result = (char **)NULL; string[i]; )
1527
/* Skip leading whitespace. */
1528
for (; string[i] && whitespace (string[i]); i++)
1530
if (string[i] == 0 || string[i] == history_comment_char)
1535
i = history_tokenize_word (string, start);
1537
/* If we have a non-whitespace delimiter character (which would not be
1538
skipped by the loop above), use it and any adjacent delimiters to
1539
make a separate field. Any adjacent white space will be skipped the
1540
next time through the loop. */
1541
if (i == start && history_word_delimiters)
1544
while (string[i] && member (string[i], history_word_delimiters))
1548
/* If we are looking for the word in which the character at a
1549
particular index falls, remember it. */
1550
if (indp && wind != -1 && wind >= start && wind < i)
1551
*indp = result_index;
1553
if (result_index + 2 >= size)
1554
result = (char **)xrealloc (result, ((size += 10) * sizeof (char *)));
1556
result[result_index++] = history_substring (string, start, i);
1557
result[result_index] = (char *)NULL;
1563
/* Return an array of tokens, much as the shell might. The tokens are
1564
parsed out of STRING. */
1566
history_tokenize (string)
1569
return (history_tokenize_internal (string, -1, (int *)NULL));
1572
/* Find and return the word which contains the character at index IND
1573
in the history line LINE. Used to save the word matched by the
1574
last history !?string? search. */
1576
history_find_word (line, ind)
1583
words = history_tokenize_internal (line, ind, &wind);
1584
if (wind == -1 || words == 0)
1585
return ((char *)NULL);
1587
for (i = 0; i < wind; i++)
1589
for (i = wind + 1; words[i]; i++)
added
removed
cmd-line-utils/readline/histexpand.c
