1 /* subst.c -- The part of the shell that does parameter, command, and
2 globbing substitutions. */
4 /* ``Have a little faith, there's magic in the night. You ain't a
5 beauty, but, hey, you're alright.'' */
7 /* Copyright (C) 1987-2004 Free Software Foundation, Inc.
9 This file is part of GNU Bash, the Bourne Again SHell.
11 Bash is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 2, or (at your option) any later
16 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License along
22 with Bash; see the file COPYING. If not, write to the Free Software
23 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
27 #include "bashtypes.h"
29 #include "chartypes.h"
34 #if defined (HAVE_UNISTD_H)
39 #include "posixstat.h"
45 #include "execute_cmd.h"
49 #include "mailcheck.h"
53 #include "builtins/getopt.h"
54 #include "builtins/common.h"
56 #include <tilde/tilde.h>
57 #include <glob/strmatch.h>
63 /* The size that strings change by. */
64 #define DEFAULT_INITIAL_ARRAY_SIZE 112
65 #define DEFAULT_ARRAY_SIZE 128
71 #define VT_ARRAYMEMBER 3
73 #define VT_STARSUB 128 /* $* or ${array[*]} -- used to split */
75 /* Flags for quoted_strchr */
76 #define ST_BACKSL 0x01
77 #define ST_CTLESC 0x02
78 #define ST_SQUOTE 0x04 /* unused yet */
79 #define ST_DQUOTE 0x08 /* unused yet */
81 /* Flags for the string extraction functions. */
82 #define EX_NOALLOC 0x01 /* just skip; don't return substring */
83 #define EX_VARNAME 0x02 /* variable name; for string_extract () */
85 /* Flags for the `pflags' argument to param_expand() */
86 #define PF_NOCOMSUB 0x01 /* Do not perform command substitution */
88 /* These defs make it easier to use the editor. */
94 /* Evaluates to 1 if C is one of the shell's special parameters whose length
95 can be taken, but is also one of the special expansion characters. */
96 #define VALID_SPECIAL_LENGTH_PARAM(c) \
97 ((c) == '-' || (c) == '?' || (c) == '#')
99 /* Evaluates to 1 if C is one of the shell's special parameters for which an
100 indirect variable reference may be made. */
101 #define VALID_INDIR_PARAM(c) \
102 ((c) == '#' || (c) == '?' || (c) == '@' || (c) == '*')
104 /* Evaluates to 1 if C is one of the OP characters that follows the parameter
105 in ${parameter[:]OPword}. */
106 #define VALID_PARAM_EXPAND_CHAR(c) (sh_syntaxtab[(unsigned char)c] & CSUBSTOP)
108 /* Evaluates to 1 if this is one of the shell's special variables. */
109 #define SPECIAL_VAR(name, wi) \
110 ((DIGIT (*name) && all_digits (name)) || \
111 (name[1] == '\0' && (sh_syntaxtab[(unsigned char)*name] & CSPECVAR)) || \
112 (wi && name[2] == '\0' && VALID_INDIR_PARAM (name[1])))
114 /* An expansion function that takes a string and a quoted flag and returns
115 a WORD_LIST *. Used as the type of the third argument to
116 expand_string_if_necessary(). */
117 typedef WORD_LIST *EXPFUNC __P((char *, int));
119 /* Process ID of the last command executed within command substitution. */
120 pid_t last_command_subst_pid = NO_PID;
121 pid_t current_command_subst_pid = NO_PID;
123 /* Variables used to keep track of the characters in IFS. */
126 unsigned char ifs_cmap[UCHAR_MAX + 1];
128 #if defined (HANDLE_MULTIBYTE)
129 unsigned char ifs_firstc[MB_LEN_MAX];
130 size_t ifs_firstc_len;
132 unsigned char ifs_firstc;
135 /* Extern functions and variables from different files. */
136 extern int last_command_exit_value, last_command_exit_signal;
137 extern int subshell_environment;
138 extern int subshell_level;
139 extern int eof_encountered;
140 extern int return_catch_flag, return_catch_value;
141 extern pid_t dollar_dollar_pid;
142 extern int posixly_correct;
143 extern char *this_command_name;
144 extern struct fd_bitmap *current_fds_to_close;
145 extern int wordexp_only;
146 extern int expanding_redir;
147 extern int tempenv_assign_error;
149 /* Non-zero means to allow unmatched globbed filenames to expand to
151 int allow_null_glob_expansion;
153 /* Non-zero means to throw an error when globbing fails to match anything. */
154 int fail_glob_expansion;
157 /* Variables to keep track of which words in an expanded word list (the
158 output of expand_word_list_internal) are the result of globbing
159 expansions. GLOB_ARGV_FLAGS is used by execute_cmd.c.
160 (CURRENTLY UNUSED). */
161 char *glob_argv_flags;
162 static int glob_argv_flags_size;
165 static WORD_LIST expand_word_error, expand_word_fatal;
166 static char expand_param_error, expand_param_fatal;
168 /* Tell the expansion functions to not longjmp back to top_level on fatal
169 errors. Enabled when doing completion and prompt string expansion. */
170 static int no_longjmp_on_fatal_error = 0;
172 /* Set by expand_word_unsplit; used to inhibit splitting and re-joining
173 $* on $IFS, primarily when doing assignment statements. */
174 static int expand_no_split_dollar_star = 0;
176 /* Used to hold a list of variable assignments preceding a command. Global
177 so the SIGCHLD handler in jobs.c can unwind-protect it when it runs a
179 WORD_LIST *subst_assign_varlist = (WORD_LIST *)NULL;
181 /* A WORD_LIST of words to be expanded by expand_word_list_internal,
182 without any leading variable assignments. */
183 static WORD_LIST *garglist = (WORD_LIST *)NULL;
185 static char *quoted_substring __P((char *, int, int));
186 static int quoted_strlen __P((char *));
187 static char *quoted_strchr __P((char *, int, int));
189 static char *expand_string_if_necessary __P((char *, int, EXPFUNC *));
190 static inline char *expand_string_to_string_internal __P((char *, int, EXPFUNC *));
191 static WORD_LIST *call_expand_word_internal __P((WORD_DESC *, int, int, int *, int *));
192 static WORD_LIST *expand_string_internal __P((char *, int));
193 static WORD_LIST *expand_string_leave_quoted __P((char *, int));
194 static WORD_LIST *expand_string_for_rhs __P((char *, int, int *, int *));
196 static WORD_LIST *list_quote_escapes __P((WORD_LIST *));
197 static char *dequote_escapes __P((char *));
198 static char *make_quoted_char __P((int));
199 static WORD_LIST *quote_list __P((WORD_LIST *));
200 static WORD_LIST *dequote_list __P((WORD_LIST *));
201 static char *remove_quoted_escapes __P((char *));
202 static char *remove_quoted_nulls __P((char *));
204 static int unquoted_substring __P((char *, char *));
205 static int unquoted_member __P((int, char *));
207 static int do_assignment_internal __P((const char *, int));
209 static char *string_extract_verbatim __P((char *, int *, char *));
210 static char *string_extract __P((char *, int *, char *, int));
211 static char *string_extract_double_quoted __P((char *, int *, int));
212 static inline char *string_extract_single_quoted __P((char *, int *));
213 static inline int skip_single_quoted __P((char *, size_t, int));
214 static int skip_double_quoted __P((char *, size_t, int));
215 static char *extract_delimited_string __P((char *, int *, char *, char *, char *, int));
216 static char *extract_dollar_brace_string __P((char *, int *, int, int));
218 static char *pos_params __P((char *, int, int, int));
220 static unsigned char *mb_getcharlens __P((char *, int));
222 static char *remove_upattern __P((char *, char *, int));
223 #if defined (HANDLE_MULTIBYTE)
224 # if !defined (HAVE_WCSDUP)
225 static wchar_t *wcsdup __P((wchar_t *));
227 static wchar_t *remove_wpattern __P((wchar_t *, size_t, wchar_t *, int));
229 static char *remove_pattern __P((char *, char *, int));
231 static int match_pattern_char __P((char *, char *));
232 static int match_upattern __P((char *, char *, int, char **, char **));
233 #if defined (HANDLE_MULTIBYTE)
234 static int match_pattern_wchar __P((wchar_t *, wchar_t *));
235 static int match_wpattern __P((wchar_t *, char **, size_t, wchar_t *, int, char **, char **));
237 static int match_pattern __P((char *, char *, int, char **, char **));
238 static int getpatspec __P((int, char *));
239 static char *getpattern __P((char *, int, int));
240 static char *variable_remove_pattern __P((char *, char *, int, int));
241 static char *list_remove_pattern __P((WORD_LIST *, char *, int, int, int));
242 static char *parameter_list_remove_pattern __P((int, char *, int, int));
244 static char *array_remove_pattern __P((ARRAY *, char *, int, char *, int));
246 static char *parameter_brace_remove_pattern __P((char *, char *, char *, int, int));
248 static char *process_substitute __P((char *, int));
250 static char *read_comsub __P((int, int));
253 static arrayind_t array_length_reference __P((char *));
256 static int valid_brace_expansion_word __P((char *, int));
257 static int chk_atstar __P((char *, int, int *, int *));
259 static char *parameter_brace_expand_word __P((char *, int, int));
260 static char *parameter_brace_expand_indir __P((char *, int, int, int *, int *));
261 static char *parameter_brace_expand_rhs __P((char *, char *, int, int, int *, int *));
262 static void parameter_brace_expand_error __P((char *, char *));
264 static int valid_length_expression __P((char *));
265 static intmax_t parameter_brace_expand_length __P((char *));
267 static char *skiparith __P((char *, int));
268 static int verify_substring_values __P((char *, char *, int, intmax_t *, intmax_t *));
269 static int get_var_and_type __P((char *, char *, int, SHELL_VAR **, char **));
270 static char *mb_substring __P((char *, int, int));
271 static char *parameter_brace_substring __P((char *, char *, char *, int));
273 static char *pos_params_pat_subst __P((char *, char *, char *, int));
275 static char *parameter_brace_patsub __P((char *, char *, char *, int));
277 static char *parameter_brace_expand __P((char *, int *, int, int *, int *));
278 static char *param_expand __P((char *, int *, int, int *, int *, int *, int *, int));
280 static WORD_LIST *expand_word_internal __P((WORD_DESC *, int, int, int *, int *));
282 static WORD_LIST *word_list_split __P((WORD_LIST *));
284 static void exp_jump_to_top_level __P((int));
286 static WORD_LIST *separate_out_assignments __P((WORD_LIST *));
287 static WORD_LIST *glob_expand_word_list __P((WORD_LIST *, int));
288 #ifdef BRACE_EXPANSION
289 static WORD_LIST *brace_expand_word_list __P((WORD_LIST *, int));
291 static WORD_LIST *shell_expand_word_list __P((WORD_LIST *, int));
292 static WORD_LIST *expand_word_list_internal __P((WORD_LIST *, int));
294 /* **************************************************************** */
296 /* Utility Functions */
298 /* **************************************************************** */
300 #ifdef INCLUDE_UNUSED
302 quoted_substring (string, start, end)
307 register char *result, *s, *r;
311 /* Move to string[start], skipping quoted characters. */
312 for (s = string, l = 0; *s && l < start; )
324 r = result = (char *)xmalloc (2*len + 1); /* save room for quotes */
326 /* Copy LEN characters, including quote characters. */
328 for (l = 0; l < len; s++)
342 #ifdef INCLUDE_UNUSED
343 /* Return the length of S, skipping over quoted characters */
367 /* Find the first occurrence of character C in string S, obeying shell
368 quoting rules. If (FLAGS & ST_BACKSL) is non-zero, backslash-escaped
369 characters are skipped. If (FLAGS & ST_CTLESC) is non-zero, characters
370 escaped with CTLESC are skipped. */
372 quoted_strchr (s, c, flags)
380 if (((flags & ST_BACKSL) && *p == '\\')
381 || ((flags & ST_CTLESC) && *p == CTLESC))
385 return ((char *)NULL);
391 return ((char *)NULL);
394 /* Return 1 if CHARACTER appears in an unquoted portion of
395 STRING. Return 0 otherwise. CHARACTER must be a single-byte character. */
397 unquoted_member (character, string)
405 slen = strlen (string);
407 while (c = string[sindex])
415 ADVANCE_CHAR (string, slen, sindex);
421 ADVANCE_CHAR (string, slen, sindex);
425 sindex = skip_single_quoted (string, slen, ++sindex);
429 sindex = skip_double_quoted (string, slen, ++sindex);
436 /* Return 1 if SUBSTR appears in an unquoted portion of STRING. */
438 unquoted_substring (substr, string)
439 char *substr, *string;
442 int sindex, c, sublen;
445 if (substr == 0 || *substr == '\0')
448 slen = strlen (string);
449 sublen = strlen (substr);
450 for (sindex = 0; c = string[sindex]; )
452 if (STREQN (string + sindex, substr, sublen))
461 ADVANCE_CHAR (string, slen, sindex);
465 sindex = skip_single_quoted (string, slen, ++sindex);
469 sindex = skip_double_quoted (string, slen, ++sindex);
473 ADVANCE_CHAR (string, slen, sindex);
480 /* Most of the substitutions must be done in parallel. In order
481 to avoid using tons of unclear goto's, I have some functions
482 for manipulating malloc'ed strings. They all take INDX, a
483 pointer to an integer which is the offset into the string
484 where manipulation is taking place. They also take SIZE, a
485 pointer to an integer which is the current length of the
486 character array for this string. */
488 /* Append SOURCE to TARGET at INDEX. SIZE is the current amount
489 of space allocated to TARGET. SOURCE can be NULL, in which
490 case nothing happens. Gets rid of SOURCE by freeing it.
491 Returns TARGET in case the location has changed. */
493 sub_append_string (source, target, indx, size)
494 char *source, *target;
501 srclen = STRLEN (source);
502 if (srclen >= (int)(*size - *indx))
505 n = (n + DEFAULT_ARRAY_SIZE) - (n % DEFAULT_ARRAY_SIZE);
506 target = (char *)xrealloc (target, (*size = n));
509 FASTCOPY (source, target + *indx, srclen);
511 target[*indx] = '\0';
520 /* Append the textual representation of NUMBER to TARGET.
521 INDX and SIZE are as in SUB_APPEND_STRING. */
523 sub_append_number (number, target, indx, size)
530 temp = itos (number);
531 return (sub_append_string (temp, target, indx, size));
535 /* Extract a substring from STRING, starting at SINDEX and ending with
536 one of the characters in CHARLIST. Don't make the ending character
537 part of the string. Leave SINDEX pointing at the ending character.
538 Understand about backslashes in the string. If (flags & EX_VARNAME)
539 is non-zero, and array variables have been compiled into the shell,
540 everything between a `[' and a corresponding `]' is skipped over.
541 If (flags & EX_NOALLOC) is non-zero, don't return the substring, just
544 string_extract (string, sindex, charlist, flags)
555 slen = strlen (string + *sindex) + *sindex;
557 while (c = string[i])
566 #if defined (ARRAY_VARS)
567 else if ((flags & EX_VARNAME) && c == '[')
570 /* If this is an array subscript, skip over it and continue. */
571 ni = skipsubscript (string, i);
572 if (string[ni] == ']')
576 else if (MEMBER (c, charlist))
579 ADVANCE_CHAR (string, slen, i);
582 temp = (flags & EX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
587 /* Extract the contents of STRING as if it is enclosed in double quotes.
588 SINDEX, when passed in, is the offset of the character immediately
589 following the opening double quote; on exit, SINDEX is left pointing after
590 the closing double quote. If STRIPDQ is non-zero, unquoted double
591 quotes are stripped and the string is terminated by a null byte.
592 Backslashes between the embedded double quotes are processed. If STRIPDQ
593 is zero, an unquoted `"' terminates the string. */
595 string_extract_double_quoted (string, sindex, stripdq)
597 int *sindex, stripdq;
603 char *temp, *ret; /* The new string we return. */
604 int pass_next, backquote, si; /* State variables for the machine. */
608 slen = strlen (string + *sindex) + *sindex;
609 send = string + slen;
611 pass_next = backquote = dquote = 0;
612 temp = (char *)xmalloc (1 + slen - *sindex);
616 while (c = string[i])
618 /* Process a character that was quoted by a backslash. */
623 ``The backslash shall retain its special meaning as an escape
624 character only when followed by one of the characters:
627 If STRIPDQ is zero, we handle the double quotes here and let
628 expand_word_internal handle the rest. If STRIPDQ is non-zero,
629 we have already been through one round of backslash stripping,
630 and want to strip these backslashes only if DQUOTE is non-zero,
631 indicating that we are inside an embedded double-quoted string. */
633 /* If we are in an embedded quoted string, then don't strip
634 backslashes before characters for which the backslash
635 retains its special meaning, but remove backslashes in
636 front of other characters. If we are not in an
637 embedded quoted string, don't strip backslashes at all.
638 This mess is necessary because the string was already
639 surrounded by double quotes (and sh has some really weird
641 The returned string will be run through expansion as if
642 it were double-quoted. */
643 if ((stripdq == 0 && c != '"') ||
644 (stripdq && ((dquote && (sh_syntaxtab[c] & CBSDQUOTE)) || dquote == 0)))
649 COPY_CHAR_I (temp, j, string, send, i);
653 /* A backslash protects the next character. The code just above
654 handles preserving the backslash in front of any character but
663 /* Inside backquotes, ``the portion of the quoted string from the
664 initial backquote and the characters up to the next backquote
665 that is not preceded by a backslash, having escape characters
666 removed, defines that command''. */
684 /* Pass everything between `$(' and the matching `)' or a quoted
685 ${ ... } pair through according to the Posix.2 specification. */
686 if (c == '$' && ((string[i + 1] == LPAREN) || (string[i + 1] == LBRACE)))
691 if (string[i + 1] == LPAREN)
692 ret = extract_delimited_string (string, &si, "$(", "(", ")", 0); /*)*/
694 ret = extract_dollar_brace_string (string, &si, 1, 0);
697 temp[j++] = string[i + 1];
699 /* Just paranoia; ret will not be 0 unless no_longjmp_on_fatal_error
701 if (ret == 0 && no_longjmp_on_fatal_error)
704 ret = string + i + 2;
707 for (t = 0; ret[t]; t++, j++)
709 temp[j] = string[si];
724 /* Add any character but a double quote to the quoted string we're
727 goto add_one_character;
741 /* Point to after the closing quote. */
749 /* This should really be another option to string_extract_double_quoted. */
751 skip_double_quoted (string, slen, sind)
758 int pass_next, backquote, si;
761 pass_next = backquote = 0;
763 while (c = string[i])
768 ADVANCE_CHAR (string, slen, i);
781 ADVANCE_CHAR (string, slen, i);
790 else if (c == '$' && ((string[i + 1] == LPAREN) || (string[i + 1] == LBRACE)))
793 if (string[i + 1] == LPAREN)
794 ret = extract_delimited_string (string, &si, "$(", "(", ")", EX_NOALLOC); /* ) */
796 ret = extract_dollar_brace_string (string, &si, 0, EX_NOALLOC);
803 ADVANCE_CHAR (string, slen, i);
816 /* Extract the contents of STRING as if it is enclosed in single quotes.
817 SINDEX, when passed in, is the offset of the character immediately
818 following the opening single quote; on exit, SINDEX is left pointing after
819 the closing single quote. */
821 string_extract_single_quoted (string, sindex)
830 slen = strlen (string + *sindex) + *sindex;
832 while (string[i] && string[i] != '\'')
833 ADVANCE_CHAR (string, slen, i);
835 t = substring (string, *sindex, i);
845 skip_single_quoted (string, slen, sind)
854 while (string[c] && string[c] != '\'')
855 ADVANCE_CHAR (string, slen, c);
862 /* Just like string_extract, but doesn't hack backslashes or any of
863 that other stuff. Obeys CTLESC quoting. Used to do splitting on $IFS. */
865 string_extract_verbatim (string, sindex, charlist)
870 register int i = *sindex;
872 #if defined (HANDLE_MULTIBYTE)
880 if (charlist[0] == '\'' && charlist[1] == '\0')
882 temp = string_extract_single_quoted (string, sindex);
883 --*sindex; /* leave *sindex at separator character */
887 slen = strlen (string + *sindex) + *sindex;
889 #if defined (HANDLE_MULTIBYTE)
890 clen = strlen (charlist);
893 while (c = string[i])
895 #if defined (HANDLE_MULTIBYTE)
904 #if defined (HANDLE_MULTIBYTE)
905 mblength = MBLEN (string + i, slen - 1);
909 mblength = mbtowc (&wc, string + i, slen - i);
910 if (MB_INVALIDCH (mblength))
912 if (MEMBER (c, charlist))
920 len = mbstowcs (wcharlist, charlist, 0);
923 wcharlist = xmalloc ((sizeof (wchar_t) * len) + 1);
924 mbstowcs (wcharlist, charlist, len);
927 if (wcschr (wcharlist, wc))
933 if (MEMBER (c, charlist))
936 ADVANCE_CHAR (string, slen, i);
939 #if defined (HANDLE_MULTIBYTE)
943 temp = substring (string, *sindex, i);
949 /* Extract the $( construct in STRING, and return a new string.
950 Start extracting at (SINDEX) as if we had just seen "$(".
951 Make (SINDEX) get the position of the matching ")". ) */
953 extract_command_subst (string, sindex)
957 return (extract_delimited_string (string, sindex, "$(", "(", ")", 0)); /*)*/
960 /* Extract the $[ construct in STRING, and return a new string. (])
961 Start extracting at (SINDEX) as if we had just seen "$[".
962 Make (SINDEX) get the position of the matching "]". */
964 extract_arithmetic_subst (string, sindex)
968 return (extract_delimited_string (string, sindex, "$[", "[", "]", 0)); /*]*/
971 #if defined (PROCESS_SUBSTITUTION)
972 /* Extract the <( or >( construct in STRING, and return a new string.
973 Start extracting at (SINDEX) as if we had just seen "<(".
974 Make (SINDEX) get the position of the matching ")". */ /*))*/
976 extract_process_subst (string, starter, sindex)
981 return (extract_delimited_string (string, sindex, starter, "(", ")", 0));
983 #endif /* PROCESS_SUBSTITUTION */
985 #if defined (ARRAY_VARS)
987 extract_array_assignment_list (string, sindex)
991 return (extract_delimited_string (string, sindex, "(", (char *)NULL, ")", 0));
995 /* Extract and create a new string from the contents of STRING, a
996 character string delimited with OPENER and CLOSER. SINDEX is
997 the address of an int describing the current offset in STRING;
998 it should point to just after the first OPENER found. On exit,
999 SINDEX gets the position of the last character of the matching CLOSER.
1000 If OPENER is more than a single character, ALT_OPENER, if non-null,
1001 contains a character string that can also match CLOSER and thus
1002 needs to be skipped. */
1004 extract_delimited_string (string, sindex, opener, alt_opener, closer, flags)
1007 char *opener, *alt_opener, *closer;
1013 int pass_character, nesting_level;
1014 int len_closer, len_opener, len_alt_opener;
1017 slen = strlen (string + *sindex) + *sindex;
1018 len_opener = STRLEN (opener);
1019 len_alt_opener = STRLEN (alt_opener);
1020 len_closer = STRLEN (closer);
1027 while (nesting_level)
1034 if (pass_character) /* previous char was backslash */
1037 ADVANCE_CHAR (string, slen, i);
1041 if (c == CTLESC || c == '\\')
1048 /* Process a nested OPENER. */
1049 if (STREQN (string + i, opener, len_opener))
1051 si = i + len_opener;
1052 t = extract_delimited_string (string, &si, opener, alt_opener, closer, flags|EX_NOALLOC);
1057 /* Process a nested ALT_OPENER */
1058 if (len_alt_opener && STREQN (string + i, alt_opener, len_alt_opener))
1060 si = i + len_alt_opener;
1061 t = extract_delimited_string (string, &si, alt_opener, alt_opener, closer, flags|EX_NOALLOC);
1066 /* If the current substring terminates the delimited string, decrement
1067 the nesting level. */
1068 if (STREQN (string + i, closer, len_closer))
1070 i += len_closer - 1; /* move to last byte of the closer */
1072 if (nesting_level == 0)
1076 /* Pass old-style command substitution through verbatim. */
1080 t = string_extract (string, &si, "`", flags|EX_NOALLOC);
1085 /* Pass single-quoted and double-quoted strings through verbatim. */
1086 if (c == '\'' || c == '"')
1089 i = (c == '\'') ? skip_single_quoted (string, slen, si)
1090 : skip_double_quoted (string, slen, si);
1094 /* move past this character, which was not special. */
1095 ADVANCE_CHAR (string, slen, i);
1098 if (c == 0 && nesting_level)
1100 if (no_longjmp_on_fatal_error == 0)
1102 report_error (_("bad substitution: no closing `%s' in %s"), closer, string);
1103 last_command_exit_value = EXECUTION_FAILURE;
1104 exp_jump_to_top_level (DISCARD);
1109 return (char *)NULL;
1113 si = i - *sindex - len_closer + 1;
1114 if (flags & EX_NOALLOC)
1115 result = (char *)NULL;
1118 result = (char *)xmalloc (1 + si);
1119 strncpy (result, string + *sindex, si);
1127 /* Extract a parameter expansion expression within ${ and } from STRING.
1128 Obey the Posix.2 rules for finding the ending `}': count braces while
1129 skipping over enclosed quoted strings and command substitutions.
1130 SINDEX is the address of an int describing the current offset in STRING;
1131 it should point to just after the first `{' found. On exit, SINDEX
1132 gets the position of the matching `}'. QUOTED is non-zero if this
1133 occurs inside double quotes. */
1134 /* XXX -- this is very similar to extract_delimited_string -- XXX */
1136 extract_dollar_brace_string (string, sindex, quoted, flags)
1138 int *sindex, quoted, flags;
1142 int pass_character, nesting_level, si;
1148 slen = strlen (string + *sindex) + *sindex;
1151 while (c = string[i])
1156 ADVANCE_CHAR (string, slen, i);
1160 /* CTLESCs and backslashes quote the next character. */
1161 if (c == CTLESC || c == '\\')
1168 if (string[i] == '$' && string[i+1] == LBRACE)
1178 if (nesting_level == 0)
1184 /* Pass the contents of old-style command substitutions through
1189 t = string_extract (string, &si, "`", flags|EX_NOALLOC);
1194 /* Pass the contents of new-style command substitutions and
1195 arithmetic substitutions through verbatim. */
1196 if (string[i] == '$' && string[i+1] == LPAREN)
1199 t = extract_delimited_string (string, &si, "$(", "(", ")", flags|EX_NOALLOC); /*)*/
1204 /* Pass the contents of single-quoted and double-quoted strings
1205 through verbatim. */
1206 if (c == '\'' || c == '"')
1209 i = (c == '\'') ? skip_single_quoted (string, slen, si)
1210 : skip_double_quoted (string, slen, si);
1211 /* skip_XXX_quoted leaves index one past close quote */
1215 /* move past this character, which was not special. */
1216 ADVANCE_CHAR (string, slen, i);
1219 if (c == 0 && nesting_level)
1221 if (no_longjmp_on_fatal_error == 0)
1223 report_error ("bad substitution: no closing `%s' in %s", "}", string);
1224 last_command_exit_value = EXECUTION_FAILURE;
1225 exp_jump_to_top_level (DISCARD);
1230 return ((char *)NULL);
1234 result = (flags & EX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
1240 /* Remove backslashes which are quoting backquotes from STRING. Modifies
1241 STRING, and returns a pointer to it. */
1243 de_backslash (string)
1246 register size_t slen;
1247 register int i, j, prev_i;
1250 slen = strlen (string);
1253 /* Loop copying string[i] to string[j], i >= j. */
1256 if (string[i] == '\\' && (string[i + 1] == '`' || string[i + 1] == '\\' ||
1257 string[i + 1] == '$'))
1260 ADVANCE_CHAR (string, slen, i);
1262 do string[j++] = string[prev_i++]; while (prev_i < i);
1273 /* Replace instances of \! in a string with !. */
1275 unquote_bang (string)
1279 register char *temp;
1281 temp = (char *)xmalloc (1 + strlen (string));
1283 for (i = 0, j = 0; (temp[j] = string[i]); i++, j++)
1285 if (string[i] == '\\' && string[i + 1] == '!')
1291 strcpy (string, temp);
1296 #if defined (READLINE)
1297 /* Return 1 if the portion of STRING ending at EINDEX is quoted (there is
1298 an unclosed quoted string), or if the character at EINDEX is quoted
1299 by a backslash. NO_LONGJMP_ON_FATAL_ERROR is used to flag that the various
1300 single and double-quoted string parsing functions should not return an
1301 error if there are unclosed quotes or braces. The characters that this
1302 recognizes need to be the same as the contents of
1303 rl_completer_quote_characters. */
1305 #define CQ_RETURN(x) do { no_longjmp_on_fatal_error = 0; return (x); } while (0)
1308 char_is_quoted (string, eindex)
1312 int i, pass_next, c;
1316 slen = strlen (string);
1317 no_longjmp_on_fatal_error = 1;
1326 if (i >= eindex) /* XXX was if (i >= eindex - 1) */
1328 ADVANCE_CHAR (string, slen, i);
1337 else if (c == '\'' || c == '"')
1339 i = (c == '\'') ? skip_single_quoted (string, slen, ++i)
1340 : skip_double_quoted (string, slen, ++i);
1343 /* no increment, the skip_xxx functions go one past end */
1346 ADVANCE_CHAR (string, slen, i);
1353 unclosed_pair (string, eindex, openstr)
1358 int i, pass_next, openc, olen;
1362 slen = strlen (string);
1363 olen = strlen (openstr);
1364 i = pass_next = openc = 0;
1370 if (i >= eindex) /* XXX was if (i >= eindex - 1) */
1372 ADVANCE_CHAR (string, slen, i);
1375 else if (string[i] == '\\')
1381 else if (STREQN (string + i, openstr, olen))
1386 else if (string[i] == '\'' || string[i] == '"')
1388 i = (string[i] == '\'') ? skip_single_quoted (string, slen, i)
1389 : skip_double_quoted (string, slen, i);
1394 ADVANCE_CHAR (string, slen, i);
1399 /* Skip characters in STRING until we find a character in DELIMS, and return
1400 the index of that character. START is the index into string at which we
1401 begin. This is similar in spirit to strpbrk, but it returns an index into
1402 STRING and takes a starting index. This little piece of code knows quite
1403 a lot of shell syntax. It's very similar to skip_double_quoted and other
1404 functions of that ilk. */
1406 skip_to_delim (string, start, delims)
1411 int i, pass_next, backq, si, c;
1416 slen = strlen (string + start) + start;
1417 no_longjmp_on_fatal_error = 1;
1419 pass_next = backq = 0;
1420 while (c = string[i])
1427 ADVANCE_CHAR (string, slen, i);
1440 ADVANCE_CHAR (string, slen, i);
1449 else if (c == '\'' || c == '"')
1451 i = (c == '\'') ? skip_single_quoted (string, slen, ++i)
1452 : skip_double_quoted (string, slen, ++i);
1453 /* no increment, the skip functions increment past the closing quote. */
1455 else if (c == '$' && (string[i+1] == LPAREN || string[i+1] == LBRACE))
1458 if (string[si] == '\0')
1461 if (string[i+1] == LPAREN)
1462 temp = extract_delimited_string (string, &si, "$(", "(", ")", EX_NOALLOC); /* ) */
1464 temp = extract_dollar_brace_string (string, &si, 0, EX_NOALLOC);
1466 if (string[i] == '\0') /* don't increment i past EOS in loop */
1471 else if (member (c, delims))
1474 ADVANCE_CHAR (string, slen, i);
1480 /* Split STRING (length SLEN) at DELIMS, and return a WORD_LIST with the
1481 individual words. If DELIMS is NULL, the current value of $IFS is used
1482 to split the string, and the function follows the shell field splitting
1483 rules. SENTINEL is an index to look for. NWP, if non-NULL,
1484 gets the number of words in the returned list. CWP, if non-NULL, gets
1485 the index of the word containing SENTINEL. Non-whitespace chars in
1486 DELIMS delimit separate fields. */
1488 split_at_delims (string, slen, delims, sentinel, nwp, cwp)
1495 int ts, te, i, nw, cw, ifs_split;
1496 char *token, *d, *d2;
1497 WORD_LIST *ret, *tl;
1499 if (string == 0 || *string == '\0')
1505 return ((WORD_LIST *)NULL);
1508 d = (delims == 0) ? ifs_value : delims;
1509 ifs_split = delims == 0;
1511 /* Make d2 the non-whitespace characters in delims */
1516 #if defined (HANDLE_MULTIBYTE)
1517 size_t mblength = 1;
1521 slength = strlen (delims);
1522 d2 = (char *)xmalloc (slength + 1);
1526 #if defined (HANDLE_MULTIBYTE)
1527 mbstate_t state_bak = state;
1528 mblength = MBRLEN (delims + i, slength, &state);
1529 if (MB_INVALIDCH (mblength))
1531 else if (mblength > 1)
1533 memcpy (d2 + ts, delims + i, mblength);
1536 slength -= mblength;
1540 if (whitespace (delims[i]) == 0)
1541 d2[ts++] = delims[i];
1549 ret = (WORD_LIST *)NULL;
1551 /* Remove sequences of whitspace characters at the start of the string, as
1552 long as those characters are delimiters. */
1553 for (i = 0; member (string[i], d) && spctabnl (string[i]); i++)
1555 if (string[i] == '\0')
1563 te = skip_to_delim (string, ts, d);
1565 /* If we have a non-whitespace delimiter character, use it to make a
1566 separate field. This is just about what $IFS splitting does and
1567 is closer to the behavior of the shell parser. */
1568 if (ts == te && d2 && member (string[ts], d2))
1571 /* If we're using IFS splitting, the non-whitespace delimiter char
1572 and any additional IFS whitespace delimits a field. */
1574 while (member (string[te], d) && spctabnl (string[te]))
1577 while (member (string[te], d2))
1581 token = substring (string, ts, te);
1583 ret = add_string_to_list (token, ret);
1587 if (sentinel >= ts && sentinel <= te)
1590 /* If the cursor is at whitespace just before word start, set the
1591 sentinel word to the current word. */
1592 if (cwp && cw == -1 && sentinel == ts-1)
1595 /* If the cursor is at whitespace between two words, make a new, empty
1596 word, add it before (well, after, since the list is in reverse order)
1597 the word we just added, and set the current word to that one. */
1598 if (cwp && cw == -1 && sentinel < ts)
1600 tl = make_word_list (make_word (""), ret->next);
1606 if (string[te] == 0)
1610 while (member (string[i], d) && (ifs_split || spctabnl(string[i])))
1619 /* Special case for SENTINEL at the end of STRING. If we haven't found
1620 the word containing SENTINEL yet, and the index we're looking for is at
1621 the end of STRING, add an additional null argument and set the current
1622 word pointer to that. */
1623 if (cwp && cw == -1 && sentinel >= slen)
1625 if (whitespace (string[sentinel - 1]))
1628 ret = add_string_to_list (token, ret);
1639 return (REVERSE_LIST (ret, WORD_LIST *));
1641 #endif /* READLINE */
1645 /* Extract the name of the variable to bind to from the assignment string. */
1647 assignment_name (string)
1653 offset = assignment (string, 0);
1655 return (char *)NULL;
1656 temp = substring (string, 0, offset);
1661 /* **************************************************************** */
1663 /* Functions to convert strings to WORD_LISTs and vice versa */
1665 /* **************************************************************** */
1667 /* Return a single string of all the words in LIST. SEP is the separator
1668 to put between individual elements of LIST in the output string. */
1670 string_list_internal (list, sep)
1674 register WORD_LIST *t;
1676 int word_len, sep_len, result_size;
1679 return ((char *)NULL);
1681 /* Short-circuit quickly if we don't need to separate anything. */
1682 if (list->next == 0)
1683 return (savestring (list->word->word));
1685 /* This is nearly always called with either sep[0] == 0 or sep[1] == 0. */
1686 sep_len = STRLEN (sep);
1689 for (t = list; t; t = t->next)
1692 result_size += sep_len;
1693 result_size += strlen (t->word->word);
1696 r = result = (char *)xmalloc (result_size + 1);
1698 for (t = list; t; t = t->next)
1700 if (t != list && sep_len)
1704 FASTCOPY (sep, r, sep_len);
1711 word_len = strlen (t->word->word);
1712 FASTCOPY (t->word->word, r, word_len);
1720 /* Return a single string of all the words present in LIST, separating
1721 each word with a space. */
1726 return (string_list_internal (list, " "));
1729 /* Return a single string of all the words present in LIST, obeying the
1730 quoting rules for "$*", to wit: (P1003.2, draft 11, 3.5.2) "If the
1731 expansion [of $*] appears within a double quoted string, it expands
1732 to a single field with the value of each parameter separated by the
1733 first character of the IFS variable, or by a <space> if IFS is unset." */
1735 string_list_dollar_star (list)
1738 #if defined (HANDLE_MULTIBYTE)
1739 char sep[MB_CUR_MAX + 1];
1745 #if defined (HANDLE_MULTIBYTE)
1746 if (ifs_firstc_len == 1)
1748 sep[0] = ifs_firstc[0];
1752 memcpy (sep, ifs_firstc, ifs_firstc_len);
1754 sep[0] = ifs_firstc;
1758 return (string_list_internal (list, sep));
1761 /* Turn $@ into a string. If (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
1762 is non-zero, the $@ appears within double quotes, and we should quote
1763 the list before converting it into a string. If IFS is unset, and the
1764 word is not quoted, we just need to quote CTLESC and CTLNUL characters
1765 in the words in the list, because the default value of $IFS is
1766 <space><tab><newline>, IFS characters in the words in the list should
1767 also be split. If IFS is null, and the word is not quoted, we need
1768 to quote the words in the list to preserve the positional parameters
1771 string_list_dollar_at (list, quoted)
1776 #if defined (HANDLE_MULTIBYTE)
1777 char sep[MB_CUR_MAX + 1];
1783 /* XXX this could just be ifs = ifs_value; */
1784 ifs = ifs_var ? value_cell (ifs_var) : (char *)0;
1786 #if defined (HANDLE_MULTIBYTE)
1790 mblength = MBLEN (ifs, strnlen (ifs, MB_CUR_MAX));
1791 if (MB_INVALIDCH (mblength) || mblength == 1)
1796 else if (mblength == 0)
1800 memcpy (sep, ifs, mblength);
1801 sep[mblength] = '\0';
1810 sep[0] = (ifs == 0 || *ifs == 0) ? ' ' : *ifs;
1814 tlist = ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (ifs && *ifs == 0))
1816 : list_quote_escapes (list);
1817 return (string_list_internal (tlist, sep));
1820 /* Return the list of words present in STRING. Separate the string into
1821 words at any of the characters found in SEPARATORS. If QUOTED is
1822 non-zero then word in the list will have its quoted flag set, otherwise
1823 the quoted flag is left as make_word () deemed fit.
1825 This obeys the P1003.2 word splitting semantics. If `separators' is
1826 exactly <space><tab><newline>, then the splitting algorithm is that of
1827 the Bourne shell, which treats any sequence of characters from `separators'
1828 as a delimiter. If IFS is unset, which results in `separators' being set
1829 to "", no splitting occurs. If separators has some other value, the
1830 following rules are applied (`IFS white space' means zero or more
1831 occurrences of <space>, <tab>, or <newline>, as long as those characters
1832 are in `separators'):
1834 1) IFS white space is ignored at the start and the end of the
1836 2) Each occurrence of a character in `separators' that is not
1837 IFS white space, along with any adjacent occurrences of
1838 IFS white space delimits a field.
1839 3) Any nonzero-length sequence of IFS white space delimits a field.
1842 /* BEWARE! list_string strips null arguments. Don't call it twice and
1843 expect to have "" preserved! */
1845 /* This performs word splitting and quoted null character removal on
1848 (((separators)[0]) ? ((separators)[1] ? isifs(c) \
1849 : (c) == (separators)[0]) \
1853 list_string (string, separators, quoted)
1854 register char *string, *separators;
1859 char *current_word, *s;
1860 int sindex, sh_style_split, whitesep;
1863 if (!string || !*string)
1864 return ((WORD_LIST *)NULL);
1866 sh_style_split = separators && separators[0] == ' ' &&
1867 separators[1] == '\t' &&
1868 separators[2] == '\n' &&
1869 separators[3] == '\0';
1872 /* Remove sequences of whitespace at the beginning of STRING, as
1873 long as those characters appear in IFS. Do not do this if
1874 STRING is quoted or if there are no separator characters. */
1875 if (!quoted || !separators || !*separators)
1877 for (s = string; *s && spctabnl (*s) && issep (*s); s++);
1880 return ((WORD_LIST *)NULL);
1885 /* OK, now STRING points to a word that does not begin with white space.
1886 The splitting algorithm is:
1887 extract a word, stopping at a separator
1888 skip sequences of spc, tab, or nl as long as they are separators
1889 This obeys the field splitting rules in Posix.2. */
1890 for (result = (WORD_LIST *)NULL, sindex = 0; string[sindex]; )
1892 current_word = string_extract_verbatim (string, &sindex, separators);
1893 if (current_word == 0)
1896 /* If we have a quoted empty string, add a quoted null argument. We
1897 want to preserve the quoted null character iff this is a quoted
1898 empty string; otherwise the quoted null characters are removed
1900 if (QUOTED_NULL (current_word))
1902 t = make_bare_word ("");
1903 t->flags |= W_QUOTED;
1905 t->word = make_quoted_char ('\0');
1906 result = make_word_list (t, result);
1908 else if (current_word[0] != '\0')
1910 /* If we have something, then add it regardless. However,
1911 perform quoted null character removal on the current word. */
1912 remove_quoted_nulls (current_word);
1913 result = add_string_to_list (current_word, result);
1914 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
1915 result->word->flags |= W_QUOTED;
1918 /* If we're not doing sequences of separators in the traditional
1919 Bourne shell style, then add a quoted null argument. */
1920 else if (!sh_style_split && !spctabnl (string[sindex]))
1922 t = make_bare_word ("");
1923 t->flags |= W_QUOTED;
1925 t->word = make_quoted_char ('\0');
1926 result = make_word_list (t, result);
1929 free (current_word);
1931 /* Note whether or not the separator is IFS whitespace, used later. */
1932 whitesep = string[sindex] && spctabnl (string[sindex]);
1934 /* Move past the current separator character. */
1939 slen = strlen (string);
1940 ADVANCE_CHAR (string, slen, sindex);
1943 /* Now skip sequences of space, tab, or newline characters if they are
1944 in the list of separators. */
1945 while (string[sindex] && spctabnl (string[sindex]) && issep (string[sindex]))
1948 /* If the first separator was IFS whitespace and the current character
1949 is a non-whitespace IFS character, it should be part of the current
1950 field delimiter, not a separate delimiter that would result in an
1951 empty field. Look at POSIX.2, 3.6.5, (3)(b). */
1952 if (string[sindex] && whitesep && issep (string[sindex]) && !spctabnl (string[sindex]))
1955 return (REVERSE_LIST (result, WORD_LIST *));
1958 /* Parse a single word from STRING, using SEPARATORS to separate fields.
1959 ENDPTR is set to the first character after the word. This is used by
1960 the `read' builtin. This is never called with SEPARATORS != $IFS;
1961 it should be simplified.
1963 XXX - this function is very similar to list_string; they should be
1966 get_word_from_string (stringp, separators, endptr)
1967 char **stringp, *separators, **endptr;
1971 int sindex, sh_style_split, whitesep;
1974 if (!stringp || !*stringp || !**stringp)
1975 return ((char *)NULL);
1979 sh_style_split = separators && separators[0] == ' ' &&
1980 separators[1] == '\t' &&
1981 separators[2] == '\n' &&
1982 separators[3] == '\0';
1986 /* Remove sequences of whitespace at the beginning of STRING, as
1987 long as those characters appear in IFS. */
1988 if (sh_style_split || !separators || !*separators)
1990 for (; *s && spctabnl (*s) && isifs (*s); s++);
1992 /* If the string is nothing but whitespace, update it and return. */
1998 return ((char *)NULL);
2002 /* OK, S points to a word that does not begin with white space.
2003 Now extract a word, stopping at a separator, save a pointer to
2004 the first character after the word, then skip sequences of spc,
2005 tab, or nl as long as they are separators.
2007 This obeys the field splitting rules in Posix.2. */
2009 current_word = string_extract_verbatim (s, &sindex, separators);
2011 /* Set ENDPTR to the first character after the end of the word. */
2013 *endptr = s + sindex;
2015 /* Note whether or not the separator is IFS whitespace, used later. */
2016 whitesep = s[sindex] && spctabnl (s[sindex]);
2018 /* Move past the current separator character. */
2024 ADVANCE_CHAR (s, slen, sindex);
2027 /* Now skip sequences of space, tab, or newline characters if they are
2028 in the list of separators. */
2029 while (s[sindex] && spctabnl (s[sindex]) && isifs (s[sindex]))
2032 /* If the first separator was IFS whitespace and the current character is
2033 a non-whitespace IFS character, it should be part of the current field
2034 delimiter, not a separate delimiter that would result in an empty field.
2035 Look at POSIX.2, 3.6.5, (3)(b). */
2036 if (s[sindex] && whitesep && isifs (s[sindex]) && !spctabnl (s[sindex]))
2039 /* Update STRING to point to the next field. */
2040 *stringp = s + sindex;
2041 return (current_word);
2044 /* Remove IFS white space at the end of STRING. Start at the end
2045 of the string and walk backwards until the beginning of the string
2046 or we find a character that's not IFS white space and not CTLESC.
2047 Only let CTLESC escape a white space character if SAW_ESCAPE is
2050 strip_trailing_ifs_whitespace (string, separators, saw_escape)
2051 char *string, *separators;
2056 s = string + STRLEN (string) - 1;
2057 while (s > string && ((spctabnl (*s) && isifs (*s)) ||
2058 (saw_escape && *s == CTLESC && spctabnl (s[1]))))
2066 /* Split STRING into words at whitespace. Obeys shell-style quoting with
2067 backslashes, single and double quotes. */
2069 list_string_with_quotes (string)
2075 int c, i, tokstart, len;
2077 for (s = string; s && *s && spctabnl (*s); s++)
2079 if (s == 0 || *s == 0)
2080 return ((WORD_LIST *)NULL);
2084 list = (WORD_LIST *)NULL;
2095 i = skip_single_quoted (s, s_len, ++i);
2097 i = skip_double_quoted (s, s_len, ++i);
2098 else if (c == 0 || spctabnl (c))
2100 /* We have found the end of a token. Make a word out of it and
2101 add it to the word list. */
2102 token = substring (s, tokstart, i);
2103 list = add_string_to_list (token, list);
2105 while (spctabnl (s[i]))
2113 i++; /* normal character */
2115 return (REVERSE_LIST (list, WORD_LIST *));
2119 /********************************************************/
2121 /* Functions to perform assignment statements */
2123 /********************************************************/
2125 /* Given STRING, an assignment string, get the value of the right side
2126 of the `=', and bind it to the left side. If EXPAND is true, then
2127 perform parameter expansion, command substitution, and arithmetic
2128 expansion on the right-hand side. Perform tilde expansion in any
2129 case. Do not perform word splitting on the result of expansion. */
2131 do_assignment_internal (string, expand)
2138 #if defined (ARRAY_VARS)
2142 int assign_list = 0;
2144 offset = assignment (string, 0);
2145 name = savestring (string);
2146 value = (char *)NULL;
2148 if (name[offset] == '=')
2153 temp = name + offset + 1;
2155 #if defined (ARRAY_VARS)
2156 if (expand && temp[0] == LPAREN && xstrchr (temp, RPAREN))
2158 assign_list = ni = 1;
2159 value = extract_delimited_string (temp, &ni, "(", (char *)NULL, ")", 0);
2164 /* Perform tilde expansion. */
2165 if (expand && temp[0])
2168 temp = (xstrchr (temp, '~') && unquoted_member ('~', temp))
2169 ? bash_tilde_expand (temp, 2)
2170 : savestring (temp);
2173 value = expand_string_if_necessary (temp, 0, expand_string_assignment);
2179 value = savestring (temp);
2184 value = (char *)xmalloc (1);
2188 if (echo_command_at_execute)
2189 xtrace_print_assignment (name, value, assign_list, 1);
2191 #define ASSIGN_RETURN(r) do { FREE (value); free (name); return (r); } while (0)
2193 #if defined (ARRAY_VARS)
2194 if (t = xstrchr (name, '[')) /*]*/
2198 report_error (_("%s: cannot assign list to array member"), name);
2201 entry = assign_array_element (name, value);
2205 else if (assign_list)
2206 entry = assign_array_from_string (name, value);
2208 #endif /* ARRAY_VARS */
2209 entry = bind_variable (name, value);
2211 stupidly_hack_special_variables (name);
2214 VUNSETATTR (entry, att_invisible);
2216 /* Return 1 if the assignment seems to have been performed correctly. */
2217 ASSIGN_RETURN (entry ? ((readonly_p (entry) == 0) && noassign_p (entry) == 0) : 0);
2220 /* Perform the assignment statement in STRING, and expand the
2221 right side by doing command and parameter expansion. */
2223 do_assignment (string)
2226 return do_assignment_internal (string, 1);
2229 /* Given STRING, an assignment string, get the value of the right side
2230 of the `=', and bind it to the left side. Do not do command and
2231 parameter substitution on the right hand side. */
2233 do_assignment_no_expand (string)
2236 return do_assignment_internal (string, 0);
2239 /***************************************************
2241 * Functions to manage the positional parameters *
2243 ***************************************************/
2245 /* Return the word list that corresponds to `$*'. */
2247 list_rest_of_args ()
2249 register WORD_LIST *list, *args;
2252 /* Break out of the loop as soon as one of the dollar variables is null. */
2253 for (i = 1, list = (WORD_LIST *)NULL; i < 10 && dollar_vars[i]; i++)
2254 list = make_word_list (make_bare_word (dollar_vars[i]), list);
2256 for (args = rest_of_args; args; args = args->next)
2257 list = make_word_list (make_bare_word (args->word->word), list);
2259 return (REVERSE_LIST (list, WORD_LIST *));
2265 register WORD_LIST *list;
2268 for (n = 0; n < 9 && dollar_vars[n+1]; n++)
2270 for (list = rest_of_args; list; list = list->next)
2275 /* Return the value of a positional parameter. This handles values > 10. */
2277 get_dollar_var_value (ind)
2284 temp = dollar_vars[ind] ? savestring (dollar_vars[ind]) : (char *)NULL;
2285 else /* We want something like ${11} */
2288 for (p = rest_of_args; p && ind--; p = p->next)
2290 temp = p ? savestring (p->word->word) : (char *)NULL;
2295 /* Make a single large string out of the dollar digit variables,
2296 and the rest_of_args. If DOLLAR_STAR is 1, then obey the special
2297 case of "$*" with respect to IFS. */
2299 string_rest_of_args (dollar_star)
2302 register WORD_LIST *list;
2305 list = list_rest_of_args ();
2306 string = dollar_star ? string_list_dollar_star (list) : string_list (list);
2307 dispose_words (list);
2311 /* Return a string containing the positional parameters from START to
2312 END, inclusive. If STRING[0] == '*', we obey the rules for $*,
2313 which only makes a difference if QUOTED is non-zero. If QUOTED includes
2314 Q_HERE_DOCUMENT or Q_DOUBLE_QUOTES, this returns a quoted list, otherwise
2315 no quoting chars are added. */
2317 pos_params (string, start, end, quoted)
2319 int start, end, quoted;
2321 WORD_LIST *save, *params, *h, *t;
2325 /* see if we can short-circuit. if start == end, we want 0 parameters. */
2327 return ((char *)NULL);
2329 save = params = list_rest_of_args ();
2331 return ((char *)NULL);
2333 for (i = 1; params && i < start; i++)
2334 params = params->next;
2336 return ((char *)NULL);
2337 for (h = t = params; params && i < end; i++)
2340 params = params->next;
2343 t->next = (WORD_LIST *)NULL;
2344 if (string[0] == '*')
2346 ret = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? string_list_dollar_star (quote_list (h)) : string_list (h);
2349 if (quoted & Q_DOUBLE_QUOTES)
2350 ret = string_list_dollar_star (quote_list (h));
2351 else if (quoted & Q_HERE_DOCUMENT)
2352 ret = string_list (quote_list (h));
2354 ret = string_list (h);
2358 ret = string_list ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? quote_list (h) : h);
2362 dispose_words (save);
2366 /******************************************************************/
2368 /* Functions to expand strings to strings or WORD_LISTs */
2370 /******************************************************************/
2372 #if defined (PROCESS_SUBSTITUTION)
2373 #define EXP_CHAR(s) (s == '$' || s == '`' || s == '<' || s == '>' || s == CTLESC || s == '~')
2375 #define EXP_CHAR(s) (s == '$' || s == '`' || s == CTLESC || s == '~')
2378 /* If there are any characters in STRING that require full expansion,
2379 then call FUNC to expand STRING; otherwise just perform quote
2380 removal if necessary. This returns a new string. */
2382 expand_string_if_necessary (string, quoted, func)
2393 slen = strlen (string);
2397 if (EXP_CHAR (string[i]))
2399 else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
2401 ADVANCE_CHAR (string, slen, i);
2406 list = (*func) (string, quoted);
2409 ret = string_list (list);
2410 dispose_words (list);
2415 else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
2416 ret = string_quote_removal (string, quoted);
2418 ret = savestring (string);
2423 static inline char *
2424 expand_string_to_string_internal (string, quoted, func)
2432 if (string == 0 || *string == '\0')
2433 return ((char *)NULL);
2435 list = (*func) (string, quoted);
2438 ret = string_list (list);
2439 dispose_words (list);
2448 expand_string_to_string (string, quoted)
2452 return (expand_string_to_string_internal (string, quoted, expand_string));
2456 expand_string_unsplit_to_string (string, quoted)
2460 return (expand_string_to_string_internal (string, quoted, expand_string_unsplit));
2463 #if defined (COND_COMMAND)
2464 /* Just remove backslashes in STRING. Returns a new string. */
2466 remove_backslashes (string)
2471 r = ret = (char *)xmalloc (strlen (string) + 1);
2472 for (s = string; s && *s; )
2484 /* This needs better error handling. */
2485 /* Expand W for use as an argument to a unary or binary operator in a
2486 [[...]] expression. If SPECIAL is nonzero, this is the rhs argument
2487 to the != or == operator, and should be treated as a pattern. In
2488 this case, we quote the string specially for the globbing code. The
2489 caller is responsible for removing the backslashes if the unquoted
2490 words is needed later. */
2492 cond_expand_word (w, special)
2499 if (w->word == 0 || w->word[0] == '\0')
2500 return ((char *)NULL);
2503 if (xstrchr (w->word, '~') && unquoted_member ('~', w->word))
2505 p = bash_tilde_expand (w->word, 0);
2511 l = call_expand_word_internal (w, 0, 0, (int *)0, (int *)0);
2517 r = string_list (l);
2521 p = string_list (l);
2522 r = quote_string_for_globbing (p, QGLOB_CVTNULL);
2534 /* Call expand_word_internal to expand W and handle error returns.
2535 A convenience function for functions that don't want to handle
2536 any errors or free any memory before aborting. */
2538 call_expand_word_internal (w, q, i, c, e)
2544 result = expand_word_internal (w, q, i, c, e);
2545 if (result == &expand_word_error || result == &expand_word_fatal)
2547 /* By convention, each time this error is returned, w->word has
2548 already been freed (it sometimes may not be in the fatal case,
2549 but that doesn't result in a memory leak because we're going
2550 to exit in most cases). */
2551 w->word = (char *)NULL;
2552 last_command_exit_value = EXECUTION_FAILURE;
2553 exp_jump_to_top_level ((result == &expand_word_error) ? DISCARD : FORCE_EOF);
2560 /* Perform parameter expansion, command substitution, and arithmetic
2561 expansion on STRING, as if it were a word. Leave the result quoted. */
2563 expand_string_internal (string, quoted)
2570 if (string == 0 || *string == 0)
2571 return ((WORD_LIST *)NULL);
2574 td.word = savestring (string);
2576 tresult = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
2582 /* Expand STRING by performing parameter expansion, command substitution,
2583 and arithmetic expansion. Dequote the resulting WORD_LIST before
2584 returning it, but do not perform word splitting. The call to
2585 remove_quoted_nulls () is in here because word splitting normally
2586 takes care of quote removal. */
2588 expand_string_unsplit (string, quoted)
2594 if (string == 0 || *string == '\0')
2595 return ((WORD_LIST *)NULL);
2597 expand_no_split_dollar_star = 1;
2598 value = expand_string_internal (string, quoted);
2599 expand_no_split_dollar_star = 0;
2604 remove_quoted_nulls (value->word->word);
2605 dequote_list (value);
2610 /* Expand the rhs of an assignment statement */
2612 expand_string_assignment (string, quoted)
2619 if (string == 0 || *string == '\0')
2620 return ((WORD_LIST *)NULL);
2622 expand_no_split_dollar_star = 1;
2624 td.flags = W_ASSIGNRHS;
2625 td.word = savestring (string);
2626 value = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
2629 expand_no_split_dollar_star = 0;
2634 remove_quoted_nulls (value->word->word);
2635 dequote_list (value);
2641 /* Expand one of the PS? prompt strings. This is a sort of combination of
2642 expand_string_unsplit and expand_string_internal, but returns the
2643 passed string when an error occurs. Might want to trap other calls
2644 to jump_to_top_level here so we don't endlessly loop. */
2646 expand_prompt_string (string, quoted)
2653 if (string == 0 || *string == 0)
2654 return ((WORD_LIST *)NULL);
2657 td.word = savestring (string);
2659 no_longjmp_on_fatal_error = 1;
2660 value = expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
2661 no_longjmp_on_fatal_error = 0;
2663 if (value == &expand_word_error || value == &expand_word_fatal)
2665 value = make_word_list (make_bare_word (string), (WORD_LIST *)NULL);
2672 remove_quoted_nulls (value->word->word);
2673 dequote_list (value);
2678 /* Expand STRING just as if you were expanding a word, but do not dequote
2679 the resultant WORD_LIST. This is called only from within this file,
2680 and is used to correctly preserve quoted characters when expanding
2681 things like ${1+"$@"}. This does parameter expansion, command
2682 substitution, arithmetic expansion, and word splitting. */
2684 expand_string_leave_quoted (string, quoted)
2691 if (string == 0 || *string == '\0')
2692 return ((WORD_LIST *)NULL);
2694 tlist = expand_string_internal (string, quoted);
2698 tresult = word_list_split (tlist);
2699 dispose_words (tlist);
2702 return ((WORD_LIST *)NULL);
2705 /* This does not perform word splitting or dequote the WORD_LIST
2708 expand_string_for_rhs (string, quoted, dollar_at_p, has_dollar_at)
2710 int quoted, *dollar_at_p, *has_dollar_at;
2715 if (string == 0 || *string == '\0')
2716 return (WORD_LIST *)NULL;
2720 tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, has_dollar_at);
2724 /* Expand STRING just as if you were expanding a word. This also returns
2725 a list of words. Note that filename globbing is *NOT* done for word
2726 or string expansion, just when the shell is expanding a command. This
2727 does parameter expansion, command substitution, arithmetic expansion,
2728 and word splitting. Dequote the resultant WORD_LIST before returning. */
2730 expand_string (string, quoted)
2736 if (string == 0 || *string == '\0')
2737 return ((WORD_LIST *)NULL);
2739 result = expand_string_leave_quoted (string, quoted);
2740 return (result ? dequote_list (result) : result);
2743 /***************************************************
2745 * Functions to handle quoting chars *
2747 ***************************************************/
2751 A string with s[0] == CTLNUL && s[1] == 0 is a quoted null string.
2752 The parser passes CTLNUL as CTLESC CTLNUL. */
2754 /* Quote escape characters in string s, but no other characters. This is
2755 used to protect CTLESC and CTLNUL in variable values from the rest of
2756 the word expansion process after the variable is expanded. */
2758 quote_escapes (string)
2761 register char *s, *t;
2763 char *result, *send;
2766 slen = strlen (string);
2767 send = string + slen;
2769 t = result = (char *)xmalloc ((slen * 2) + 1);
2774 if (*s == CTLESC || *s == CTLNUL)
2776 COPY_CHAR_P (t, s, send);
2783 list_quote_escapes (list)
2786 register WORD_LIST *w;
2789 for (w = list; w; w = w->next)
2792 w->word->word = quote_escapes (t);
2798 /* Inverse of quote_escapes; remove CTLESC protecting CTLESC or CTLNUL.
2800 The parser passes us CTLESC as CTLESC CTLESC and CTLNUL as CTLESC CTLNUL.
2801 This is necessary to make unquoted CTLESC and CTLNUL characters in the
2802 data stream pass through properly.
2804 We need to remove doubled CTLESC characters inside quoted strings before
2805 quoting the entire string, so we do not double the number of CTLESC
2808 Also used by parts of the pattern substitution code. */
2810 dequote_escapes (string)
2813 register char *s, *t;
2815 char *result, *send;
2821 slen = strlen (string);
2822 send = string + slen;
2824 t = result = (char *)xmalloc (slen + 1);
2827 if (strchr (string, CTLESC) == 0)
2828 return (strcpy (result, s));
2832 if (*s == CTLESC && (s[1] == CTLESC || s[1] == CTLNUL))
2838 COPY_CHAR_P (t, s, send);
2844 /* Return a new string with the quoted representation of character C. */
2846 make_quoted_char (c)
2851 temp = (char *)xmalloc (3);
2866 /* Quote STRING. Return a new string. */
2868 quote_string (string)
2873 char *result, *send;
2877 result = (char *)xmalloc (2);
2885 slen = strlen (string);
2886 send = string + slen;
2888 result = (char *)xmalloc ((slen * 2) + 1);
2890 for (t = result; string < send; )
2893 COPY_CHAR_P (t, string, send);
2900 /* De-quoted quoted characters in STRING. */
2902 dequote_string (string)
2905 register char *s, *t;
2907 char *result, *send;
2910 slen = strlen (string);
2912 t = result = (char *)xmalloc (slen + 1);
2914 if (QUOTED_NULL (string))
2920 /* If no character in the string can be quoted, don't bother examining
2921 each character. Just return a copy of the string passed to us. */
2922 if (strchr (string, CTLESC) == NULL)
2923 return (strcpy (result, string));
2925 send = string + slen;
2935 COPY_CHAR_P (t, s, send);
2942 /* Quote the entire WORD_LIST list. */
2947 register WORD_LIST *w;
2950 for (w = list; w; w = w->next)
2953 w->word->word = quote_string (t);
2955 w->word->flags |= W_QUOTED;
2965 register WORD_LIST *tlist;
2967 for (tlist = list; tlist; tlist = tlist->next)
2969 s = dequote_string (tlist->word->word);
2970 free (tlist->word->word);
2971 tlist->word->word = s;
2976 /* Remove CTLESC protecting a CTLESC or CTLNUL in place. Return the passed
2979 remove_quoted_escapes (string)
2986 t = dequote_escapes (string);
2994 /* Perform quoted null character removal on STRING. We don't allow any
2995 quoted null characters in the middle or at the ends of strings because
2996 of how expand_word_internal works. remove_quoted_nulls () turns
2997 STRING into an empty string iff it only consists of a quoted null,
2998 and removes all unquoted CTLNUL characters. */
3000 remove_quoted_nulls (string)
3003 register size_t slen;
3004 register int i, j, prev_i;
3007 if (strchr (string, CTLNUL) == 0) /* XXX */
3008 return string; /* XXX */
3010 slen = strlen (string);
3015 if (string[i] == CTLESC)
3017 /* Old code had j++, but we cannot assume that i == j at this
3018 point -- what if a CTLNUL has already been removed from the
3019 string? We don't want to drop the CTLESC or recopy characters
3020 that we've already copied down. */
3021 i++; string[j++] = CTLESC;
3025 else if (string[i] == CTLNUL)
3029 ADVANCE_CHAR (string, slen, i);
3032 do string[j++] = string[prev_i++]; while (prev_i < i);
3042 /* Perform quoted null character removal on each element of LIST.
3043 This modifies LIST. */
3045 word_list_remove_quoted_nulls (list)
3048 register WORD_LIST *t;
3050 for (t = list; t; t = t->next)
3051 remove_quoted_nulls (t->word->word);
3054 /* **************************************************************** */
3056 /* Functions for Matching and Removing Patterns */
3058 /* **************************************************************** */
3060 #if defined (HANDLE_MULTIBYTE)
3061 #if 0 /* Currently unused */
3062 static unsigned char *
3063 mb_getcharlens (string, len)
3067 int i, offset, last;
3074 ret = (unsigned char *)xmalloc (len);
3075 memset (ret, 0, len);
3076 while (string[last])
3078 ADVANCE_CHAR (string, len, offset);
3079 ret[last] = offset - last;
3087 /* Remove the portion of PARAM matched by PATTERN according to OP, where OP
3088 can have one of 4 values:
3089 RP_LONG_LEFT remove longest matching portion at start of PARAM
3090 RP_SHORT_LEFT remove shortest matching portion at start of PARAM
3091 RP_LONG_RIGHT remove longest matching portion at end of PARAM
3092 RP_SHORT_RIGHT remove shortest matching portion at end of PARAM
3095 #define RP_LONG_LEFT 1
3096 #define RP_SHORT_LEFT 2
3097 #define RP_LONG_RIGHT 3
3098 #define RP_SHORT_RIGHT 4
3101 remove_upattern (param, pattern, op)
3102 char *param, *pattern;
3107 register char *p, *ret, c;
3109 len = STRLEN (param);
3114 case RP_LONG_LEFT: /* remove longest match at start */
3115 for (p = end; p >= param; p--)
3118 if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3121 return (savestring (p));
3128 case RP_SHORT_LEFT: /* remove shortest match at start */
3129 for (p = param; p <= end; p++)
3132 if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3135 return (savestring (p));
3141 case RP_LONG_RIGHT: /* remove longest match at end */
3142 for (p = param; p <= end; p++)
3144 if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3147 ret = savestring (param);
3154 case RP_SHORT_RIGHT: /* remove shortest match at end */
3155 for (p = end; p >= param; p--)
3157 if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3160 ret = savestring (param);
3168 return (savestring (param)); /* no match, return original string */
3171 #if defined (HANDLE_MULTIBYTE)
3173 #if !defined (HAVE_WCSDUP)
3182 ret = xmalloc ((len + 1) * sizeof (wchar_t));
3185 return (wcscpy (ret, ws));
3187 #endif /* !HAVE_WCSDUP */
3190 remove_wpattern (wparam, wstrlen, wpattern, op)
3202 case RP_LONG_LEFT: /* remove longest match at start */
3203 for (n = wstrlen; n >= 0; n--)
3205 wc = wparam[n]; wparam[n] = L'\0';
3206 if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3209 return (wcsdup (wparam + n));
3215 case RP_SHORT_LEFT: /* remove shortest match at start */
3216 for (n = 0; n <= wstrlen; n++)
3218 wc = wparam[n]; wparam[n] = L'\0';
3219 if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3222 return (wcsdup (wparam + n));
3228 case RP_LONG_RIGHT: /* remove longest match at end */
3229 for (n = 0; n <= wstrlen; n++)
3231 if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3233 wc = wparam[n]; wparam[n] = L'\0';
3234 ret = wcsdup (wparam);
3241 case RP_SHORT_RIGHT: /* remove shortest match at end */
3242 for (n = wstrlen; n >= 0; n--)
3244 if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3246 wc = wparam[n]; wparam[n] = L'\0';
3247 ret = wcsdup (wparam);
3255 return (wcsdup (wparam)); /* no match, return original string */
3257 #endif /* HANDLE_MULTIBYTE */
3260 remove_pattern (param, pattern, op)
3261 char *param, *pattern;
3266 if (*param == '\0' || pattern == NULL || *pattern == '\0') /* minor optimization */
3267 return (savestring (param));
3269 #if defined (HANDLE_MULTIBYTE)
3272 wchar_t *ret, *oret;
3274 wchar_t *wparam, *wpattern;
3278 n = xdupmbstowcs (&wpattern, NULL, pattern);
3279 if (n == (size_t)-1)
3280 return (remove_upattern (param, pattern, op));
3281 n = xdupmbstowcs (&wparam, NULL, param);
3282 if (n == (size_t)-1)
3285 return (remove_upattern (param, pattern, op));
3287 oret = ret = remove_wpattern (wparam, n, wpattern, op);
3293 xret = xmalloc (n + 1);
3294 memset (&ps, '\0', sizeof (mbstate_t));
3295 n = wcsrtombs (xret, (const wchar_t **)&ret, n, &ps);
3296 xret[n] = '\0'; /* just to make sure */
3302 return (remove_upattern (param, pattern, op));
3305 /* Return 1 of the first character of STRING could match the first
3306 character of pattern PAT. Used to avoid n2 calls to strmatch(). */
3308 match_pattern_char (pat, string)
3319 return (*string == c);
3321 return (*string == *pat);
3323 return (*pat == LPAREN ? 1 : (*string != '\0'));
3329 return (*pat == LPAREN ? 1 : (*string == c));
3331 return (*string != '\0');
3335 /* Match PAT anywhere in STRING and return the match boundaries.
3336 This returns 1 in case of a successful match, 0 otherwise. SP
3337 and EP are pointers into the string where the match begins and
3338 ends, respectively. MTYPE controls what kind of match is attempted.
3339 MATCH_BEG and MATCH_END anchor the match at the beginning and end
3340 of the string, respectively. The longest match is returned. */
3342 match_upattern (string, pat, mtype, sp, ep)
3348 register char *p, *p1;
3351 len = STRLEN (string);
3357 for (p = string; p <= end; p++)
3359 if (match_pattern_char (pat, p))
3361 for (p1 = end; p1 >= p; p1--)
3363 c = *p1; *p1 = '\0';
3364 if (strmatch (pat, p, FNMATCH_EXTFLAG) == 0)
3379 if (match_pattern_char (pat, string) == 0)
3382 for (p = end; p >= string; p--)
3385 if (strmatch (pat, string, FNMATCH_EXTFLAG) == 0)
3398 for (p = string; p <= end; p++)
3400 if (strmatch (pat, p, FNMATCH_EXTFLAG) == 0)
3415 #if defined (HANDLE_MULTIBYTE)
3416 /* Return 1 of the first character of WSTRING could match the first
3417 character of pattern WPAT. Wide character version. */
3419 match_pattern_wchar (wpat, wstring)
3420 wchar_t *wpat, *wstring;
3427 switch (wc = *wpat++)
3430 return (*wstring == wc);
3432 return (*wstring == *wpat);
3434 return (*wpat == LPAREN ? 1 : (*wstring != L'\0'));
3440 return (*wpat == LPAREN ? 1 : (*wstring == wc));
3442 return (*wstring != L'\0');
3446 /* Match WPAT anywhere in WSTRING and return the match boundaries.
3447 This returns 1 in case of a successful match, 0 otherwise. Wide
3448 character version. */
3450 match_wpattern (wstring, indices, wstrlen, wpat, mtype, sp, ep)
3461 size_t n, n1; /* Apple's gcc seems to miscompile this badly */
3469 for (n = 0; n <= wstrlen; n++)
3471 if (match_pattern_wchar (wpat, wstring + n))
3473 for (n1 = wstrlen; n1 >= n; n1--)
3475 wc = wstring[n1]; wstring[n1] = L'\0';
3476 if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG) == 0)
3491 if (match_pattern_wchar (wpat, wstring) == 0)
3494 for (n = wstrlen; n >= 0; n--)
3496 wc = wstring[n]; wstring[n] = L'\0';
3497 if (wcsmatch (wpat, wstring, FNMATCH_EXTFLAG) == 0)
3510 for (n = 0; n <= wstrlen; n++)
3512 if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG) == 0)
3515 *ep = indices[wstrlen];
3525 #endif /* HANDLE_MULTIBYTE */
3528 match_pattern (string, pat, mtype, sp, ep)
3533 #if defined (HANDLE_MULTIBYTE)
3536 wchar_t *wstring, *wpat;
3540 if (string == 0 || *string == 0 || pat == 0 || *pat == 0)
3543 #if defined (HANDLE_MULTIBYTE)
3546 n = xdupmbstowcs (&wpat, NULL, pat);
3547 if (n == (size_t)-1)
3548 return (match_upattern (string, pat, mtype, sp, ep));
3549 n = xdupmbstowcs (&wstring, &indices, string);
3550 if (n == (size_t)-1)
3553 return (match_upattern (string, pat, mtype, sp, ep));
3555 ret = match_wpattern (wstring, indices, n, wpat, mtype, sp, ep);
3565 return (match_upattern (string, pat, mtype, sp, ep));
3569 getpatspec (c, value)
3574 return ((*value == '#') ? RP_LONG_LEFT : RP_SHORT_LEFT);
3576 return ((*value == '%') ? RP_LONG_RIGHT : RP_SHORT_RIGHT);
3579 /* Posix.2 says that the WORD should be run through tilde expansion,
3580 parameter expansion, command substitution and arithmetic expansion.
3581 This leaves the result quoted, so quote_string_for_globbing () has
3582 to be called to fix it up for strmatch (). If QUOTED is non-zero,
3583 it means that the entire expression was enclosed in double quotes.
3584 This means that quoting characters in the pattern do not make any
3585 special pattern characters quoted. For example, the `*' in the
3586 following retains its special meaning: "${foo#'*'}". */
3588 getpattern (value, quoted, expandpat)
3590 int quoted, expandpat;
3597 tword = xstrchr (value, '~') ? bash_tilde_expand (value, 0) : savestring (value);
3599 tword = savestring (value);
3601 /* There is a problem here: how to handle single or double quotes in the
3602 pattern string when the whole expression is between double quotes?
3603 POSIX.2 says that enclosing double quotes do not cause the pattern to
3604 be quoted, but does that leave us a problem with @ and array[@] and their
3605 expansions inside a pattern? */
3607 if (expandpat && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *tword)
3610 pat = string_extract_double_quoted (tword, &i, 1);
3616 /* expand_string_for_rhs () leaves WORD quoted and does not perform
3618 l = *tword ? expand_string_for_rhs (tword,
3619 (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? Q_PATQUOTE : quoted,
3620 (int *)NULL, (int *)NULL)
3623 pat = string_list (l);
3627 tword = quote_string_for_globbing (pat, QGLOB_CVTNULL);
3635 /* Handle removing a pattern from a string as a result of ${name%[%]value}
3636 or ${name#[#]value}. */
3638 variable_remove_pattern (value, pattern, patspec, quoted)
3639 char *value, *pattern;
3640 int patspec, quoted;
3644 tword = remove_pattern (value, pattern, patspec);
3651 list_remove_pattern (list, pattern, patspec, itype, quoted)
3654 int patspec, itype, quoted;
3660 for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)
3662 tword = remove_pattern (l->word->word, pattern, patspec);
3663 w = make_bare_word (tword);
3665 new = make_word_list (w, new);
3668 l = REVERSE_LIST (new, WORD_LIST *);
3671 tword = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? string_list_dollar_star (l) : string_list (l);
3673 tword = (quoted & Q_DOUBLE_QUOTES) ? string_list_dollar_star (l) : string_list (l);
3676 tword = string_list ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? quote_list (l) : l);
3683 parameter_list_remove_pattern (itype, pattern, patspec, quoted)
3686 int patspec, quoted;
3691 list = list_rest_of_args ();
3693 return ((char *)NULL);
3694 ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
3695 dispose_words (list);
3699 #if defined (ARRAY_VARS)
3701 array_remove_pattern (a, pattern, patspec, varname, quoted)
3705 char *varname; /* so we can figure out how it's indexed */
3713 /* compute itype from varname here */
3714 v = array_variable_part (varname, &ret, 0);
3717 list = array_to_word_list (a);
3719 return ((char *)NULL);
3720 ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
3721 dispose_words (list);
3725 #endif /* ARRAY_VARS */
3728 parameter_brace_remove_pattern (varname, value, patstr, rtype, quoted)
3729 char *varname, *value, *patstr;
3732 int vtype, patspec, starsub;
3733 char *temp1, *val, *pattern;
3737 return ((char *)NULL);
3739 this_command_name = varname;
3741 vtype = get_var_and_type (varname, value, quoted, &v, &val);
3743 return ((char *)NULL);
3745 starsub = vtype & VT_STARSUB;
3746 vtype &= ~VT_STARSUB;
3748 patspec = getpatspec (rtype, patstr);
3749 if (patspec == RP_LONG_LEFT || patspec == RP_LONG_RIGHT)
3752 pattern = getpattern (patstr, quoted, 1);
3754 temp1 = (char *)NULL; /* shut up gcc */
3758 case VT_ARRAYMEMBER:
3759 temp1 = remove_pattern (val, pattern, patspec);
3760 if (vtype == VT_VARIABLE)
3764 val = quote_escapes (temp1);
3769 #if defined (ARRAY_VARS)
3771 temp1 = array_remove_pattern (array_cell (v), pattern, patspec, varname, quoted);
3772 if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
3774 val = quote_escapes (temp1);
3781 temp1 = parameter_list_remove_pattern (varname[0], pattern, patspec, quoted);
3782 if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
3784 val = quote_escapes (temp1);
3795 /*******************************************
3797 * Functions to expand WORD_DESCs *
3799 *******************************************/
3801 /* Expand WORD, performing word splitting on the result. This does
3802 parameter expansion, command substitution, arithmetic expansion,
3803 word splitting, and quote removal. */
3806 expand_word (word, quoted)
3810 WORD_LIST *result, *tresult;
3812 tresult = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
3813 result = word_list_split (tresult);
3814 dispose_words (tresult);
3815 return (result ? dequote_list (result) : result);
3818 /* Expand WORD, but do not perform word splitting on the result. This
3819 does parameter expansion, command substitution, arithmetic expansion,
3820 and quote removal. */
3822 expand_word_unsplit (word, quoted)
3828 expand_no_split_dollar_star = 1;
3829 result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
3830 expand_no_split_dollar_star = 0;
3832 return (result ? dequote_list (result) : result);
3835 /* Perform shell expansions on WORD, but do not perform word splitting or
3836 quote removal on the result. */
3838 expand_word_leave_quoted (word, quoted)
3842 return (call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL));
3845 #if defined (PROCESS_SUBSTITUTION)
3847 /*****************************************************************/
3849 /* Hacking Process Substitution */
3851 /*****************************************************************/
3853 #if !defined (HAVE_DEV_FD)
3854 /* Named pipes must be removed explicitly with `unlink'. This keeps a list
3855 of FIFOs the shell has open. unlink_fifo_list will walk the list and
3856 unlink all of them. add_fifo_list adds the name of an open FIFO to the
3857 list. NFIFO is a count of the number of FIFOs in the list. */
3858 #define FIFO_INCR 20
3865 static struct temp_fifo *fifo_list = (struct temp_fifo *)NULL;
3867 static int fifo_list_size;
3870 add_fifo_list (pathname)
3873 if (nfifo >= fifo_list_size - 1)
3875 fifo_list_size += FIFO_INCR;
3876 fifo_list = (struct temp_fifo *)xrealloc (fifo_list,
3877 fifo_list_size * sizeof (struct temp_fifo));
3880 fifo_list[nfifo].file = savestring (pathname);
3892 for (i = saved = 0; i < nfifo; i++)
3894 if ((fifo_list[i].proc == -1) || (kill(fifo_list[i].proc, 0) == -1))
3896 unlink (fifo_list[i].file);
3897 free (fifo_list[i].file);
3898 fifo_list[i].file = (char *)NULL;
3899 fifo_list[i].proc = -1;
3905 /* If we didn't remove some of the FIFOs, compact the list. */
3908 for (i = j = 0; i < nfifo; i++)
3909 if (fifo_list[i].file)
3911 fifo_list[j].file = fifo_list[i].file;
3912 fifo_list[j].proc = fifo_list[i].proc;
3926 tname = sh_mktmpname ("sh-np", MT_USERANDOM);
3927 if (mkfifo (tname, 0600) < 0)
3930 return ((char *)NULL);
3933 add_fifo_list (tname);
3937 #else /* HAVE_DEV_FD */
3939 /* DEV_FD_LIST is a bitmap of file descriptors attached to pipes the shell
3940 has open to children. NFDS is a count of the number of bits currently
3941 set in DEV_FD_LIST. TOTFDS is a count of the highest possible number
3943 static char *dev_fd_list = (char *)NULL;
3945 static int totfds; /* The highest possible number of open files. */
3951 if (!dev_fd_list || fd >= totfds)
3956 totfds = getdtablesize ();
3957 if (totfds < 0 || totfds > 256)
3962 dev_fd_list = (char *)xrealloc (dev_fd_list, totfds);
3963 memset (dev_fd_list + ofds, '\0', totfds - ofds);
3966 dev_fd_list[fd] = 1;
3978 for (i = 0; nfds && i < totfds; i++)
3989 #if defined (NOTDEF)
3990 print_dev_fd_list ()
3994 fprintf (stderr, "pid %ld: dev_fd_list:", (long)getpid ());
3997 for (i = 0; i < totfds; i++)
4000 fprintf (stderr, " %d", i);
4002 fprintf (stderr, "\n");
4007 make_dev_fd_filename (fd)
4010 char *ret, intbuf[INT_STRLEN_BOUND (int) + 1], *p;
4012 ret = (char *)xmalloc (sizeof (DEV_FD_PREFIX) + 4);
4014 strcpy (ret, DEV_FD_PREFIX);
4015 p = inttostr (fd, intbuf, sizeof (intbuf));
4016 strcpy (ret + sizeof (DEV_FD_PREFIX) - 1, p);
4022 #endif /* HAVE_DEV_FD */
4024 /* Return a filename that will open a connection to the process defined by
4025 executing STRING. HAVE_DEV_FD, if defined, means open a pipe and return
4026 a filename in /dev/fd corresponding to a descriptor that is one of the
4027 ends of the pipe. If not defined, we use named pipes on systems that have
4028 them. Systems without /dev/fd and named pipes are out of luck.
4030 OPEN_FOR_READ_IN_CHILD, if 1, means open the named pipe for reading or
4031 use the read end of the pipe and dup that file descriptor to fd 0 in
4032 the child. If OPEN_FOR_READ_IN_CHILD is 0, we open the named pipe for
4033 writing or use the write end of the pipe in the child, and dup that
4034 file descriptor to fd 1 in the child. The parent does the opposite. */
4037 process_substitute (string, open_for_read_in_child)
4039 int open_for_read_in_child;
4044 #if defined (HAVE_DEV_FD)
4045 int parent_pipe_fd, child_pipe_fd;
4047 #endif /* HAVE_DEV_FD */
4048 #if defined (JOB_CONTROL)
4049 pid_t old_pipeline_pgrp;
4052 if (!string || !*string || wordexp_only)
4053 return ((char *)NULL);
4055 #if !defined (HAVE_DEV_FD)
4056 pathname = make_named_pipe ();
4057 #else /* HAVE_DEV_FD */
4058 if (pipe (fildes) < 0)
4060 sys_error (_("cannot make pipe for process substitution"));
4061 return ((char *)NULL);
4063 /* If OPEN_FOR_READ_IN_CHILD == 1, we want to use the write end of
4064 the pipe in the parent, otherwise the read end. */
4065 parent_pipe_fd = fildes[open_for_read_in_child];
4066 child_pipe_fd = fildes[1 - open_for_read_in_child];
4067 /* Move the parent end of the pipe to some high file descriptor, to
4068 avoid clashes with FDs used by the script. */
4069 parent_pipe_fd = move_to_high_fd (parent_pipe_fd, 1, 64);
4071 pathname = make_dev_fd_filename (parent_pipe_fd);
4072 #endif /* HAVE_DEV_FD */
4076 sys_error (_("cannot make pipe for process substitution"));
4077 return ((char *)NULL);
4080 old_pid = last_made_pid;
4082 #if defined (JOB_CONTROL)
4083 old_pipeline_pgrp = pipeline_pgrp;
4084 pipeline_pgrp = shell_pgrp;
4086 #endif /* JOB_CONTROL */
4088 pid = make_child ((char *)NULL, 1);
4091 reset_terminating_signals (); /* XXX */
4092 free_pushed_string_input ();
4093 /* Cancel traps, in trap.c. */
4094 restore_original_signals ();
4095 setup_async_signals ();
4096 subshell_environment |= SUBSHELL_COMSUB;
4099 #if defined (JOB_CONTROL)
4100 set_sigchld_handler ();
4101 stop_making_children ();
4102 pipeline_pgrp = old_pipeline_pgrp;
4103 #endif /* JOB_CONTROL */
4107 sys_error (_("cannot make child for process substitution"));
4109 #if defined (HAVE_DEV_FD)
4110 close (parent_pipe_fd);
4111 close (child_pipe_fd);
4112 #endif /* HAVE_DEV_FD */
4113 return ((char *)NULL);
4118 #if defined (JOB_CONTROL)
4119 restore_pipeline (1);
4122 #if !defined (HAVE_DEV_FD)
4123 fifo_list[nfifo-1].proc = pid;
4126 last_made_pid = old_pid;
4128 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
4130 #endif /* JOB_CONTROL && PGRP_PIPE */
4132 #if defined (HAVE_DEV_FD)
4133 close (child_pipe_fd);
4134 #endif /* HAVE_DEV_FD */
4139 set_sigint_handler ();
4141 #if defined (JOB_CONTROL)
4142 set_job_control (0);
4143 #endif /* JOB_CONTROL */
4145 #if !defined (HAVE_DEV_FD)
4146 /* Open the named pipe in the child. */
4147 fd = open (pathname, open_for_read_in_child ? O_RDONLY|O_NONBLOCK : O_WRONLY);
4150 /* Two separate strings for ease of translation. */
4151 if (open_for_read_in_child)
4152 sys_error (_("cannot open named pipe %s for reading"), pathname);
4154 sys_error (_("cannot open named pipe %s for writing"), pathname);
4158 if (open_for_read_in_child)
4160 if (sh_unset_nodelay_mode (fd) < 0)
4162 sys_error (_("cannout reset nodelay mode for fd %d"), fd);
4166 #else /* HAVE_DEV_FD */
4168 #endif /* HAVE_DEV_FD */
4170 if (dup2 (fd, open_for_read_in_child ? 0 : 1) < 0)
4172 sys_error (_("cannot duplicate named pipe %s as fd %d"), pathname,
4173 open_for_read_in_child ? 0 : 1);
4177 if (fd != (open_for_read_in_child ? 0 : 1))
4180 /* Need to close any files that this process has open to pipes inherited
4182 if (current_fds_to_close)
4184 close_fd_bitmap (current_fds_to_close);
4185 current_fds_to_close = (struct fd_bitmap *)NULL;
4188 #if defined (HAVE_DEV_FD)
4189 /* Make sure we close the parent's end of the pipe and clear the slot
4190 in the fd list so it is not closed later, if reallocated by, for
4191 instance, pipe(2). */
4192 close (parent_pipe_fd);
4193 dev_fd_list[parent_pipe_fd] = 0;
4194 #endif /* HAVE_DEV_FD */
4196 result = parse_and_execute (string, "process substitution", (SEVAL_NONINT|SEVAL_NOHIST));
4198 #if !defined (HAVE_DEV_FD)
4199 /* Make sure we close the named pipe in the child before we exit. */
4200 close (open_for_read_in_child ? 0 : 1);
4201 #endif /* !HAVE_DEV_FD */
4206 #endif /* PROCESS_SUBSTITUTION */
4208 /***********************************/
4210 /* Command Substitution */
4212 /***********************************/
4215 read_comsub (fd, quoted)
4218 char *istring, buf[128], *bufp;
4219 int istring_index, istring_size, c;
4222 istring = (char *)NULL;
4223 istring_index = istring_size = bufn = 0;
4226 setmode (fd, O_TEXT); /* we don't want CR/LF, we want Unix-style */
4229 /* Read the output of the command through the pipe. */
4236 bufn = zread (fd, buf, sizeof (buf));
4246 internal_warning ("read_comsub: ignored null byte in input");
4251 /* Add the character to ISTRING, possibly after resizing it. */
4252 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size, DEFAULT_ARRAY_SIZE);
4254 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || c == CTLESC || c == CTLNUL)
4255 istring[istring_index++] = CTLESC;
4257 istring[istring_index++] = c;
4260 #if defined (__CYGWIN__)
4261 if (c == '\n' && istring_index > 1 && istring[istring_index - 2] == '\r')
4264 istring[istring_index - 1] = '\n';
4271 istring[istring_index] = '\0';
4273 /* If we read no output, just return now and save ourselves some
4275 if (istring_index == 0)
4278 return (char *)NULL;
4281 /* Strip trailing newlines from the output of the command. */
4282 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
4284 while (istring_index > 0)
4286 if (istring[istring_index - 1] == '\n')
4290 /* If the newline was quoted, remove the quoting char. */
4291 if (istring[istring_index - 1] == CTLESC)
4297 istring[istring_index] = '\0';
4300 strip_trailing (istring, istring_index - 1, 1);
4305 /* Perform command substitution on STRING. This returns a string,
4308 command_substitute (string, quoted)
4312 pid_t pid, old_pid, old_pipeline_pgrp;
4314 int result, fildes[2], function_value, pflags, rc;
4316 istring = (char *)NULL;
4318 /* Don't fork () if there is no need to. In the case of no command to
4319 run, just return NULL. */
4320 if (!string || !*string || (string[0] == '\n' && !string[1]))
4321 return ((char *)NULL);
4323 if (wordexp_only && read_but_dont_execute)
4325 last_command_exit_value = 125;
4326 jump_to_top_level (EXITPROG);
4329 /* We're making the assumption here that the command substitution will
4330 eventually run a command from the file system. Since we'll run
4331 maybe_make_export_env in this subshell before executing that command,
4332 the parent shell and any other shells it starts will have to remake
4333 the environment. If we make it before we fork, other shells won't
4334 have to. Don't bother if we have any temporary variable assignments,
4335 though, because the export environment will be remade after this
4336 command completes anyway, but do it if all the words to be expanded
4337 are variable assignments. */
4338 if (subst_assign_varlist == 0 || garglist == 0)
4339 maybe_make_export_env (); /* XXX */
4341 /* Flags to pass to parse_and_execute() */
4342 pflags = interactive ? SEVAL_RESETLINE : 0;
4344 /* Pipe the output of executing STRING into the current shell. */
4345 if (pipe (fildes) < 0)
4347 sys_error (_("cannot make pipe for command substitution"));
4351 old_pid = last_made_pid;
4352 #if defined (JOB_CONTROL)
4353 old_pipeline_pgrp = pipeline_pgrp;
4354 /* Don't reset the pipeline pgrp if we're already a subshell in a pipeline. */
4355 if ((subshell_environment & SUBSHELL_PIPE) == 0)
4356 pipeline_pgrp = shell_pgrp;
4357 cleanup_the_pipeline ();
4360 pid = make_child ((char *)NULL, 0);
4362 /* Reset the signal handlers in the child, but don't free the
4364 reset_signal_handlers ();
4366 #if defined (JOB_CONTROL)
4367 set_sigchld_handler ();
4368 stop_making_children ();
4369 pipeline_pgrp = old_pipeline_pgrp;
4371 stop_making_children ();
4372 #endif /* JOB_CONTROL */
4376 sys_error (_("cannot make child for command substitution"));
4382 return ((char *)NULL);
4387 set_sigint_handler (); /* XXX */
4389 free_pushed_string_input ();
4391 if (dup2 (fildes[1], 1) < 0)
4393 sys_error (_("command_substitute: cannot duplicate pipe as fd 1"));
4394 exit (EXECUTION_FAILURE);
4397 /* If standard output is closed in the parent shell
4398 (such as after `exec >&-'), file descriptor 1 will be
4399 the lowest available file descriptor, and end up in
4400 fildes[0]. This can happen for stdin and stderr as well,
4401 but stdout is more important -- it will cause no output
4402 to be generated from this command. */
4403 if ((fildes[1] != fileno (stdin)) &&
4404 (fildes[1] != fileno (stdout)) &&
4405 (fildes[1] != fileno (stderr)))
4408 if ((fildes[0] != fileno (stdin)) &&
4409 (fildes[0] != fileno (stdout)) &&
4410 (fildes[0] != fileno (stderr)))
4413 /* The currently executing shell is not interactive. */
4416 /* This is a subshell environment. */
4417 subshell_environment |= SUBSHELL_COMSUB;
4419 /* When not in POSIX mode, command substitution does not inherit
4421 if (posixly_correct == 0)
4422 exit_immediately_on_error = 0;
4424 remove_quoted_escapes (string);
4426 startup_state = 2; /* see if we can avoid a fork */
4427 /* Give command substitution a place to jump back to on failure,
4428 so we don't go back up to main (). */
4429 result = setjmp (top_level);
4431 /* If we're running a command substitution inside a shell function,
4432 trap `return' so we don't return from the function in the subshell
4433 and go off to never-never land. */
4434 if (result == 0 && return_catch_flag)
4435 function_value = setjmp (return_catch);
4439 if (result == ERREXIT)
4440 rc = last_command_exit_value;
4441 else if (result == EXITPROG)
4442 rc = last_command_exit_value;
4444 rc = EXECUTION_FAILURE;
4445 else if (function_value)
4446 rc = return_catch_value;
4450 rc = parse_and_execute (string, "command substitution", pflags|SEVAL_NOHIST);
4454 last_command_exit_value = rc;
4455 rc = run_exit_trap ();
4460 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
4462 #endif /* JOB_CONTROL && PGRP_PIPE */
4466 istring = read_comsub (fildes[0], quoted);
4470 current_command_subst_pid = pid;
4471 last_command_exit_value = wait_for (pid);
4472 last_command_subst_pid = pid;
4473 last_made_pid = old_pid;
4475 #if defined (JOB_CONTROL)
4476 /* If last_command_exit_value > 128, then the substituted command
4477 was terminated by a signal. If that signal was SIGINT, then send
4478 SIGINT to ourselves. This will break out of loops, for instance. */
4479 if (last_command_exit_value == (128 + SIGINT) && last_command_exit_signal == SIGINT)
4480 kill (getpid (), SIGINT);
4482 /* wait_for gives the terminal back to shell_pgrp. If some other
4483 process group should have it, give it away to that group here.
4484 pipeline_pgrp is non-zero only while we are constructing a
4485 pipline, so what we are concerned about is whether or not that
4486 pipeline was started in the background. A pipeline started in
4487 the background should never get the tty back here. */
4489 if (interactive && pipeline_pgrp != (pid_t)0 && pipeline_pgrp != last_asynchronous_pid)
4491 if (interactive && pipeline_pgrp != (pid_t)0 && (subshell_environment & SUBSHELL_ASYNC) == 0)
4493 give_terminal_to (pipeline_pgrp, 0);
4494 #endif /* JOB_CONTROL */
4500 /********************************************************
4502 * Utility functions for parameter expansion *
4504 ********************************************************/
4506 #if defined (ARRAY_VARS)
4509 array_length_reference (s)
4518 var = array_variable_part (s, &t, &len);
4520 /* If unbound variables should generate an error, report one and return
4522 if ((var == 0 || array_p (var) == 0) && unbound_vars_is_error)
4533 /* We support a couple of expansions for variables that are not arrays.
4534 We'll return the length of the value for v[0], and 1 for v[@] or
4535 v[*]. Return 0 for everything else. */
4537 array = array_p (var) ? array_cell (var) : (ARRAY *)NULL;
4539 if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
4540 return (array_p (var) ? array_num_elements (array) : 1);
4542 ind = array_expand_index (t, len);
4545 err_badarraysub (t);
4550 t = array_reference (array, ind);
4552 t = (ind == 0) ? value_cell (var) : (char *)NULL;
4557 #endif /* ARRAY_VARS */
4560 valid_brace_expansion_word (name, var_is_special)
4564 if (DIGIT (*name) && all_digits (name))
4566 else if (var_is_special)
4568 #if defined (ARRAY_VARS)
4569 else if (valid_array_reference (name))
4571 #endif /* ARRAY_VARS */
4572 else if (legal_identifier (name))
4579 chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at)
4582 int *quoted_dollar_atp, *contains_dollar_at;
4588 if (quoted_dollar_atp)
4589 *quoted_dollar_atp = 0;
4590 if (contains_dollar_at)
4591 *contains_dollar_at = 0;
4595 /* check for $@ and $* */
4596 if (name[0] == '@' && name[1] == 0)
4598 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
4599 *quoted_dollar_atp = 1;
4600 if (contains_dollar_at)
4601 *contains_dollar_at = 1;
4604 else if (name[0] == '*' && name[1] == '\0' && quoted == 0)
4606 if (contains_dollar_at)
4607 *contains_dollar_at = 1;
4611 /* Now check for ${array[@]} and ${array[*]} */
4612 #if defined (ARRAY_VARS)
4613 else if (valid_array_reference (name))
4615 temp1 = xstrchr (name, '[');
4616 if (temp1 && temp1[1] == '@' && temp1[2] == ']')
4618 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
4619 *quoted_dollar_atp = 1;
4620 if (contains_dollar_at)
4621 *contains_dollar_at = 1;
4624 /* ${array[*]}, when unquoted, should be treated like ${array[@]},
4625 which should result in separate words even when IFS is unset. */
4626 if (temp1 && temp1[1] == '*' && temp1[2] == ']' && quoted == 0)
4628 if (contains_dollar_at)
4629 *contains_dollar_at = 1;
4637 /* Parameter expand NAME, and return a new string which is the expansion,
4638 or NULL if there was no expansion.
4639 VAR_IS_SPECIAL is non-zero if NAME is one of the special variables in
4640 the shell, e.g., "@", "$", "*", etc. QUOTED, if non-zero, means that
4641 NAME was found inside of a double-quoted expression. */
4643 parameter_brace_expand_word (name, var_is_special, quoted)
4645 int var_is_special, quoted;
4652 /* Handle multiple digit arguments, as in ${11}. */
4654 if (legal_number (name, &arg_index))
4656 tt = get_dollar_var_value (arg_index);
4658 temp = (*tt && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
4660 : quote_escapes (tt);
4662 temp = (char *)NULL;
4665 else if (var_is_special) /* ${@} */
4668 tt = (char *)xmalloc (2 + strlen (name));
4669 tt[sindex = 0] = '$';
4670 strcpy (tt + 1, name);
4672 temp = param_expand (tt, &sindex, quoted, (int *)NULL, (int *)NULL,
4673 (int *)NULL, (int *)NULL, 0);
4676 #if defined (ARRAY_VARS)
4677 else if (valid_array_reference (name))
4679 temp = array_value (name, quoted, &atype);
4680 if (atype == 0 && temp)
4681 temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
4682 ? quote_string (temp)
4683 : quote_escapes (temp);
4686 else if (var = find_variable (name))
4688 if (var_isset (var) && invisible_p (var) == 0)
4690 #if defined (ARRAY_VARS)
4691 temp = array_p (var) ? array_reference (array_cell (var), 0) : value_cell (var);
4693 temp = value_cell (var);
4697 temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
4698 ? quote_string (temp)
4699 : quote_escapes (temp);
4702 temp = (char *)NULL;
4705 temp = (char *)NULL;
4710 /* Expand an indirect reference to a variable: ${!NAME} expands to the
4711 value of the variable whose name is the value of NAME. */
4713 parameter_brace_expand_indir (name, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at)
4715 int var_is_special, quoted;
4716 int *quoted_dollar_atp, *contains_dollar_at;
4720 t = parameter_brace_expand_word (name, var_is_special, quoted);
4721 /* Have to dequote here if necessary */
4724 temp = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
4725 ? dequote_string (t)
4726 : dequote_escapes (t);
4730 chk_atstar (t, quoted, quoted_dollar_atp, contains_dollar_at);
4733 temp = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted);
4738 /* Expand the right side of a parameter expansion of the form ${NAMEcVALUE},
4739 depending on the value of C, the separating character. C can be one of
4740 "-", "+", or "=". QUOTED is true if the entire brace expression occurs
4741 between double quotes. */
4743 parameter_brace_expand_rhs (name, value, c, quoted, qdollaratp, hasdollarat)
4745 int c, quoted, *qdollaratp, *hasdollarat;
4748 char *t, *t1, *temp;
4752 /* XXX - Should we tilde expand in an assignment context if C is `='? */
4754 temp = bash_tilde_expand (value, 0);
4755 else if (xstrchr (value, '~') && unquoted_substring ("=~", value))
4756 temp = bash_tilde_expand (value, 1);
4759 temp = savestring (value);
4761 /* If the entire expression is between double quotes, we want to treat
4762 the value as a double-quoted string, with the exception that we strip
4763 embedded unescaped double quotes. */
4764 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *temp)
4767 t = string_extract_double_quoted (temp, &hasdol, 1);
4773 /* XXX was 0 not quoted */
4774 l = *temp ? expand_string_for_rhs (temp, quoted, &hasdol, (int *)NULL)
4777 *hasdollarat = hasdol || (l && l->next);
4781 /* The expansion of TEMP returned something. We need to treat things
4782 slightly differently if HASDOL is non-zero. If we have "$@", the
4783 individual words have already been quoted. We need to turn them
4784 into a string with the words separated by the first character of
4785 $IFS without any additional quoting, so string_list_dollar_at won't
4786 do the right thing. We use string_list_dollar_star instead. */
4787 temp = (hasdol || l->next) ? string_list_dollar_star (l) : string_list (l);
4789 /* If l->next is not null, we know that TEMP contained "$@", since that
4790 is the only expansion that creates more than one word. */
4791 if (qdollaratp && ((hasdol && quoted) || l->next))
4795 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && hasdol)
4797 /* The brace expansion occurred between double quotes and there was
4798 a $@ in TEMP. It does not matter if the $@ is quoted, as long as
4799 it does not expand to anything. In this case, we want to return
4800 a quoted empty string. */
4801 temp = (char *)xmalloc (2);
4806 temp = (char *)NULL;
4808 if (c == '-' || c == '+')
4812 t = temp ? savestring (temp) : savestring ("");
4813 t1 = dequote_string (t);
4815 #if defined (ARRAY_VARS)
4816 if (valid_array_reference (name))
4817 assign_array_element (name, t1);
4819 #endif /* ARRAY_VARS */
4820 bind_variable (name, t1);
4825 /* Deal with the right hand side of a ${name:?value} expansion in the case
4826 that NAME is null or not set. If VALUE is non-null it is expanded and
4827 used as the error message to print, otherwise a standard message is
4830 parameter_brace_expand_error (name, value)
4836 if (value && *value)
4840 temp = bash_tilde_expand (value, 0);
4841 else if (xstrchr (value, '~') && unquoted_substring ("=~", value))
4842 temp = bash_tilde_expand (value, 1);
4845 temp = savestring (value);
4847 l = expand_string (temp, 0);
4849 temp = string_list (l);
4850 report_error ("%s: %s", name, temp ? temp : ""); /* XXX was value not "" */
4855 report_error (_("%s: parameter null or not set"), name);
4857 /* Free the data we have allocated during this expansion, since we
4858 are about to longjmp out. */
4863 /* Return 1 if NAME is something for which parameter_brace_expand_length is
4866 valid_length_expression (name)
4869 return (name[1] == '\0' || /* ${#} */
4870 ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0') || /* special param */
4871 (DIGIT (name[1]) && all_digits (name + 1)) || /* ${#11} */
4872 #if defined (ARRAY_VARS)
4873 valid_array_reference (name + 1) || /* ${#a[7]} */
4875 legal_identifier (name + 1)); /* ${#PS1} */
4878 #if defined (HANDLE_MULTIBYTE)
4887 memset (&mbs, 0, sizeof (mbs));
4888 while ((clen = mbrlen(s, MB_CUR_MAX, &mbs)) != 0 && (MB_INVALIDCH(clen) == 0))
4898 /* Handle the parameter brace expansion that requires us to return the
4899 length of a parameter. */
4901 parameter_brace_expand_length (name)
4905 intmax_t number, arg_index;
4907 #if defined (ARRAY_VARS)
4911 if (name[1] == '\0') /* ${#} */
4912 number = number_of_args ();
4913 else if ((name[1] == '@' || name[1] == '*') && name[2] == '\0') /* ${#@}, ${#*} */
4914 number = number_of_args ();
4915 else if ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0')
4917 /* Take the lengths of some of the shell's special parameters. */
4921 t = which_set_flags ();
4924 t = itos (last_command_exit_value);
4927 t = itos (dollar_dollar_pid);
4930 if (last_asynchronous_pid == NO_PID)
4933 t = itos (last_asynchronous_pid);
4936 t = itos (number_of_args ());
4939 number = STRLEN (t);
4942 #if defined (ARRAY_VARS)
4943 else if (valid_array_reference (name + 1))
4944 number = array_length_reference (name + 1);
4945 #endif /* ARRAY_VARS */
4950 if (legal_number (name + 1, &arg_index)) /* ${#1} */
4952 t = get_dollar_var_value (arg_index);
4953 number = MB_STRLEN (t);
4956 #if defined (ARRAY_VARS)
4957 else if ((var = find_variable (name + 1)) && (invisible_p (var) == 0) && array_p (var))
4959 t = array_reference (array_cell (var), 0);
4960 number = MB_STRLEN (t);
4965 newname = savestring (name);
4967 list = expand_string (newname, Q_DOUBLE_QUOTES);
4968 t = list ? string_list (list) : (char *)NULL;
4971 dispose_words (list);
4973 number = MB_STRLEN (t);
4981 /* Skip characters in SUBSTR until DELIM. SUBSTR is an arithmetic expression,
4982 so we do some ad-hoc parsing of an arithmetic expression to find
4983 the first DELIM, instead of using strchr(3). Two rules:
4984 1. If the substring contains a `(', read until closing `)'.
4985 2. If the substring contains a `?', read past one `:' for each `?'.
4989 skiparith (substr, delim)
4994 int skipcol, pcount, i;
4997 sublen = strlen (substr);
4998 i = skipcol = pcount = 0;
5001 /* Balance parens */
5002 if (substr[i] == LPAREN)
5008 if (substr[i] == RPAREN && pcount)
5016 ADVANCE_CHAR (substr, sublen, i);
5020 /* Skip one `:' for each `?' */
5021 if (substr[i] == ':' && skipcol)
5027 if (substr[i] == delim)
5029 if (substr[i] == '?')
5035 ADVANCE_CHAR (substr, sublen, i);
5038 return (substr + i);
5041 /* Verify and limit the start and end of the desired substring. If
5042 VTYPE == 0, a regular shell variable is being used; if it is 1,
5043 then the positional parameters are being used; if it is 2, then
5044 VALUE is really a pointer to an array variable that should be used.
5045 Return value is 1 if both values were OK, 0 if there was a problem
5046 with an invalid expression, or -1 if the values were out of range. */
5048 verify_substring_values (value, substr, vtype, e1p, e2p)
5049 char *value, *substr;
5051 intmax_t *e1p, *e2p;
5053 char *t, *temp1, *temp2;
5056 #if defined (ARRAY_VARS)
5060 /* duplicate behavior of strchr(3) */
5061 t = skiparith (substr, ':');
5062 if (*t && *t == ':')
5067 temp1 = expand_string_if_necessary (substr, Q_DOUBLE_QUOTES, expand_string);
5068 *e1p = evalexp (temp1, &expok);
5073 len = -1; /* paranoia */
5077 case VT_ARRAYMEMBER:
5078 len = MB_STRLEN (value);
5081 len = number_of_args () + 1;
5083 #if defined (ARRAY_VARS)
5086 /* For arrays, the first value deals with array indices. Negative
5087 offsets count from one past the array's maximum index. */
5088 len = array_max_index (a) + (*e1p < 0); /* arrays index from 0 to n - 1 */
5093 if (len == -1) /* paranoia */
5096 if (*e1p < 0) /* negative offsets count from end */
5099 if (*e1p > len || *e1p < 0)
5102 #if defined (ARRAY_VARS)
5103 /* For arrays, the second offset deals with the number of elements. */
5104 if (vtype == VT_ARRAYVAR)
5105 len = array_num_elements (a);
5111 temp2 = savestring (t);
5112 temp1 = expand_string_if_necessary (temp2, Q_DOUBLE_QUOTES, expand_string);
5115 *e2p = evalexp (temp1, &expok);
5121 internal_error (_("%s: substring expression < 0"), t);
5124 #if defined (ARRAY_VARS)
5125 /* In order to deal with sparse arrays, push the intelligence about how
5126 to deal with the number of elements desired down to the array-
5127 specific functions. */
5128 if (vtype != VT_ARRAYVAR)
5131 *e2p += *e1p; /* want E2 chars starting at E1 */
5142 /* Return the type of variable specified by VARNAME (simple variable,
5143 positional param, or array variable). Also return the value specified
5144 by VARNAME (value of a variable or a reference to an array element).
5145 If this returns VT_VARIABLE, the caller assumes that CTLESC and CTLNUL
5146 characters in the value are quoted with CTLESC and takes appropriate
5147 steps. For convenience, *VALP is set to the dequoted VALUE. */
5149 get_var_and_type (varname, value, quoted, varp, valp)
5150 char *varname, *value;
5157 #if defined (ARRAY_VARS)
5161 /* This sets vtype to VT_VARIABLE or VT_POSPARMS */
5162 vtype = (varname[0] == '@' || varname[0] == '*') && varname[1] == '\0';
5163 if (vtype == VT_POSPARMS && varname[0] == '*')
5164 vtype |= VT_STARSUB;
5165 *varp = (SHELL_VAR *)NULL;
5167 #if defined (ARRAY_VARS)
5168 if (valid_array_reference (varname))
5170 v = array_variable_part (varname, &temp, (int *)0);
5171 if (v && array_p (v))
5173 if (ALL_ELEMENT_SUB (temp[0]) && temp[1] == ']')
5175 vtype = VT_ARRAYVAR;
5177 vtype |= VT_STARSUB;
5178 *valp = (char *)array_cell (v);
5182 vtype = VT_ARRAYMEMBER;
5183 *valp = array_value (varname, 1, (int *)NULL);
5190 else if ((v = find_variable (varname)) && (invisible_p (v) == 0) && array_p (v))
5192 vtype = VT_ARRAYMEMBER;
5194 *valp = array_reference (array_cell (v), 0);
5200 if (value && vtype == VT_VARIABLE)
5202 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
5203 *valp = dequote_string (value);
5205 *valp = dequote_escapes (value);
5211 *valp = (value && vtype == VT_VARIABLE) ? dequote_escapes (value) : value;
5217 /******************************************************/
5219 /* Functions to extract substrings of variable values */
5221 /******************************************************/
5223 #if defined (HANDLE_MULTIBYTE)
5224 /* Character-oriented rather than strictly byte-oriented substrings. S and
5225 E, rather being strict indices into STRING, indicate character (possibly
5226 multibyte character) positions that require calculation.
5227 Used by the ${param:offset[:length]} expansion. */
5229 mb_substring (string, s, e)
5234 int start, stop, i, slen;
5238 slen = STRLEN (string);
5241 while (string[start] && i--)
5242 ADVANCE_CHAR (string, slen, start);
5245 while (string[stop] && i--)
5246 ADVANCE_CHAR (string, slen, stop);
5247 tt = substring (string, start, stop);
5252 /* Process a variable substring expansion: ${name:e1[:e2]}. If VARNAME
5253 is `@', use the positional parameters; otherwise, use the value of
5254 VARNAME. If VARNAME is an array variable, use the array elements. */
5257 parameter_brace_substring (varname, value, substr, quoted)
5258 char *varname, *value, *substr;
5262 int vtype, r, starsub;
5263 char *temp, *val, *tt;
5267 return ((char *)NULL);
5269 this_command_name = varname;
5271 vtype = get_var_and_type (varname, value, quoted, &v, &val);
5273 return ((char *)NULL);
5275 starsub = vtype & VT_STARSUB;
5276 vtype &= ~VT_STARSUB;
5278 r = verify_substring_values (val, substr, vtype, &e1, &e2);
5280 return ((r == 0) ? &expand_param_error : (char *)NULL);
5285 case VT_ARRAYMEMBER:
5286 #if defined (HANDLE_MULTIBYTE)
5288 tt = mb_substring (val, e1, e2);
5291 tt = substring (val, e1, e2);
5293 if (vtype == VT_VARIABLE)
5295 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
5296 temp = quote_string (tt);
5298 temp = tt ? quote_escapes (tt) : (char *)NULL;
5302 tt = pos_params (varname, e1, e2, quoted);
5303 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
5305 temp = tt ? quote_escapes (tt) : (char *)NULL;
5311 #if defined (ARRAY_VARS)
5313 /* We want E2 to be the number of elements desired (arrays can be sparse,
5314 so verify_substring_values just returns the numbers specified and we
5315 rely on array_subrange to understand how to deal with them). */
5316 tt = array_subrange (array_cell (v), e1, e2, starsub, quoted);
5317 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
5319 temp = tt ? quote_escapes (tt) : (char *)NULL;
5327 temp = (char *)NULL;
5333 /****************************************************************/
5335 /* Functions to perform pattern substitution on variable values */
5337 /****************************************************************/
5340 pat_subst (string, pat, rep, mflags)
5341 char *string, *pat, *rep;
5344 char *ret, *s, *e, *str;
5345 int rsize, rptr, l, replen, mtype;
5347 mtype = mflags & MATCH_TYPEMASK;
5350 * 1. A null pattern with mtype == MATCH_BEG means to prefix STRING
5351 * with REP and return the result.
5352 * 2. A null pattern with mtype == MATCH_END means to append REP to
5353 * STRING and return the result.
5355 if ((pat == 0 || *pat == 0) && (mtype == MATCH_BEG || mtype == MATCH_END))
5357 replen = STRLEN (rep);
5358 l = strlen (string);
5359 ret = (char *)xmalloc (replen + l + 2);
5361 strcpy (ret, string);
5362 else if (mtype == MATCH_BEG)
5365 strcpy (ret + replen, string);
5369 strcpy (ret, string);
5370 strcpy (ret + l, rep);
5375 ret = (char *)xmalloc (rsize = 64);
5378 for (replen = STRLEN (rep), rptr = 0, str = string;;)
5380 if (match_pattern (str, pat, mtype, &s, &e) == 0)
5383 RESIZE_MALLOCED_BUFFER (ret, rptr, (l + replen), rsize, 64);
5385 /* OK, now copy the leading unmatched portion of the string (from
5386 str to s) to ret starting at rptr (the current offset). Then copy
5387 the replacement string at ret + rptr + (s - str). Increment
5388 rptr (if necessary) and str and go on. */
5391 strncpy (ret + rptr, str, l);
5396 strncpy (ret + rptr, rep, replen);
5399 str = e; /* e == end of match */
5401 if (((mflags & MATCH_GLOBREP) == 0) || mtype != MATCH_ANY)
5405 e++, str++; /* avoid infinite recursion on zero-length match */
5408 /* Now copy the unmatched portion of the input string */
5411 RESIZE_MALLOCED_BUFFER (ret, rptr, STRLEN(str) + 1, rsize, 64);
5412 strcpy (ret + rptr, str);
5420 /* Do pattern match and replacement on the positional parameters. */
5422 pos_params_pat_subst (string, pat, rep, mflags)
5423 char *string, *pat, *rep;
5426 WORD_LIST *save, *params;
5430 save = params = list_rest_of_args ();
5432 return ((char *)NULL);
5434 for ( ; params; params = params->next)
5436 ret = pat_subst (params->word->word, pat, rep, mflags);
5437 w = make_bare_word (ret);
5438 dispose_word (params->word);
5443 if ((mflags & (MATCH_QUOTED|MATCH_STARSUB)) == (MATCH_QUOTED|MATCH_STARSUB))
5444 ret = string_list_dollar_star (quote_list (save));
5446 ret = string_list ((mflags & MATCH_QUOTED) ? quote_list (save) : save);
5447 dispose_words (save);
5452 /* Perform pattern substitution on VALUE, which is the expansion of
5453 VARNAME. PATSUB is an expression supplying the pattern to match
5454 and the string to substitute. QUOTED is a flags word containing
5455 the type of quoting currently in effect. */
5457 parameter_brace_patsub (varname, value, patsub, quoted)
5458 char *varname, *value, *patsub;
5461 int vtype, mflags, starsub;
5462 char *val, *temp, *pat, *rep, *p, *lpatsub, *tt;
5466 return ((char *)NULL);
5468 this_command_name = varname;
5470 vtype = get_var_and_type (varname, value, quoted, &v, &val);
5472 return ((char *)NULL);
5474 starsub = vtype & VT_STARSUB;
5475 vtype &= ~VT_STARSUB;
5480 mflags |= MATCH_GLOBREP;
5484 /* Malloc this because expand_string_if_necessary or one of the expansion
5485 functions in its call chain may free it on a substitution error. */
5486 lpatsub = savestring (patsub);
5488 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
5489 mflags |= MATCH_QUOTED;
5492 mflags |= MATCH_STARSUB;
5494 if (rep = quoted_strchr (lpatsub, '/', ST_BACKSL))
5499 if (rep && *rep == '\0')
5503 /* Expand PAT and REP for command, variable and parameter, arithmetic,
5504 and process substitution. Also perform quote removal. Do not
5505 perform word splitting or filename generation. */
5506 pat = expand_string_if_necessary (lpatsub, (quoted & ~Q_DOUBLE_QUOTES), expand_string_unsplit);
5508 /* Perform the same expansions on the pattern as performed by the
5509 pattern removal expansions. */
5510 pat = getpattern (lpatsub, quoted, 1);
5515 if ((mflags & MATCH_QUOTED) == 0)
5516 rep = expand_string_if_necessary (rep, quoted, expand_string_unsplit);
5518 rep = expand_string_to_string_internal (rep, quoted, expand_string_unsplit);
5522 if (pat && pat[0] == '#')
5524 mflags |= MATCH_BEG;
5527 else if (pat && pat[0] == '%')
5529 mflags |= MATCH_END;
5533 mflags |= MATCH_ANY;
5535 /* OK, we now want to substitute REP for PAT in VAL. If
5536 flags & MATCH_GLOBREP is non-zero, the substitution is done
5537 everywhere, otherwise only the first occurrence of PAT is
5538 replaced. The pattern matching code doesn't understand
5539 CTLESC quoting CTLESC and CTLNUL so we use the dequoted variable
5540 values passed in (VT_VARIABLE) so the pattern substitution
5541 code works right. We need to requote special chars after
5542 we're done for VT_VARIABLE and VT_ARRAYMEMBER, and for the
5543 other cases if QUOTED == 0, since the posparams and arrays
5544 indexed by * or @ do special things when QUOTED != 0. */
5549 case VT_ARRAYMEMBER:
5550 temp = pat_subst (val, p, rep, mflags);
5551 if (vtype == VT_VARIABLE)
5555 tt = quote_escapes (temp);
5561 temp = pos_params_pat_subst (val, p, rep, mflags);
5562 if (temp && (mflags & MATCH_QUOTED) == 0)
5564 tt = quote_escapes (temp);
5569 #if defined (ARRAY_VARS)
5571 temp = array_patsub (array_cell (v), p, rep, mflags);
5572 if (temp && (mflags & MATCH_QUOTED) == 0)
5574 tt = quote_escapes (temp);
5589 /****************************************************************/
5591 /* Functions to perform parameter expansion on a string */
5593 /****************************************************************/
5595 /* ${[#][!]name[[:]#[#]%[%]-=?+[word][:e1[:e2]]]} */
5597 parameter_brace_expand (string, indexp, quoted, quoted_dollar_atp, contains_dollar_at)
5599 int *indexp, quoted, *quoted_dollar_atp, *contains_dollar_at;
5601 int check_nullness, var_is_set, var_is_null, var_is_special;
5602 int want_substring, want_indir, want_patsub;
5603 char *name, *value, *temp, *temp1;
5604 int t_index, sindex, c;
5607 value = (char *)NULL;
5608 var_is_set = var_is_null = var_is_special = check_nullness = 0;
5609 want_substring = want_indir = want_patsub = 0;
5613 name = string_extract (string, &t_index, "#%:-=?+/}", EX_VARNAME);
5615 /* If the name really consists of a special variable, then make sure
5616 that we have the entire name. We don't allow indirect references
5617 to special variables except `#', `?', `@' and `*'. */
5618 if ((sindex == t_index &&
5619 (string[t_index] == '-' ||
5620 string[t_index] == '?' ||
5621 string[t_index] == '#')) ||
5622 (sindex == t_index - 1 && string[sindex] == '!' &&
5623 (string[t_index] == '#' ||
5624 string[t_index] == '?' ||
5625 string[t_index] == '@' ||
5626 string[t_index] == '*')))
5630 temp1 = string_extract (string, &t_index, "#%:-=?+/}", 0);
5631 name = (char *)xmalloc (3 + (strlen (temp1)));
5632 *name = string[sindex];
5633 if (string[sindex] == '!')
5635 /* indirect reference of $#, $?, $@, or $* */
5636 name[1] = string[sindex + 1];
5637 strcpy (name + 2, temp1);
5640 strcpy (name + 1, temp1);
5645 /* Find out what character ended the variable name. Then
5646 do the appropriate thing. */
5647 if (c = string[sindex])
5650 /* If c is followed by one of the valid parameter expansion
5651 characters, move past it as normal. If not, assume that
5652 a substring specification is being given, and do not move
5654 if (c == ':' && VALID_PARAM_EXPAND_CHAR (string[sindex]))
5657 if (c = string[sindex])
5660 else if (c == ':' && string[sindex] != RBRACE)
5662 else if (c == '/' && string[sindex] != RBRACE)
5665 /* Catch the valid and invalid brace expressions that made it through the
5667 /* ${#-} is a valid expansion and means to take the length of $-.
5668 Similarly for ${#?} and ${##}... */
5669 if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
5670 VALID_SPECIAL_LENGTH_PARAM (c) && string[sindex] == RBRACE)
5672 name = (char *)xrealloc (name, 3);
5675 c = string[sindex++];
5678 /* ...but ${#%}, ${#:}, ${#=}, ${#+}, and ${#/} are errors. */
5679 if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
5680 member (c, "%:=+/") && string[sindex] == RBRACE)
5682 temp = (char *)NULL;
5683 goto bad_substitution;
5686 /* Indirect expansion begins with a `!'. A valid indirect expansion is
5687 either a variable name, one of the positional parameters or a special
5688 variable that expands to one of the positional parameters. */
5689 want_indir = *name == '!' &&
5690 (legal_variable_starter ((unsigned char)name[1]) || DIGIT (name[1])
5691 || VALID_INDIR_PARAM (name[1]));
5693 /* Determine the value of this variable. */
5695 /* Check for special variables, directly referenced. */
5696 if (SPECIAL_VAR (name, want_indir))
5699 /* Check for special expansion things, like the length of a parameter */
5700 if (*name == '#' && name[1])
5702 /* If we are not pointing at the character just after the
5703 closing brace, then we haven't gotten all of the name.
5704 Since it begins with a special character, this is a bad
5705 substitution. Also check NAME for validity before trying
5707 if (string[sindex - 1] != RBRACE || (valid_length_expression (name) == 0))
5709 temp = (char *)NULL;
5710 goto bad_substitution;
5713 number = parameter_brace_expand_length (name);
5717 return ((number < 0) ? &expand_param_error : itos (number));
5720 /* ${@} is identical to $@. */
5721 if (name[0] == '@' && name[1] == '\0')
5723 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5724 *quoted_dollar_atp = 1;
5726 if (contains_dollar_at)
5727 *contains_dollar_at = 1;
5730 /* Process ${!PREFIX*} expansion. */
5731 if (want_indir && string[sindex - 1] == RBRACE &&
5732 (string[sindex - 2] == '*' || string[sindex - 2] == '@') &&
5733 legal_variable_starter ((unsigned char) name[1]))
5738 temp1 = savestring (name + 1);
5739 number = strlen (temp1);
5740 temp1[number - 1] = '\0';
5741 x = all_variables_matching_prefix (temp1);
5742 xlist = strvec_to_word_list (x, 0, 0);
5743 if (string[sindex - 2] == '*')
5744 temp = string_list_dollar_star (xlist);
5747 temp = string_list_dollar_at (xlist, quoted);
5748 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5749 *quoted_dollar_atp = 1;
5750 if (contains_dollar_at)
5751 *contains_dollar_at = 1;
5760 #if defined (ARRAY_VARS)
5761 /* Process ${!ARRAY[@]} and ${!ARRAY[*]} expansion. */ /* [ */
5762 if (want_indir && string[sindex - 1] == RBRACE &&
5763 string[sindex - 2] == ']' && valid_array_reference (name+1))
5767 temp1 = savestring (name + 1);
5768 x = array_variable_name (temp1, &x1, (int *)0); /* [ */
5770 if (ALL_ELEMENT_SUB (x1[0]) && x1[1] == ']')
5772 temp = array_keys (temp1, quoted);
5775 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5776 *quoted_dollar_atp = 1;
5777 if (contains_dollar_at)
5778 *contains_dollar_at = 1;
5788 #endif /* ARRAY_VARS */
5790 /* Make sure that NAME is valid before trying to go on. */
5791 if (valid_brace_expansion_word (want_indir ? name + 1 : name,
5792 var_is_special) == 0)
5794 temp = (char *)NULL;
5795 goto bad_substitution;
5799 temp = parameter_brace_expand_indir (name + 1, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at);
5801 temp = parameter_brace_expand_word (name, var_is_special, quoted);
5803 #if defined (ARRAY_VARS)
5804 if (valid_array_reference (name))
5805 chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at);
5808 var_is_set = temp != (char *)0;
5809 var_is_null = check_nullness && (var_is_set == 0 || *temp == 0);
5811 /* Get the rest of the stuff inside the braces. */
5812 if (c && c != RBRACE)
5814 /* Extract the contents of the ${ ... } expansion
5815 according to the Posix.2 rules. */
5816 value = extract_dollar_brace_string (string, &sindex, quoted, 0);
5817 if (string[sindex] == RBRACE)
5820 goto bad_substitution;
5823 value = (char *)NULL;
5827 /* If this is a substring spec, process it and add the result. */
5830 temp1 = parameter_brace_substring (name, temp, value, quoted);
5836 else if (want_patsub)
5838 temp1 = parameter_brace_patsub (name, temp, value, quoted);
5845 /* Do the right thing based on which character ended the variable name. */
5851 report_error (_("%s: bad substitution"), string ? string : "??");
5855 return &expand_param_error;
5858 if (var_is_set == 0 && unbound_vars_is_error)
5860 err_unboundvar (name);
5864 last_command_exit_value = EXECUTION_FAILURE;
5865 return (interactive_shell ? &expand_param_error : &expand_param_fatal);
5869 case '#': /* ${param#[#]pattern} */
5870 case '%': /* ${param%[%]pattern} */
5871 if (value == 0 || *value == '\0' || temp == 0 || *temp == '\0')
5876 temp1 = parameter_brace_remove_pattern (name, temp, value, c, quoted);
5886 if (var_is_set && var_is_null == 0)
5888 /* If the operator is `+', we don't want the value of the named
5889 variable for anything, just the value of the right hand side. */
5893 /* XXX -- if we're double-quoted and the named variable is "$@",
5894 we want to turn off any special handling of "$@" --
5895 we're not using it, so whatever is on the rhs applies. */
5896 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5897 *quoted_dollar_atp = 0;
5898 if (contains_dollar_at)
5899 *contains_dollar_at = 0;
5904 temp = parameter_brace_expand_rhs (name, value, c,
5907 contains_dollar_at);
5911 temp = (char *)NULL;
5917 /* Otherwise do nothing; just use the value in TEMP. */
5919 else /* VAR not set or VAR is NULL. */
5922 temp = (char *)NULL;
5923 if (c == '=' && var_is_special)
5925 report_error (_("$%s: cannot assign in this way"), name);
5928 return &expand_param_error;
5932 parameter_brace_expand_error (name, value);
5933 return (interactive_shell ? &expand_param_error : &expand_param_fatal);
5937 /* XXX -- if we're double-quoted and the named variable is "$@",
5938 we want to turn off any special handling of "$@" --
5939 we're not using it, so whatever is on the rhs applies. */
5940 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5941 *quoted_dollar_atp = 0;
5942 if (contains_dollar_at)
5943 *contains_dollar_at = 0;
5945 temp = parameter_brace_expand_rhs (name, value, c, quoted,
5947 contains_dollar_at);
5958 /* Expand a single ${xxx} expansion. The braces are optional. When
5959 the braces are used, parameter_brace_expand() does the work,
5960 possibly calling param_expand recursively. */
5962 param_expand (string, sindex, quoted, expanded_something,
5963 contains_dollar_at, quoted_dollar_at_p, had_quoted_null_p,
5966 int *sindex, quoted, *expanded_something, *contains_dollar_at;
5967 int *quoted_dollar_at_p, *had_quoted_null_p, pflags;
5969 char *temp, *temp1, uerror[3];
5970 int zindex, t_index, expok;
5977 c = string[++zindex];
5979 temp = (char *)NULL;
5981 /* Do simple cases first. Switch on what follows '$'. */
5995 temp1 = dollar_vars[TODIGIT (c)];
5996 if (unbound_vars_is_error && temp1 == (char *)NULL)
6001 err_unboundvar (uerror);
6002 last_command_exit_value = EXECUTION_FAILURE;
6003 return (interactive_shell ? &expand_param_error : &expand_param_fatal);
6007 temp = (*temp1 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
6008 ? quote_string (temp1)
6009 : quote_escapes (temp1);
6011 temp = (char *)NULL;
6013 temp = temp1 ? quote_escapes (temp1) : (char *)NULL;
6017 /* $$ -- pid of the invoking shell. */
6019 temp = itos (dollar_dollar_pid);
6022 /* $# -- number of positional parameters. */
6024 temp = itos (number_of_args ());
6027 /* $? -- return value of the last synchronous command. */
6029 temp = itos (last_command_exit_value);
6032 /* $- -- flags supplied to the shell on invocation or by `set'. */
6034 temp = which_set_flags ();
6037 /* $! -- Pid of the last asynchronous command. */
6039 /* If no asynchronous pids have been created, expand to nothing.
6040 If `set -u' has been executed, and no async processes have
6041 been created, this is an expansion error. */
6042 if (last_asynchronous_pid == NO_PID)
6044 if (expanded_something)
6045 *expanded_something = 0;
6046 temp = (char *)NULL;
6047 if (unbound_vars_is_error)
6052 err_unboundvar (uerror);
6053 last_command_exit_value = EXECUTION_FAILURE;
6054 return (interactive_shell ? &expand_param_error : &expand_param_fatal);
6058 temp = itos (last_asynchronous_pid);
6061 /* The only difference between this and $@ is when the arg is quoted. */
6062 case '*': /* `$*' */
6063 list = list_rest_of_args ();
6065 /* If there are no command-line arguments, this should just
6066 disappear if there are other characters in the expansion,
6067 even if it's quoted. */
6068 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && list == 0)
6069 temp = (char *)NULL;
6070 else if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6072 /* If we have "$*" we want to make a string of the positional
6073 parameters, separated by the first character of $IFS, and
6074 quote the whole string, including the separators. If IFS
6075 is unset, the parameters are separated by ' '; if $IFS is
6076 null, the parameters are concatenated. */
6078 temp = string_list_dollar_star (list);
6080 temp = (quoted & Q_DOUBLE_QUOTES) ? string_list_dollar_star (list) : string_list (list);
6082 temp1 = quote_string (temp);
6088 /* If the $* is not quoted it is identical to $@ */
6089 temp = string_list_dollar_at (list, quoted);
6090 if (expand_no_split_dollar_star == 0 && contains_dollar_at)
6091 *contains_dollar_at = 1;
6094 dispose_words (list);
6097 /* When we have "$@" what we want is "$1" "$2" "$3" ... This
6098 means that we have to turn quoting off after we split into
6099 the individually quoted arguments so that the final split
6100 on the first character of $IFS is still done. */
6101 case '@': /* `$@' */
6102 list = list_rest_of_args ();
6104 /* We want to flag the fact that we saw this. We can't turn
6105 off quoting entirely, because other characters in the
6106 string might need it (consider "\"$@\""), but we need some
6107 way to signal that the final split on the first character
6108 of $IFS should be done, even though QUOTED is 1. */
6109 if (quoted_dollar_at_p && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
6110 *quoted_dollar_at_p = 1;
6111 if (contains_dollar_at)
6112 *contains_dollar_at = 1;
6114 /* We want to separate the positional parameters with the first
6115 character of $IFS in case $IFS is something other than a space.
6116 We also want to make sure that splitting is done no matter what --
6117 according to POSIX.2, this expands to a list of the positional
6118 parameters no matter what IFS is set to. */
6119 temp = string_list_dollar_at (list, quoted);
6121 dispose_words (list);
6125 temp = parameter_brace_expand (string, &zindex, quoted,
6127 contains_dollar_at);
6128 if (temp == &expand_param_error || temp == &expand_param_fatal)
6132 /* Quoted nulls should be removed if there is anything else
6134 /* Note that we saw the quoted null so we can add one back at
6135 the end of this function if there are no other characters
6136 in the string, discard TEMP, and go on. The exception to
6137 this is when we have "${@}" and $1 is '', since $@ needs
6138 special handling. */
6139 if (temp && QUOTED_NULL (temp))
6141 if (had_quoted_null_p)
6142 *had_quoted_null_p = 1;
6143 if (*quoted_dollar_at_p == 0)
6146 temp = (char *)NULL;
6153 /* Do command or arithmetic substitution. */
6155 /* We have to extract the contents of this paren substitution. */
6156 t_index = zindex + 1;
6157 temp = extract_command_subst (string, &t_index);
6160 /* For Posix.2-style `$(( ))' arithmetic substitution,
6161 extract the expression and pass it to the evaluator. */
6162 if (temp && *temp == LPAREN)
6166 temp2 = savestring (temp1);
6167 t_index = strlen (temp2) - 1;
6169 if (temp2[t_index] != RPAREN)
6175 /* Cut off ending `)' */
6176 temp2[t_index] = '\0';
6178 /* Expand variables found inside the expression. */
6179 temp1 = expand_string_if_necessary (temp2, Q_DOUBLE_QUOTES, expand_string);
6183 /* No error messages. */
6184 this_command_name = (char *)NULL;
6185 number = evalexp (temp1, &expok);
6190 if (interactive_shell == 0 && posixly_correct)
6192 last_command_exit_value = EXECUTION_FAILURE;
6193 return (&expand_param_fatal);
6196 return (&expand_param_error);
6198 temp = itos (number);
6203 if (pflags & PF_NOCOMSUB)
6204 /* we need zindex+1 because string[zindex] == RPAREN */
6205 temp1 = substring (string, *sindex, zindex+1);
6207 temp1 = command_substitute (temp, quoted);
6212 /* Do POSIX.2d9-style arithmetic substitution. This will probably go
6213 away in a future bash release. */
6215 /* Extract the contents of this arithmetic substitution. */
6216 t_index = zindex + 1;
6217 temp = extract_arithmetic_subst (string, &t_index);
6220 /* Do initial variable expansion. */
6221 temp1 = expand_string_if_necessary (temp, Q_DOUBLE_QUOTES, expand_string);
6226 /* Find the variable in VARIABLE_LIST. */
6227 temp = (char *)NULL;
6229 for (t_index = zindex; (c = string[zindex]) && legal_variable_char (c); zindex++)
6231 temp1 = (zindex > t_index) ? substring (string, t_index, zindex) : (char *)NULL;
6233 /* If this isn't a variable name, then just output the `$'. */
6234 if (temp1 == 0 || *temp1 == '\0')
6237 temp = (char *)xmalloc (2);
6240 if (expanded_something)
6241 *expanded_something = 0;
6245 /* If the variable exists, return its value cell. */
6246 var = find_variable (temp1);
6248 if (var && invisible_p (var) == 0 && var_isset (var))
6250 #if defined (ARRAY_VARS)
6253 temp = array_reference (array_cell (var), 0);
6255 temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
6256 ? quote_string (temp)
6257 : quote_escapes (temp);
6258 else if (unbound_vars_is_error)
6259 goto unbound_variable;
6264 temp = value_cell (var);
6266 temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
6267 ? quote_string (temp)
6268 : quote_escapes (temp);
6276 temp = (char *)NULL;
6279 if (unbound_vars_is_error)
6280 err_unboundvar (temp1);
6288 last_command_exit_value = EXECUTION_FAILURE;
6289 return ((unbound_vars_is_error && interactive_shell == 0)
6290 ? &expand_param_fatal
6291 : &expand_param_error);
6302 /* Make a word list which is the result of parameter and variable
6303 expansion, command substitution, arithmetic substitution, and
6304 quote removal of WORD. Return a pointer to a WORD_LIST which is
6305 the result of the expansion. If WORD contains a null word, the
6306 word list returned is also null.
6308 QUOTED contains flag values defined in shell.h.
6310 ISEXP is used to tell expand_word_internal that the word should be
6311 treated as the result of an expansion. This has implications for
6312 how IFS characters in the word are treated.
6314 CONTAINS_DOLLAR_AT and EXPANDED_SOMETHING are return values; when non-null
6315 they point to an integer value which receives information about expansion.
6316 CONTAINS_DOLLAR_AT gets non-zero if WORD contained "$@", else zero.
6317 EXPANDED_SOMETHING get non-zero if WORD contained any parameter expansions,
6320 This only does word splitting in the case of $@ expansion. In that
6321 case, we split on ' '. */
6323 /* Values for the local variable quoted_state. */
6325 #define PARTIALLY_QUOTED 1
6326 #define WHOLLY_QUOTED 2
6329 expand_word_internal (word, quoted, isexp, contains_dollar_at, expanded_something)
6332 int *contains_dollar_at;
6333 int *expanded_something;
6338 /* The intermediate string that we build while expanding. */
6341 /* The current size of the above object. */
6344 /* Index into ISTRING. */
6347 /* Temporary string storage. */
6350 /* The text of WORD. */
6351 register char *string;
6353 /* The size of STRING. */
6356 /* The index into STRING. */
6359 /* This gets 1 if we see a $@ while quoted. */
6360 int quoted_dollar_at;
6362 /* One of UNQUOTED, PARTIALLY_QUOTED, or WHOLLY_QUOTED, depending on
6363 whether WORD contains no quoting characters, a partially quoted
6364 string (e.g., "xx"ab), or is fully quoted (e.g., "xxab"). */
6368 int had_quoted_null;
6372 int assignoff; /* If assignment, offset of `=' */
6374 register unsigned char c; /* Current character. */
6375 int t_index; /* For calls to string_extract_xxx. */
6381 istring = (char *)xmalloc (istring_size = DEFAULT_INITIAL_ARRAY_SIZE);
6382 istring[istring_index = 0] = '\0';
6383 quoted_dollar_at = had_quoted_null = has_dollar_at = 0;
6384 quoted_state = UNQUOTED;
6386 string = word->word;
6388 goto finished_with_string;
6389 string_size = strlen (string);
6391 if (contains_dollar_at)
6392 *contains_dollar_at = 0;
6396 /* Begin the expansion. */
6402 /* Case on toplevel character. */
6406 goto finished_with_string;
6410 #if HANDLE_MULTIBYTE
6411 if (MB_CUR_MAX > 1 && string[sindex])
6413 SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
6418 temp = (char *)xmalloc (3);
6420 temp[1] = c = string[sindex];
6431 istring = sub_append_string (temp, istring, &istring_index, &istring_size);
6437 #if defined (PROCESS_SUBSTITUTION)
6438 /* Process substitution. */
6442 if (string[++sindex] != LPAREN || (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || posixly_correct)
6444 sindex--; /* add_character: label increments sindex */
6448 t_index = sindex + 1; /* skip past both '<' and LPAREN */
6450 temp1 = extract_process_subst (string, (c == '<') ? "<(" : ">(", &t_index); /*))*/
6453 /* If the process substitution specification is `<()', we want to
6454 open the pipe for writing in the child and produce output; if
6455 it is `>()', we want to open the pipe for reading in the child
6456 and consume input. */
6457 temp = temp1 ? process_substitute (temp1, (c == '>')) : (char *)0;
6461 goto dollar_add_string;
6463 #endif /* PROCESS_SUBSTITUTION */
6466 if (word->flags & (W_ASSIGNRHS|W_NOTILDE))
6468 if ((word->flags & W_ASSIGNMENT) && assignoff == -1 && sindex > 0)
6470 if (sindex == assignoff && string[sindex+1] == '~') /* XXX */
6471 word->flags |= W_ITILDE;
6472 else if ((word->flags & W_ASSIGNMENT) &&
6473 (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
6474 string[sindex+1] == '~')
6475 word->flags |= W_ITILDE;
6479 if (word->flags & W_NOTILDE)
6481 if ((word->flags & (W_ASSIGNMENT|W_ASSIGNRHS)) &&
6482 (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
6483 string[sindex+1] == '~')
6484 word->flags |= W_ITILDE;
6488 /* If the word isn't supposed to be tilde expanded, or we're not
6489 at the start of a word or after an unquoted : or = in an
6490 assignment statement, we don't do tilde expansion. */
6491 if ((word->flags & W_NOTILDE) ||
6492 (sindex > 0 && ((word->flags & W_ITILDE) == 0)) ||
6493 (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
6495 word->flags &= ~W_ITILDE;
6498 temp = tilde_find_word (string + sindex, 1, &t_index);
6499 if (temp && *temp && unquoted_tilde_word (temp) == 0)
6505 if (word->flags & W_ASSIGNRHS)
6507 else if ((word->flags & W_ASSIGNMENT) &&
6508 (posixly_correct == 0 || (word->flags & W_TILDEEXP)))
6513 word->flags &= ~W_ITILDE;
6515 if (temp && *temp && t_index > 0)
6517 temp1 = bash_tilde_expand (temp, tflag);
6530 if (expanded_something)
6531 *expanded_something = 1;
6534 temp = param_expand (string, &sindex, quoted, expanded_something,
6535 &has_dollar_at, "ed_dollar_at,
6537 (word->flags & W_NOCOMSUB) ? PF_NOCOMSUB : 0);
6539 if (temp == &expand_param_error || temp == &expand_param_fatal)
6543 return ((temp == &expand_param_error) ? &expand_word_error
6544 : &expand_word_fatal);
6546 if (contains_dollar_at && has_dollar_at)
6547 *contains_dollar_at = 1;
6551 case '`': /* Backquoted command substitution. */
6555 if (expanded_something)
6556 *expanded_something = 1;
6558 temp = string_extract (string, &sindex, "`", 0);
6559 if (word->flags & W_NOCOMSUB)
6560 /* sindex + 1 because string[sindex] == '`' */
6561 temp1 = substring (string, t_index, sindex + 1);
6564 de_backslash (temp);
6565 temp1 = command_substitute (temp, quoted);
6569 goto dollar_add_string;
6573 if (string[sindex + 1] == '\n')
6579 c = string[++sindex];
6581 if (quoted & Q_HERE_DOCUMENT)
6583 else if (quoted & Q_DOUBLE_QUOTES)
6588 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0))
6590 SCOPY_CHAR_I (twochars, '\\', c, string, sindex, string_size);
6595 sindex--; /* add_character: label increments sindex */
6600 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
6605 /* BEFORE jumping here, we need to increment sindex if appropriate */
6606 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
6607 DEFAULT_ARRAY_SIZE);
6608 istring[istring_index++] = twochars[0];
6609 istring[istring_index++] = twochars[1];
6610 istring[istring_index] = '\0';
6616 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT|Q_PATQUOTE))
6618 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6623 temp = string_extract_double_quoted (string, &sindex, 0);
6625 /* If the quotes surrounded the entire string, then the
6626 whole word was quoted. */
6627 quoted_state = (t_index == 1 && string[sindex] == '\0')
6633 tword = make_word (temp); /* XXX */
6635 temp = (char *)NULL;
6638 list = expand_word_internal (tword, Q_DOUBLE_QUOTES, 0, &has_dollar_at, (int *)NULL);
6640 if (list == &expand_word_error || list == &expand_word_fatal)
6644 /* expand_word_internal has already freed temp_word->word
6645 for us because of the way it prints error messages. */
6646 tword->word = (char *)NULL;
6647 dispose_word (tword);
6651 dispose_word (tword);
6653 /* "$@" (a double-quoted dollar-at) expands into nothing,
6654 not even a NULL word, when there are no positional
6656 if (list == 0 && has_dollar_at)
6662 /* If we get "$@", we know we have expanded something, so we
6663 need to remember it for the final split on $IFS. This is
6664 a special case; it's the only case where a quoted string
6665 can expand into more than one word. It's going to come back
6666 from the above call to expand_word_internal as a list with
6667 a single word, in which all characters are quoted and
6668 separated by blanks. What we want to do is to turn it back
6669 into a list for the next piece of code. */
6671 dequote_list (list);
6676 if (contains_dollar_at)
6677 *contains_dollar_at = 1;
6678 if (expanded_something)
6679 *expanded_something = 1;
6684 /* What we have is "". This is a minor optimization. */
6686 list = (WORD_LIST *)NULL;
6689 /* The code above *might* return a list (consider the case of "$@",
6690 where it returns "$1", "$2", etc.). We can't throw away the
6691 rest of the list, and we have to make sure each word gets added
6692 as quoted. We test on tresult->next: if it is non-NULL, we
6693 quote the whole list, save it to a string with string_list, and
6694 add that string. We don't need to quote the results of this
6695 (and it would be wrong, since that would quote the separators
6696 as well), so we go directly to add_string. */
6701 /* Testing quoted_dollar_at makes sure that "$@" is
6702 split correctly when $IFS does not contain a space. */
6703 temp = quoted_dollar_at
6704 ? string_list_dollar_at (list, Q_DOUBLE_QUOTES)
6705 : string_list (quote_list (list));
6706 dispose_words (list);
6711 temp = savestring (list->word->word);
6712 dispose_words (list);
6714 /* If the string is not a quoted null string, we want
6715 to remove any embedded unquoted CTLNUL characters.
6716 We do not want to turn quoted null strings back into
6717 the empty string, though. We do this because we
6718 want to remove any quoted nulls from expansions that
6719 contain other characters. For example, if we have
6720 x"$*"y or "x$*y" and there are no positional parameters,
6721 the $* should expand into nothing. */
6722 /* HOWEVER, this fails if the string contains a literal
6723 CTLNUL or CTLNUL is contained in the (non-null) expansion
6724 of some variable. I'm not sure what to do about this
6725 yet. There has to be some way to indicate the difference
6726 between the two. An auxiliary data structure might be
6728 if (QUOTED_NULL (temp) == 0)
6729 remove_quoted_nulls (temp); /* XXX */
6734 temp = (char *)NULL;
6736 /* We do not want to add quoted nulls to strings that are only
6737 partially quoted; we can throw them away. */
6738 if (temp == 0 && quoted_state == PARTIALLY_QUOTED)
6746 temp = quote_string (temp);
6754 sindex--; /* add_character: label increments sindex */
6762 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT|Q_PATQUOTE))
6764 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6769 temp = string_extract_single_quoted (string, &sindex);
6771 /* If the entire STRING was surrounded by single quotes,
6772 then the string is wholly quoted. */
6773 quoted_state = (t_index == 1 && string[sindex] == '\0')
6777 /* If all we had was '', it is a null expansion. */
6781 temp = (char *)NULL;
6784 remove_quoted_escapes (temp); /* ??? */
6786 /* We do not want to add quoted nulls to strings that are only
6787 partially quoted; such nulls are discarded. */
6788 if (temp == 0 && (quoted_state == PARTIALLY_QUOTED))
6791 /* If we have a quoted null expansion, add a quoted NULL to istring. */
6795 sindex--; /* add_character: label increments sindex */
6799 goto add_quoted_string;
6804 /* This is the fix for " $@ " */
6805 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (isexp == 0 && isifs (c)))
6807 if (string[sindex]) /* from old goto dollar_add_string */
6816 #if HANDLE_MULTIBYTE
6822 SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
6827 twochars[0] = CTLESC;
6834 SADD_MBCHAR (temp, string, sindex, string_size);
6837 RESIZE_MALLOCED_BUFFER (istring, istring_index, 1, istring_size,
6838 DEFAULT_ARRAY_SIZE);
6839 istring[istring_index++] = c;
6840 istring[istring_index] = '\0';
6842 /* Next character. */
6847 finished_with_string:
6848 /* OK, we're ready to return. If we have a quoted string, and
6849 quoted_dollar_at is not set, we do no splitting at all; otherwise
6850 we split on ' '. The routines that call this will handle what to
6851 do if nothing has been expanded. */
6853 /* Partially and wholly quoted strings which expand to the empty
6854 string are retained as an empty arguments. Unquoted strings
6855 which expand to the empty string are discarded. The single
6856 exception is the case of expanding "$@" when there are no
6857 positional parameters. In that case, we discard the expansion. */
6859 /* Because of how the code that handles "" and '' in partially
6860 quoted strings works, we need to make ISTRING into a QUOTED_NULL
6861 if we saw quoting characters, but the expansion was empty.
6862 "" and '' are tossed away before we get to this point when
6863 processing partially quoted strings. This makes "" and $xxx""
6864 equivalent when xxx is unset. We also look to see whether we
6865 saw a quoted null from a ${} expansion and add one back if we
6868 /* If we expand to nothing and there were no single or double quotes
6869 in the word, we throw it away. Otherwise, we return a NULL word.
6870 The single exception is for $@ surrounded by double quotes when
6871 there are no positional parameters. In that case, we also throw
6874 if (*istring == '\0')
6876 if (quoted_dollar_at == 0 && (had_quoted_null || quoted_state == PARTIALLY_QUOTED))
6878 istring[0] = CTLNUL;
6880 tword = make_bare_word (istring);
6881 list = make_word_list (tword, (WORD_LIST *)NULL);
6882 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6883 tword->flags |= W_QUOTED;
6885 /* According to sh, ksh, and Posix.2, if a word expands into nothing
6886 and a double-quoted "$@" appears anywhere in it, then the entire
6888 else if (quoted_state == UNQUOTED || quoted_dollar_at)
6889 list = (WORD_LIST *)NULL;
6893 tword = make_bare_word (istring);
6894 list = make_word_list (tword, (WORD_LIST *)NULL);
6895 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6896 tword->flags |= W_QUOTED;
6900 list = (WORD_LIST *)NULL;
6903 else if (word->flags & W_NOSPLIT)
6905 tword = make_bare_word (istring);
6906 list = make_word_list (tword, (WORD_LIST *)NULL);
6907 if (word->flags & W_ASSIGNMENT)
6908 tword->flags |= W_ASSIGNMENT; /* XXX */
6909 if (word->flags & W_NOGLOB)
6910 tword->flags |= W_NOGLOB; /* XXX */
6911 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6912 tword->flags |= W_QUOTED;
6918 ifs_chars = (quoted_dollar_at || has_dollar_at) ? ifs_value : (char *)NULL;
6920 /* If we have $@, we need to split the results no matter what. If
6921 IFS is unset or NULL, string_list_dollar_at has separated the
6922 positional parameters with a space, so we split on space (we have
6923 set ifs_chars to " \t\n" above if ifs is unset). If IFS is set,
6924 string_list_dollar_at has separated the positional parameters
6925 with the first character of $IFS, so we split on $IFS. */
6926 if (has_dollar_at && ifs_chars)
6927 list = list_string (istring, *ifs_chars ? ifs_chars : " ", 1);
6930 tword = make_bare_word (istring);
6931 list = make_word_list (tword, (WORD_LIST *)NULL);
6932 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || (quoted_state == WHOLLY_QUOTED))
6933 tword->flags |= W_QUOTED;
6934 if (word->flags & W_ASSIGNMENT)
6935 tword->flags |= W_ASSIGNMENT;
6936 if (word->flags & W_NOGLOB)
6937 tword->flags |= W_NOGLOB;
6945 /* **************************************************************** */
6947 /* Functions for Quote Removal */
6949 /* **************************************************************** */
6951 /* Perform quote removal on STRING. If QUOTED > 0, assume we are obeying the
6952 backslash quoting rules for within double quotes or a here document. */
6954 string_quote_removal (string, quoted)
6959 char *r, *result_string, *temp, *send;
6960 int sindex, tindex, dquote;
6964 /* The result can be no longer than the original string. */
6965 slen = strlen (string);
6966 send = string + slen;
6968 r = result_string = (char *)xmalloc (slen + 1);
6970 for (dquote = sindex = 0; c = string[sindex];)
6975 c = string[++sindex];
6976 if (((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote) && (sh_syntaxtab[c] & CBSDQUOTE) == 0)
6981 SCOPY_CHAR_M (r, string, send, sindex);
6985 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote)
6991 tindex = sindex + 1;
6992 temp = string_extract_single_quoted (string, &tindex);
7003 dquote = 1 - dquote;
7009 return (result_string);
7014 /* Perform quote removal on word WORD. This allocates and returns a new
7017 word_quote_removal (word, quoted)
7024 t = string_quote_removal (word->word, quoted);
7025 w = make_bare_word (t);
7030 /* Perform quote removal on all words in LIST. If QUOTED is non-zero,
7031 the members of the list are treated as if they are surrounded by
7032 double quotes. Return a new list, or NULL if LIST is NULL. */
7034 word_list_quote_removal (list, quoted)
7038 WORD_LIST *result, *t, *tresult;
7040 for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
7042 tresult = make_word_list (word_quote_removal (t->word, quoted), (WORD_LIST *)NULL);
7043 result = (WORD_LIST *) list_append (result, tresult);
7049 /*******************************************
7051 * Functions to perform word splitting *
7053 *******************************************/
7063 ifs_value = v ? value_cell (v) : " \t\n";
7065 /* Should really merge ifs_cmap with sh_syntaxtab. XXX - doesn't yet
7066 handle multibyte chars in IFS */
7067 memset (ifs_cmap, '\0', sizeof (ifs_cmap));
7068 for (t = ifs_value ; t && *t; t++)
7074 #if defined (HANDLE_MULTIBYTE)
7077 ifs_firstc[0] = '\0';
7083 ifs_len = strnlen (ifs_value, MB_CUR_MAX);
7084 ifs_firstc_len = MBLEN (ifs_value, ifs_len);
7085 if (ifs_firstc_len == 1 || ifs_firstc_len == 0 || MB_INVALIDCH (ifs_firstc_len))
7087 ifs_firstc[0] = ifs_value[0];
7088 ifs_firstc[1] = '\0';
7092 memcpy (ifs_firstc, ifs_value, ifs_firstc_len);
7095 ifs_firstc = ifs_value ? *ifs_value : 0;
7105 /* This splits a single word into a WORD LIST on $IFS, but only if the word
7106 is not quoted. list_string () performs quote removal for us, even if we
7107 don't do any splitting. */
7109 word_split (w, ifs_chars)
7119 xifs = ((w->flags & W_QUOTED) || ifs_chars == 0) ? "" : ifs_chars;
7120 result = list_string (w->word, xifs, w->flags & W_QUOTED);
7123 result = (WORD_LIST *)NULL;
7128 /* Perform word splitting on LIST and return the RESULT. It is possible
7129 to return (WORD_LIST *)NULL. */
7131 word_list_split (list)
7134 WORD_LIST *result, *t, *tresult, *e;
7136 for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
7138 tresult = word_split (t->word, ifs_value);
7140 result = (WORD_LIST *) list_append (result, tresult);
7143 result = e = tresult;
7155 /**************************************************
7157 * Functions to expand an entire WORD_LIST *
7159 **************************************************/
7161 /* Do any word-expansion-specific cleanup and jump to top_level */
7163 exp_jump_to_top_level (v)
7166 /* Cleanup code goes here. */
7167 expand_no_split_dollar_star = 0; /* XXX */
7168 expanding_redir = 0;
7170 jump_to_top_level (v);
7173 /* Put NLIST (which is a WORD_LIST * of only one element) at the front of
7174 ELIST, and set ELIST to the new list. */
7175 #define PREPEND_LIST(nlist, elist) \
7176 do { nlist->next = elist; elist = nlist; } while (0)
7178 /* Separate out any initial variable assignments from TLIST. If set -k has
7179 been executed, remove all assignment statements from TLIST. Initial
7180 variable assignments and other environment assignments are placed
7181 on SUBST_ASSIGN_VARLIST. */
7183 separate_out_assignments (tlist)
7186 register WORD_LIST *vp, *lp;
7189 return ((WORD_LIST *)NULL);
7191 if (subst_assign_varlist)
7192 dispose_words (subst_assign_varlist); /* Clean up after previous error */
7194 subst_assign_varlist = (WORD_LIST *)NULL;
7197 /* Separate out variable assignments at the start of the command.
7198 Loop invariant: vp->next == lp
7200 lp = list of words left after assignment statements skipped
7201 tlist = original list of words
7203 while (lp && (lp->word->flags & W_ASSIGNMENT))
7209 /* If lp != tlist, we have some initial assignment statements.
7210 We make SUBST_ASSIGN_VARLIST point to the list of assignment
7211 words and TLIST point to the remaining words. */
7214 subst_assign_varlist = tlist;
7215 /* ASSERT(vp->next == lp); */
7216 vp->next = (WORD_LIST *)NULL; /* terminate variable list */
7217 tlist = lp; /* remainder of word list */
7220 /* vp == end of variable list */
7221 /* tlist == remainder of original word list without variable assignments */
7223 /* All the words in tlist were assignment statements */
7224 return ((WORD_LIST *)NULL);
7226 /* ASSERT(tlist != NULL); */
7227 /* ASSERT((tlist->word->flags & W_ASSIGNMENT) == 0); */
7229 /* If the -k option is in effect, we need to go through the remaining
7230 words, separate out the assignment words, and place them on
7231 SUBST_ASSIGN_VARLIST. */
7232 if (place_keywords_in_env)
7234 WORD_LIST *tp; /* tp == running pointer into tlist */
7239 /* Loop Invariant: tp->next == lp */
7240 /* Loop postcondition: tlist == word list without assignment statements */
7243 if (lp->word->flags & W_ASSIGNMENT)
7245 /* Found an assignment statement, add this word to end of
7246 subst_assign_varlist (vp). */
7247 if (!subst_assign_varlist)
7248 subst_assign_varlist = vp = lp;
7255 /* Remove the word pointed to by LP from TLIST. */
7256 tp->next = lp->next;
7257 /* ASSERT(vp == lp); */
7258 lp->next = (WORD_LIST *)NULL;
7271 #define WEXP_VARASSIGN 0x001
7272 #define WEXP_BRACEEXP 0x002
7273 #define WEXP_TILDEEXP 0x004
7274 #define WEXP_PARAMEXP 0x008
7275 #define WEXP_PATHEXP 0x010
7277 /* All of the expansions, including variable assignments at the start of
7279 #define WEXP_ALL (WEXP_VARASSIGN|WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
7281 /* All of the expansions except variable assignments at the start of
7283 #define WEXP_NOVARS (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
7285 /* All of the `shell expansions': brace expansion, tilde expansion, parameter
7286 expansion, command substitution, arithmetic expansion, word splitting, and
7288 #define WEXP_SHELLEXP (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP)
7290 /* Take the list of words in LIST and do the various substitutions. Return
7291 a new list of words which is the expanded list, and without things like
7292 variable assignments. */
7298 return (expand_word_list_internal (list, WEXP_ALL));
7301 /* Same as expand_words (), but doesn't hack variable or environment
7304 expand_words_no_vars (list)
7307 return (expand_word_list_internal (list, WEXP_NOVARS));
7311 expand_words_shellexp (list)
7314 return (expand_word_list_internal (list, WEXP_SHELLEXP));
7318 glob_expand_word_list (tlist, eflags)
7322 char **glob_array, *temp_string;
7323 register int glob_index;
7324 WORD_LIST *glob_list, *output_list, *disposables, *next;
7327 output_list = disposables = (WORD_LIST *)NULL;
7328 glob_array = (char **)NULL;
7331 /* For each word, either globbing is attempted or the word is
7332 added to orig_list. If globbing succeeds, the results are
7333 added to orig_list and the word (tlist) is added to the list
7334 of disposable words. If globbing fails and failed glob
7335 expansions are left unchanged (the shell default), the
7336 original word is added to orig_list. If globbing fails and
7337 failed glob expansions are removed, the original word is
7338 added to the list of disposable words. orig_list ends up
7339 in reverse order and requires a call to REVERSE_LIST to
7340 be set right. After all words are examined, the disposable
7344 /* If the word isn't an assignment and contains an unquoted
7345 pattern matching character, then glob it. */
7346 if ((tlist->word->flags & W_NOGLOB) == 0 &&
7347 unquoted_glob_pattern_p (tlist->word->word))
7349 glob_array = shell_glob_filename (tlist->word->word);
7351 /* Handle error cases.
7352 I don't think we should report errors like "No such file
7353 or directory". However, I would like to report errors
7354 like "Read failed". */
7356 if (glob_array == 0 || GLOB_FAILED (glob_array))
7358 glob_array = (char **)xmalloc (sizeof (char *));
7359 glob_array[0] = (char *)NULL;
7362 /* Dequote the current word in case we have to use it. */
7363 if (glob_array[0] == NULL)
7365 temp_string = dequote_string (tlist->word->word);
7366 free (tlist->word->word);
7367 tlist->word->word = temp_string;
7370 /* Make the array into a word list. */
7371 glob_list = (WORD_LIST *)NULL;
7372 for (glob_index = 0; glob_array[glob_index]; glob_index++)
7374 tword = make_bare_word (glob_array[glob_index]);
7375 tword->flags |= W_GLOBEXP; /* XXX */
7376 glob_list = make_word_list (tword, glob_list);
7381 output_list = (WORD_LIST *)list_append (glob_list, output_list);
7382 PREPEND_LIST (tlist, disposables);
7384 else if (fail_glob_expansion != 0)
7386 report_error (_("no match: %s"), tlist->word->word);
7387 jump_to_top_level (DISCARD);
7389 else if (allow_null_glob_expansion == 0)
7391 /* Failed glob expressions are left unchanged. */
7392 PREPEND_LIST (tlist, output_list);
7396 /* Failed glob expressions are removed. */
7397 PREPEND_LIST (tlist, disposables);
7402 /* Dequote the string. */
7403 temp_string = dequote_string (tlist->word->word);
7404 free (tlist->word->word);
7405 tlist->word->word = temp_string;
7406 PREPEND_LIST (tlist, output_list);
7409 strvec_dispose (glob_array);
7410 glob_array = (char **)NULL;
7416 dispose_words (disposables);
7419 output_list = REVERSE_LIST (output_list, WORD_LIST *);
7421 return (output_list);
7424 #if defined (BRACE_EXPANSION)
7426 brace_expand_word_list (tlist, eflags)
7430 register char **expansions;
7432 WORD_LIST *disposables, *output_list, *next;
7436 for (disposables = output_list = (WORD_LIST *)NULL; tlist; tlist = next)
7440 /* Only do brace expansion if the word has a brace character. If
7441 not, just add the word list element to BRACES and continue. In
7442 the common case, at least when running shell scripts, this will
7443 degenerate to a bunch of calls to `xstrchr', and then what is
7444 basically a reversal of TLIST into BRACES, which is corrected
7445 by a call to REVERSE_LIST () on BRACES when the end of TLIST
7447 if (xstrchr (tlist->word->word, LBRACE))
7449 expansions = brace_expand (tlist->word->word);
7451 for (eindex = 0; temp_string = expansions[eindex]; eindex++)
7453 w = make_word (temp_string);
7454 /* If brace expansion didn't change the word, preserve
7455 the flags. We may want to preserve the flags
7456 unconditionally someday -- XXX */
7457 if (STREQ (temp_string, tlist->word->word))
7458 w->flags = tlist->word->flags;
7459 output_list = make_word_list (w, output_list);
7460 free (expansions[eindex]);
7464 /* Add TLIST to the list of words to be freed after brace
7465 expansion has been performed. */
7466 PREPEND_LIST (tlist, disposables);
7469 PREPEND_LIST (tlist, output_list);
7473 dispose_words (disposables);
7476 output_list = REVERSE_LIST (output_list, WORD_LIST *);
7478 return (output_list);
7483 shell_expand_word_list (tlist, eflags)
7487 WORD_LIST *expanded, *orig_list, *new_list, *next, *temp_list;
7488 int expanded_something, has_dollar_at;
7491 /* We do tilde expansion all the time. This is what 1003.2 says. */
7492 new_list = (WORD_LIST *)NULL;
7493 for (orig_list = tlist; tlist; tlist = next)
7495 temp_string = tlist->word->word;
7499 /* Posix.2 section 3.6.1 says that tildes following `=' in words
7500 which are not assignment statements are not expanded. If the
7501 shell isn't in posix mode, though, we perform tilde expansion
7502 on `likely candidate' unquoted assignment statements (flags
7503 include W_ASSIGNMENT but not W_QUOTED). A likely candidate
7504 contains an unquoted :~ or =~. Something to think about: we
7505 now have a flag that says to perform tilde expansion on arguments
7506 to `assignment builtins' like declare and export that look like
7507 assignment statements. We now do tilde expansion on such words
7508 even in POSIX mode. */
7510 if (((tlist->word->flags & (W_ASSIGNMENT|W_QUOTED)) == W_ASSIGNMENT) &&
7511 (posixly_correct == 0 || (tlist->word->flags & W_TILDEEXP)) &&
7512 (unquoted_substring ("=~", temp_string) || unquoted_substring (":~", temp_string)))
7514 tlist->word->word = bash_tilde_expand (temp_string, 1);
7517 else if (temp_string[0] == '~')
7519 tlist->word->word = bash_tilde_expand (temp_string, 0);
7524 expanded_something = 0;
7525 expanded = expand_word_internal
7526 (tlist->word, 0, 0, &has_dollar_at, &expanded_something);
7528 if (expanded == &expand_word_error || expanded == &expand_word_fatal)
7530 /* By convention, each time this error is returned,
7531 tlist->word->word has already been freed. */
7532 tlist->word->word = (char *)NULL;
7534 /* Dispose our copy of the original list. */
7535 dispose_words (orig_list);
7536 /* Dispose the new list we're building. */
7537 dispose_words (new_list);
7539 last_command_exit_value = EXECUTION_FAILURE;
7540 if (expanded == &expand_word_error)
7541 exp_jump_to_top_level (DISCARD);
7543 exp_jump_to_top_level (FORCE_EOF);
7546 /* Don't split words marked W_NOSPLIT. */
7547 if (expanded_something && (tlist->word->flags & W_NOSPLIT) == 0)
7549 temp_list = word_list_split (expanded);
7550 dispose_words (expanded);
7554 /* If no parameter expansion, command substitution, process
7555 substitution, or arithmetic substitution took place, then
7556 do not do word splitting. We still have to remove quoted
7557 null characters from the result. */
7558 word_list_remove_quoted_nulls (expanded);
7559 temp_list = expanded;
7562 expanded = REVERSE_LIST (temp_list, WORD_LIST *);
7563 new_list = (WORD_LIST *)list_append (expanded, new_list);
7567 dispose_words (orig_list);
7570 new_list = REVERSE_LIST (new_list, WORD_LIST *);
7575 /* The workhorse for expand_words () and expand_words_no_vars ().
7576 First arg is LIST, a WORD_LIST of words.
7577 Second arg EFLAGS is a flags word controlling which expansions are
7580 This does all of the substitutions: brace expansion, tilde expansion,
7581 parameter expansion, command substitution, arithmetic expansion,
7582 process substitution, word splitting, and pathname expansion, according
7583 to the bits set in EFLAGS. Words with the W_QUOTED or W_NOSPLIT bits
7584 set, or for which no expansion is done, do not undergo word splitting.
7585 Words with the W_NOGLOB bit set do not undergo pathname expansion. */
7587 expand_word_list_internal (list, eflags)
7591 WORD_LIST *new_list, *temp_list;
7595 return ((WORD_LIST *)NULL);
7597 garglist = new_list = copy_word_list (list);
7598 if (eflags & WEXP_VARASSIGN)
7600 garglist = new_list = separate_out_assignments (new_list);
7603 if (subst_assign_varlist)
7605 /* All the words were variable assignments, so they are placed
7606 into the shell's environment. */
7607 for (temp_list = subst_assign_varlist; temp_list; temp_list = temp_list->next)
7609 this_command_name = (char *)NULL; /* no arithmetic errors */
7610 tint = do_assignment (temp_list->word->word);
7611 /* Variable assignment errors in non-interactive shells
7612 running in Posix.2 mode cause the shell to exit. */
7615 last_command_exit_value = EXECUTION_FAILURE;
7616 if (interactive_shell == 0 && posixly_correct)
7617 exp_jump_to_top_level (FORCE_EOF);
7619 exp_jump_to_top_level (DISCARD);
7622 dispose_words (subst_assign_varlist);
7623 subst_assign_varlist = (WORD_LIST *)NULL;
7625 return ((WORD_LIST *)NULL);
7629 /* Begin expanding the words that remain. The expansions take place on
7630 things that aren't really variable assignments. */
7632 #if defined (BRACE_EXPANSION)
7633 /* Do brace expansion on this word if there are any brace characters
7635 if ((eflags & WEXP_BRACEEXP) && brace_expansion && new_list)
7636 new_list = brace_expand_word_list (new_list, eflags);
7637 #endif /* BRACE_EXPANSION */
7639 /* Perform the `normal' shell expansions: tilde expansion, parameter and
7640 variable substitution, command substitution, arithmetic expansion,
7641 and word splitting. */
7642 new_list = shell_expand_word_list (new_list, eflags);
7644 /* Okay, we're almost done. Now let's just do some filename
7648 if ((eflags & WEXP_PATHEXP) && disallow_filename_globbing == 0)
7649 /* Glob expand the word list unless globbing has been disabled. */
7650 new_list = glob_expand_word_list (new_list, eflags);
7652 /* Dequote the words, because we're not performing globbing. */
7653 new_list = dequote_list (new_list);
7656 if ((eflags & WEXP_VARASSIGN) && subst_assign_varlist)
7658 sh_assign_func_t *assign_func;
7660 /* If the remainder of the words expand to nothing, Posix.2 requires
7661 that the variable and environment assignments affect the shell's
7663 assign_func = new_list ? assign_in_env : do_assignment;
7664 tempenv_assign_error = 0;
7666 for (temp_list = subst_assign_varlist; temp_list; temp_list = temp_list->next)
7668 this_command_name = (char *)NULL;
7669 tint = (*assign_func) (temp_list->word->word);
7670 /* Variable assignment errors in non-interactive shells running
7671 in Posix.2 mode cause the shell to exit. */
7674 if (assign_func == do_assignment)
7676 last_command_exit_value = EXECUTION_FAILURE;
7677 if (interactive_shell == 0 && posixly_correct)
7678 exp_jump_to_top_level (FORCE_EOF);
7680 exp_jump_to_top_level (DISCARD);
7683 tempenv_assign_error++;
7687 dispose_words (subst_assign_varlist);
7688 subst_assign_varlist = (WORD_LIST *)NULL;
7692 tint = list_length (new_list) + 1;
7693 RESIZE_MALLOCED_BUFFER (glob_argv_flags, 0, tint, glob_argv_flags_size, 16);
7694 for (tint = 0, temp_list = new_list; temp_list; temp_list = temp_list->next)
7695 glob_argv_flags[tint++] = (temp_list->word->flags & W_GLOBEXP) ? '1' : '0';
7696 glob_argv_flags[tint] = '\0';