1 /* subst.c -- The part of the shell that does parameter, command, arithmetic,
2 and 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-2013 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
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation, either version 3 of the License, or
14 (at your option) any later version.
16 Bash is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with Bash. If not, see <http://www.gnu.org/licenses/>.
27 #include "bashtypes.h"
29 #include "chartypes.h"
30 #if defined (HAVE_PWD_H)
36 #if defined (HAVE_UNISTD_H)
41 #include "posixstat.h"
48 #include "execute_cmd.h"
52 #include "mailcheck.h"
57 #include "builtins/getopt.h"
58 #include "builtins/common.h"
60 #include "builtins/builtext.h"
62 #include <tilde/tilde.h>
63 #include <glob/strmatch.h>
69 /* The size that strings change by. */
70 #define DEFAULT_INITIAL_ARRAY_SIZE 112
71 #define DEFAULT_ARRAY_SIZE 128
77 #define VT_ARRAYMEMBER 3
80 #define VT_STARSUB 128 /* $* or ${array[*]} -- used to split */
82 /* Flags for quoted_strchr */
83 #define ST_BACKSL 0x01
84 #define ST_CTLESC 0x02
85 #define ST_SQUOTE 0x04 /* unused yet */
86 #define ST_DQUOTE 0x08 /* unused yet */
88 /* Flags for the `pflags' argument to param_expand() */
89 #define PF_NOCOMSUB 0x01 /* Do not perform command substitution */
90 #define PF_IGNUNBOUND 0x02 /* ignore unbound vars even if -u set */
91 #define PF_NOSPLIT2 0x04 /* same as W_NOSPLIT2 */
92 #define PF_ASSIGNRHS 0x08 /* same as W_ASSIGNRHS */
94 /* These defs make it easier to use the editor. */
102 #if defined (HANDLE_MULTIBYTE)
107 /* Evaluates to 1 if C is one of the shell's special parameters whose length
108 can be taken, but is also one of the special expansion characters. */
109 #define VALID_SPECIAL_LENGTH_PARAM(c) \
110 ((c) == '-' || (c) == '?' || (c) == '#')
112 /* Evaluates to 1 if C is one of the shell's special parameters for which an
113 indirect variable reference may be made. */
114 #define VALID_INDIR_PARAM(c) \
115 ((posixly_correct == 0 && (c) == '#') || (posixly_correct == 0 && (c) == '?') || (c) == '@' || (c) == '*')
117 /* Evaluates to 1 if C is one of the OP characters that follows the parameter
118 in ${parameter[:]OPword}. */
119 #define VALID_PARAM_EXPAND_CHAR(c) (sh_syntaxtab[(unsigned char)c] & CSUBSTOP)
121 /* Evaluates to 1 if this is one of the shell's special variables. */
122 #define SPECIAL_VAR(name, wi) \
123 ((DIGIT (*name) && all_digits (name)) || \
124 (name[1] == '\0' && (sh_syntaxtab[(unsigned char)*name] & CSPECVAR)) || \
125 (wi && name[2] == '\0' && VALID_INDIR_PARAM (name[1])))
127 /* An expansion function that takes a string and a quoted flag and returns
128 a WORD_LIST *. Used as the type of the third argument to
129 expand_string_if_necessary(). */
130 typedef WORD_LIST *EXPFUNC __P((char *, int));
132 /* Process ID of the last command executed within command substitution. */
133 pid_t last_command_subst_pid = NO_PID;
134 pid_t current_command_subst_pid = NO_PID;
136 /* Variables used to keep track of the characters in IFS. */
139 unsigned char ifs_cmap[UCHAR_MAX + 1];
140 int ifs_is_set, ifs_is_null;
142 #if defined (HANDLE_MULTIBYTE)
143 unsigned char ifs_firstc[MB_LEN_MAX];
144 size_t ifs_firstc_len;
146 unsigned char ifs_firstc;
149 /* Sentinel to tell when we are performing variable assignments preceding a
150 command name and putting them into the environment. Used to make sure
151 we use the temporary environment when looking up variable values. */
152 int assigning_in_environment;
154 /* Used to hold a list of variable assignments preceding a command. Global
155 so the SIGCHLD handler in jobs.c can unwind-protect it when it runs a
156 SIGCHLD trap and so it can be saved and restored by the trap handlers. */
157 WORD_LIST *subst_assign_varlist = (WORD_LIST *)NULL;
159 /* Extern functions and variables from different files. */
160 extern int last_command_exit_value, last_command_exit_signal;
161 extern int subshell_environment, line_number;
162 extern int subshell_level, parse_and_execute_level, sourcelevel;
163 extern int eof_encountered;
164 extern int return_catch_flag, return_catch_value;
165 extern pid_t dollar_dollar_pid;
166 extern int posixly_correct;
167 extern char *this_command_name;
168 extern struct fd_bitmap *current_fds_to_close;
169 extern int wordexp_only;
170 extern int expanding_redir;
171 extern int tempenv_assign_error;
172 extern int builtin_ignoring_errexit;
174 #if !defined (HAVE_WCSDUP) && defined (HANDLE_MULTIBYTE)
175 extern wchar_t *wcsdup __P((const wchar_t *));
178 /* Non-zero means to allow unmatched globbed filenames to expand to
180 int allow_null_glob_expansion;
182 /* Non-zero means to throw an error when globbing fails to match anything. */
183 int fail_glob_expansion;
186 /* Variables to keep track of which words in an expanded word list (the
187 output of expand_word_list_internal) are the result of globbing
188 expansions. GLOB_ARGV_FLAGS is used by execute_cmd.c.
189 (CURRENTLY UNUSED). */
190 char *glob_argv_flags;
191 static int glob_argv_flags_size;
194 static WORD_LIST expand_word_error, expand_word_fatal;
195 static WORD_DESC expand_wdesc_error, expand_wdesc_fatal;
196 static char expand_param_error, expand_param_fatal;
197 static char extract_string_error, extract_string_fatal;
199 /* Tell the expansion functions to not longjmp back to top_level on fatal
200 errors. Enabled when doing completion and prompt string expansion. */
201 static int no_longjmp_on_fatal_error = 0;
203 /* Set by expand_word_unsplit; used to inhibit splitting and re-joining
204 $* on $IFS, primarily when doing assignment statements. */
205 static int expand_no_split_dollar_star = 0;
207 /* A WORD_LIST of words to be expanded by expand_word_list_internal,
208 without any leading variable assignments. */
209 static WORD_LIST *garglist = (WORD_LIST *)NULL;
211 static char *quoted_substring __P((char *, int, int));
212 static int quoted_strlen __P((char *));
213 static char *quoted_strchr __P((char *, int, int));
215 static char *expand_string_if_necessary __P((char *, int, EXPFUNC *));
216 static inline char *expand_string_to_string_internal __P((char *, int, EXPFUNC *));
217 static WORD_LIST *call_expand_word_internal __P((WORD_DESC *, int, int, int *, int *));
218 static WORD_LIST *expand_string_internal __P((char *, int));
219 static WORD_LIST *expand_string_leave_quoted __P((char *, int));
220 static WORD_LIST *expand_string_for_rhs __P((char *, int, int *, int *));
222 static WORD_LIST *list_quote_escapes __P((WORD_LIST *));
223 static WORD_LIST *list_dequote_escapes __P((WORD_LIST *));
225 static char *make_quoted_char __P((int));
226 static WORD_LIST *quote_list __P((WORD_LIST *));
228 static int unquoted_substring __P((char *, char *));
229 static int unquoted_member __P((int, char *));
231 #if defined (ARRAY_VARS)
232 static SHELL_VAR *do_compound_assignment __P((char *, char *, int));
234 static int do_assignment_internal __P((const WORD_DESC *, int));
236 static char *string_extract_verbatim __P((char *, size_t, int *, char *, int));
237 static char *string_extract __P((char *, int *, char *, int));
238 static char *string_extract_double_quoted __P((char *, int *, int));
239 static inline char *string_extract_single_quoted __P((char *, int *));
240 static inline int skip_single_quoted __P((const char *, size_t, int));
241 static int skip_double_quoted __P((char *, size_t, int));
242 static char *extract_delimited_string __P((char *, int *, char *, char *, char *, int));
243 static char *extract_dollar_brace_string __P((char *, int *, int, int));
244 static int skip_matched_pair __P((const char *, int, int, int, int));
246 static char *pos_params __P((char *, int, int, int));
248 static unsigned char *mb_getcharlens __P((char *, int));
250 static char *remove_upattern __P((char *, char *, int));
251 #if defined (HANDLE_MULTIBYTE)
252 static wchar_t *remove_wpattern __P((wchar_t *, size_t, wchar_t *, int));
254 static char *remove_pattern __P((char *, char *, int));
256 static int match_upattern __P((char *, char *, int, char **, char **));
257 #if defined (HANDLE_MULTIBYTE)
258 static int match_wpattern __P((wchar_t *, char **, size_t, wchar_t *, int, char **, char **));
260 static int match_pattern __P((char *, char *, int, char **, char **));
261 static int getpatspec __P((int, char *));
262 static char *getpattern __P((char *, int, int));
263 static char *variable_remove_pattern __P((char *, char *, int, int));
264 static char *list_remove_pattern __P((WORD_LIST *, char *, int, int, int));
265 static char *parameter_list_remove_pattern __P((int, char *, int, int));
267 static char *array_remove_pattern __P((SHELL_VAR *, char *, int, char *, int));
269 static char *parameter_brace_remove_pattern __P((char *, char *, int, char *, int, int, int));
271 static char *process_substitute __P((char *, int));
273 static char *read_comsub __P((int, int, int *));
276 static arrayind_t array_length_reference __P((char *));
279 static int valid_brace_expansion_word __P((char *, int));
280 static int chk_atstar __P((char *, int, int *, int *));
281 static int chk_arithsub __P((const char *, int));
283 static WORD_DESC *parameter_brace_expand_word __P((char *, int, int, int, arrayind_t *));
284 static char *parameter_brace_find_indir __P((char *, int, int, int));
285 static WORD_DESC *parameter_brace_expand_indir __P((char *, int, int, int *, int *));
286 static WORD_DESC *parameter_brace_expand_rhs __P((char *, char *, int, int, int *, int *));
287 static void parameter_brace_expand_error __P((char *, char *));
289 static int valid_length_expression __P((char *));
290 static intmax_t parameter_brace_expand_length __P((char *));
292 static char *skiparith __P((char *, int));
293 static int verify_substring_values __P((SHELL_VAR *, char *, char *, int, intmax_t *, intmax_t *));
294 static int get_var_and_type __P((char *, char *, arrayind_t, int, int, SHELL_VAR **, char **));
295 static char *mb_substring __P((char *, int, int));
296 static char *parameter_brace_substring __P((char *, char *, int, char *, int, int));
298 static int shouldexp_replacement __P((char *));
300 static char *pos_params_pat_subst __P((char *, char *, char *, int));
302 static char *parameter_brace_patsub __P((char *, char *, int, char *, int, int));
304 static char *pos_params_casemod __P((char *, char *, int, int));
305 static char *parameter_brace_casemod __P((char *, char *, int, int, char *, int, int));
307 static WORD_DESC *parameter_brace_expand __P((char *, int *, int, int, int *, int *));
308 static WORD_DESC *param_expand __P((char *, int *, int, int *, int *, int *, int *, int));
310 static WORD_LIST *expand_word_internal __P((WORD_DESC *, int, int, int *, int *));
312 static WORD_LIST *word_list_split __P((WORD_LIST *));
314 static void exp_jump_to_top_level __P((int));
316 static WORD_LIST *separate_out_assignments __P((WORD_LIST *));
317 static WORD_LIST *glob_expand_word_list __P((WORD_LIST *, int));
318 #ifdef BRACE_EXPANSION
319 static WORD_LIST *brace_expand_word_list __P((WORD_LIST *, int));
321 #if defined (ARRAY_VARS)
322 static int make_internal_declare __P((char *, char *));
324 static WORD_LIST *shell_expand_word_list __P((WORD_LIST *, int));
325 static WORD_LIST *expand_word_list_internal __P((WORD_LIST *, int));
327 /* **************************************************************** */
329 /* Utility Functions */
331 /* **************************************************************** */
335 dump_word_flags (flags)
341 fprintf (stderr, "%d -> ", f);
342 if (f & W_ASSIGNASSOC)
345 fprintf (stderr, "W_ASSIGNASSOC%s", f ? "|" : "");
347 if (f & W_ASSIGNARRAY)
350 fprintf (stderr, "W_ASSIGNARRAY%s", f ? "|" : "");
355 fprintf (stderr, "W_HASCTLESC%s", f ? "|" : "");
360 fprintf (stderr, "W_NOPROCSUB%s", f ? "|" : "");
365 fprintf (stderr, "W_DQUOTE%s", f ? "|" : "");
367 if (f & W_HASQUOTEDNULL)
369 f &= ~W_HASQUOTEDNULL;
370 fprintf (stderr, "W_HASQUOTEDNULL%s", f ? "|" : "");
375 fprintf (stderr, "W_ASSIGNARG%s", f ? "|" : "");
380 fprintf (stderr, "W_ASSNBLTIN%s", f ? "|" : "");
382 if (f & W_ASSNGLOBAL)
385 fprintf (stderr, "W_ASSNGLOBAL%s", f ? "|" : "");
390 fprintf (stderr, "W_ASSIGNINT%s", f ? "|" : "");
392 if (f & W_COMPASSIGN)
395 fprintf (stderr, "W_COMPASSIGN%s", f ? "|" : "");
400 fprintf (stderr, "W_NOEXPAND%s", f ? "|" : "");
405 fprintf (stderr, "W_ITILDE%s", f ? "|" : "");
410 fprintf (stderr, "W_NOTILDE%s", f ? "|" : "");
415 fprintf (stderr, "W_ASSIGNRHS%s", f ? "|" : "");
420 fprintf (stderr, "W_NOCOMSUB%s", f ? "|" : "");
422 if (f & W_DOLLARSTAR)
425 fprintf (stderr, "W_DOLLARSTAR%s", f ? "|" : "");
430 fprintf (stderr, "W_DOLLARAT%s", f ? "|" : "");
435 fprintf (stderr, "W_TILDEEXP%s", f ? "|" : "");
440 fprintf (stderr, "W_NOSPLIT2%s", f ? "|" : "");
445 fprintf (stderr, "W_NOSPLIT%s", f ? "|" : "");
450 fprintf (stderr, "W_NOBRACE%s", f ? "|" : "");
455 fprintf (stderr, "W_NOGLOB%s", f ? "|" : "");
457 if (f & W_SPLITSPACE)
460 fprintf (stderr, "W_SPLITSPACE%s", f ? "|" : "");
462 if (f & W_ASSIGNMENT)
465 fprintf (stderr, "W_ASSIGNMENT%s", f ? "|" : "");
470 fprintf (stderr, "W_QUOTED%s", f ? "|" : "");
475 fprintf (stderr, "W_HASDOLLAR%s", f ? "|" : "");
477 fprintf (stderr, "\n");
482 #ifdef INCLUDE_UNUSED
484 quoted_substring (string, start, end)
489 register char *result, *s, *r;
493 /* Move to string[start], skipping quoted characters. */
494 for (s = string, l = 0; *s && l < start; )
506 r = result = (char *)xmalloc (2*len + 1); /* save room for quotes */
508 /* Copy LEN characters, including quote characters. */
510 for (l = 0; l < len; s++)
524 #ifdef INCLUDE_UNUSED
525 /* Return the length of S, skipping over quoted characters */
549 /* Find the first occurrence of character C in string S, obeying shell
550 quoting rules. If (FLAGS & ST_BACKSL) is non-zero, backslash-escaped
551 characters are skipped. If (FLAGS & ST_CTLESC) is non-zero, characters
552 escaped with CTLESC are skipped. */
554 quoted_strchr (s, c, flags)
562 if (((flags & ST_BACKSL) && *p == '\\')
563 || ((flags & ST_CTLESC) && *p == CTLESC))
567 return ((char *)NULL);
573 return ((char *)NULL);
576 /* Return 1 if CHARACTER appears in an unquoted portion of
577 STRING. Return 0 otherwise. CHARACTER must be a single-byte character. */
579 unquoted_member (character, string)
587 slen = strlen (string);
589 while (c = string[sindex])
597 ADVANCE_CHAR (string, slen, sindex);
603 ADVANCE_CHAR (string, slen, sindex);
607 sindex = skip_single_quoted (string, slen, ++sindex);
611 sindex = skip_double_quoted (string, slen, ++sindex);
618 /* Return 1 if SUBSTR appears in an unquoted portion of STRING. */
620 unquoted_substring (substr, string)
621 char *substr, *string;
624 int sindex, c, sublen;
627 if (substr == 0 || *substr == '\0')
630 slen = strlen (string);
631 sublen = strlen (substr);
632 for (sindex = 0; c = string[sindex]; )
634 if (STREQN (string + sindex, substr, sublen))
642 ADVANCE_CHAR (string, slen, sindex);
646 sindex = skip_single_quoted (string, slen, ++sindex);
650 sindex = skip_double_quoted (string, slen, ++sindex);
654 ADVANCE_CHAR (string, slen, sindex);
661 /* Most of the substitutions must be done in parallel. In order
662 to avoid using tons of unclear goto's, I have some functions
663 for manipulating malloc'ed strings. They all take INDX, a
664 pointer to an integer which is the offset into the string
665 where manipulation is taking place. They also take SIZE, a
666 pointer to an integer which is the current length of the
667 character array for this string. */
669 /* Append SOURCE to TARGET at INDEX. SIZE is the current amount
670 of space allocated to TARGET. SOURCE can be NULL, in which
671 case nothing happens. Gets rid of SOURCE by freeing it.
672 Returns TARGET in case the location has changed. */
674 sub_append_string (source, target, indx, size)
675 char *source, *target;
682 srclen = STRLEN (source);
683 if (srclen >= (int)(*size - *indx))
686 n = (n + DEFAULT_ARRAY_SIZE) - (n % DEFAULT_ARRAY_SIZE);
687 target = (char *)xrealloc (target, (*size = n));
690 FASTCOPY (source, target + *indx, srclen);
692 target[*indx] = '\0';
701 /* Append the textual representation of NUMBER to TARGET.
702 INDX and SIZE are as in SUB_APPEND_STRING. */
704 sub_append_number (number, target, indx, size)
711 temp = itos (number);
712 return (sub_append_string (temp, target, indx, size));
716 /* Extract a substring from STRING, starting at SINDEX and ending with
717 one of the characters in CHARLIST. Don't make the ending character
718 part of the string. Leave SINDEX pointing at the ending character.
719 Understand about backslashes in the string. If (flags & SX_VARNAME)
720 is non-zero, and array variables have been compiled into the shell,
721 everything between a `[' and a corresponding `]' is skipped over.
722 If (flags & SX_NOALLOC) is non-zero, don't return the substring, just
723 update SINDEX. If (flags & SX_REQMATCH) is non-zero, the string must
724 contain a closing character from CHARLIST. */
726 string_extract (string, sindex, charlist, flags)
738 slen = (MB_CUR_MAX > 1) ? strlen (string + *sindex) + *sindex : 0;
741 while (c = string[i])
750 #if defined (ARRAY_VARS)
751 else if ((flags & SX_VARNAME) && c == '[')
754 /* If this is an array subscript, skip over it and continue. */
755 ni = skipsubscript (string, i, 0);
756 if (string[ni] == ']')
760 else if (MEMBER (c, charlist))
766 ADVANCE_CHAR (string, slen, i);
769 /* If we had to have a matching delimiter and didn't find one, return an
770 error and let the caller deal with it. */
771 if ((flags & SX_REQMATCH) && found == 0)
774 return (&extract_string_error);
777 temp = (flags & SX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
783 /* Extract the contents of STRING as if it is enclosed in double quotes.
784 SINDEX, when passed in, is the offset of the character immediately
785 following the opening double quote; on exit, SINDEX is left pointing after
786 the closing double quote. If STRIPDQ is non-zero, unquoted double
787 quotes are stripped and the string is terminated by a null byte.
788 Backslashes between the embedded double quotes are processed. If STRIPDQ
789 is zero, an unquoted `"' terminates the string. */
791 string_extract_double_quoted (string, sindex, stripdq)
793 int *sindex, stripdq;
799 char *temp, *ret; /* The new string we return. */
800 int pass_next, backquote, si; /* State variables for the machine. */
804 slen = strlen (string + *sindex) + *sindex;
805 send = string + slen;
807 pass_next = backquote = dquote = 0;
808 temp = (char *)xmalloc (1 + slen - *sindex);
812 while (c = string[i])
814 /* Process a character that was quoted by a backslash. */
817 /* XXX - take another look at this in light of Interp 221 */
820 ``The backslash shall retain its special meaning as an escape
821 character only when followed by one of the characters:
824 If STRIPDQ is zero, we handle the double quotes here and let
825 expand_word_internal handle the rest. If STRIPDQ is non-zero,
826 we have already been through one round of backslash stripping,
827 and want to strip these backslashes only if DQUOTE is non-zero,
828 indicating that we are inside an embedded double-quoted string. */
830 /* If we are in an embedded quoted string, then don't strip
831 backslashes before characters for which the backslash
832 retains its special meaning, but remove backslashes in
833 front of other characters. If we are not in an
834 embedded quoted string, don't strip backslashes at all.
835 This mess is necessary because the string was already
836 surrounded by double quotes (and sh has some really weird
838 The returned string will be run through expansion as if
839 it were double-quoted. */
840 if ((stripdq == 0 && c != '"') ||
841 (stripdq && ((dquote && (sh_syntaxtab[c] & CBSDQUOTE)) || dquote == 0)))
846 COPY_CHAR_I (temp, j, string, send, i);
850 /* A backslash protects the next character. The code just above
851 handles preserving the backslash in front of any character but
860 /* Inside backquotes, ``the portion of the quoted string from the
861 initial backquote and the characters up to the next backquote
862 that is not preceded by a backslash, having escape characters
863 removed, defines that command''. */
881 /* Pass everything between `$(' and the matching `)' or a quoted
882 ${ ... } pair through according to the Posix.2 specification. */
883 if (c == '$' && ((string[i + 1] == LPAREN) || (string[i + 1] == LBRACE)))
888 if (string[i + 1] == LPAREN)
889 ret = extract_command_subst (string, &si, 0);
891 ret = extract_dollar_brace_string (string, &si, Q_DOUBLE_QUOTES, 0);
894 temp[j++] = string[i + 1];
896 /* Just paranoia; ret will not be 0 unless no_longjmp_on_fatal_error
898 if (ret == 0 && no_longjmp_on_fatal_error)
901 ret = string + i + 2;
904 for (t = 0; ret[t]; t++, j++)
906 temp[j] = string[si];
921 /* Add any character but a double quote to the quoted string we're
924 goto add_one_character;
938 /* Point to after the closing quote. */
946 /* This should really be another option to string_extract_double_quoted. */
948 skip_double_quoted (string, slen, sind)
955 int pass_next, backquote, si;
958 pass_next = backquote = 0;
960 while (c = string[i])
965 ADVANCE_CHAR (string, slen, i);
978 ADVANCE_CHAR (string, slen, i);
987 else if (c == '$' && ((string[i + 1] == LPAREN) || (string[i + 1] == LBRACE)))
990 if (string[i + 1] == LPAREN)
991 ret = extract_command_subst (string, &si, SX_NOALLOC);
993 ret = extract_dollar_brace_string (string, &si, Q_DOUBLE_QUOTES, SX_NOALLOC);
1000 ADVANCE_CHAR (string, slen, i);
1013 /* Extract the contents of STRING as if it is enclosed in single quotes.
1014 SINDEX, when passed in, is the offset of the character immediately
1015 following the opening single quote; on exit, SINDEX is left pointing after
1016 the closing single quote. */
1017 static inline char *
1018 string_extract_single_quoted (string, sindex)
1027 /* Don't need slen for ADVANCE_CHAR unless multibyte chars possible. */
1028 slen = (MB_CUR_MAX > 1) ? strlen (string + *sindex) + *sindex : 0;
1030 while (string[i] && string[i] != '\'')
1031 ADVANCE_CHAR (string, slen, i);
1033 t = substring (string, *sindex, i);
1043 skip_single_quoted (string, slen, sind)
1052 while (string[c] && string[c] != '\'')
1053 ADVANCE_CHAR (string, slen, c);
1060 /* Just like string_extract, but doesn't hack backslashes or any of
1061 that other stuff. Obeys CTLESC quoting. Used to do splitting on $IFS. */
1063 string_extract_verbatim (string, slen, sindex, charlist, flags)
1071 #if defined (HANDLE_MULTIBYTE)
1079 if (charlist[0] == '\'' && charlist[1] == '\0')
1081 temp = string_extract_single_quoted (string, sindex);
1082 --*sindex; /* leave *sindex at separator character */
1088 /* See how the MBLEN and ADVANCE_CHAR macros work to understand why we need
1089 this only if MB_CUR_MAX > 1. */
1090 slen = (MB_CUR_MAX > 1) ? strlen (string + *sindex) + *sindex : 1;
1092 #if defined (HANDLE_MULTIBYTE)
1093 clen = strlen (charlist);
1096 while (c = string[i])
1098 #if defined (HANDLE_MULTIBYTE)
1101 if ((flags & SX_NOCTLESC) == 0 && c == CTLESC)
1106 /* Even if flags contains SX_NOCTLESC, we let CTLESC quoting CTLNUL
1107 through, to protect the CTLNULs from later calls to
1108 remove_quoted_nulls. */
1109 else if ((flags & SX_NOESCCTLNUL) == 0 && c == CTLESC && string[i+1] == CTLNUL)
1115 #if defined (HANDLE_MULTIBYTE)
1116 mblength = MBLEN (string + i, slen - i);
1120 mblength = mbtowc (&wc, string + i, slen - i);
1121 if (MB_INVALIDCH (mblength))
1123 if (MEMBER (c, charlist))
1131 len = mbstowcs (wcharlist, charlist, 0);
1134 wcharlist = (wchar_t *)xmalloc (sizeof (wchar_t) * (len + 1));
1135 mbstowcs (wcharlist, charlist, len + 1);
1138 if (wcschr (wcharlist, wc))
1144 if (MEMBER (c, charlist))
1147 ADVANCE_CHAR (string, slen, i);
1150 #if defined (HANDLE_MULTIBYTE)
1154 temp = substring (string, *sindex, i);
1160 /* Extract the $( construct in STRING, and return a new string.
1161 Start extracting at (SINDEX) as if we had just seen "$(".
1162 Make (SINDEX) get the position of the matching ")". )
1163 XFLAGS is additional flags to pass to other extraction functions. */
1165 extract_command_subst (string, sindex, xflags)
1170 if (string[*sindex] == LPAREN)
1171 return (extract_delimited_string (string, sindex, "$(", "(", ")", xflags|SX_COMMAND)); /*)*/
1174 xflags |= (no_longjmp_on_fatal_error ? SX_NOLONGJMP : 0);
1175 return (xparse_dolparen (string, string+*sindex, sindex, xflags));
1179 /* Extract the $[ construct in STRING, and return a new string. (])
1180 Start extracting at (SINDEX) as if we had just seen "$[".
1181 Make (SINDEX) get the position of the matching "]". */
1183 extract_arithmetic_subst (string, sindex)
1187 return (extract_delimited_string (string, sindex, "$[", "[", "]", 0)); /*]*/
1190 #if defined (PROCESS_SUBSTITUTION)
1191 /* Extract the <( or >( construct in STRING, and return a new string.
1192 Start extracting at (SINDEX) as if we had just seen "<(".
1193 Make (SINDEX) get the position of the matching ")". */ /*))*/
1195 extract_process_subst (string, starter, sindex)
1200 return (extract_delimited_string (string, sindex, starter, "(", ")", SX_COMMAND));
1202 #endif /* PROCESS_SUBSTITUTION */
1204 #if defined (ARRAY_VARS)
1205 /* This can be fooled by unquoted right parens in the passed string. If
1206 each caller verifies that the last character in STRING is a right paren,
1207 we don't even need to call extract_delimited_string. */
1209 extract_array_assignment_list (string, sindex)
1216 slen = strlen (string); /* ( */
1217 if (string[slen - 1] == ')')
1219 ret = substring (string, *sindex, slen - 1);
1227 /* Extract and create a new string from the contents of STRING, a
1228 character string delimited with OPENER and CLOSER. SINDEX is
1229 the address of an int describing the current offset in STRING;
1230 it should point to just after the first OPENER found. On exit,
1231 SINDEX gets the position of the last character of the matching CLOSER.
1232 If OPENER is more than a single character, ALT_OPENER, if non-null,
1233 contains a character string that can also match CLOSER and thus
1234 needs to be skipped. */
1236 extract_delimited_string (string, sindex, opener, alt_opener, closer, flags)
1239 char *opener, *alt_opener, *closer;
1245 int pass_character, nesting_level, in_comment;
1246 int len_closer, len_opener, len_alt_opener;
1249 slen = strlen (string + *sindex) + *sindex;
1250 len_opener = STRLEN (opener);
1251 len_alt_opener = STRLEN (alt_opener);
1252 len_closer = STRLEN (closer);
1254 pass_character = in_comment = 0;
1259 while (nesting_level)
1270 ADVANCE_CHAR (string, slen, i);
1274 if (pass_character) /* previous char was backslash */
1277 ADVANCE_CHAR (string, slen, i);
1281 /* Not exactly right yet; should handle shell metacharacters and
1282 multibyte characters, too. See COMMENT_BEGIN define in parse.y */
1283 if ((flags & SX_COMMAND) && c == '#' && (i == 0 || string[i - 1] == '\n' || shellblank (string[i - 1])))
1286 ADVANCE_CHAR (string, slen, i);
1290 if (c == CTLESC || c == '\\')
1297 /* Process a nested command substitution, but only if we're parsing an
1298 arithmetic substitution. */
1299 if ((flags & SX_COMMAND) && string[i] == '$' && string[i+1] == LPAREN)
1302 t = extract_command_subst (string, &si, flags|SX_NOALLOC);
1307 /* Process a nested OPENER. */
1308 if (STREQN (string + i, opener, len_opener))
1310 si = i + len_opener;
1311 t = extract_delimited_string (string, &si, opener, alt_opener, closer, flags|SX_NOALLOC);
1316 /* Process a nested ALT_OPENER */
1317 if (len_alt_opener && STREQN (string + i, alt_opener, len_alt_opener))
1319 si = i + len_alt_opener;
1320 t = extract_delimited_string (string, &si, alt_opener, alt_opener, closer, flags|SX_NOALLOC);
1325 /* If the current substring terminates the delimited string, decrement
1326 the nesting level. */
1327 if (STREQN (string + i, closer, len_closer))
1329 i += len_closer - 1; /* move to last byte of the closer */
1331 if (nesting_level == 0)
1335 /* Pass old-style command substitution through verbatim. */
1339 t = string_extract (string, &si, "`", flags|SX_NOALLOC);
1344 /* Pass single-quoted and double-quoted strings through verbatim. */
1345 if (c == '\'' || c == '"')
1348 i = (c == '\'') ? skip_single_quoted (string, slen, si)
1349 : skip_double_quoted (string, slen, si);
1353 /* move past this character, which was not special. */
1354 ADVANCE_CHAR (string, slen, i);
1357 if (c == 0 && nesting_level)
1359 if (no_longjmp_on_fatal_error == 0)
1361 last_command_exit_value = EXECUTION_FAILURE;
1362 report_error (_("bad substitution: no closing `%s' in %s"), closer, string);
1363 exp_jump_to_top_level (DISCARD);
1368 return (char *)NULL;
1372 si = i - *sindex - len_closer + 1;
1373 if (flags & SX_NOALLOC)
1374 result = (char *)NULL;
1377 result = (char *)xmalloc (1 + si);
1378 strncpy (result, string + *sindex, si);
1386 /* Extract a parameter expansion expression within ${ and } from STRING.
1387 Obey the Posix.2 rules for finding the ending `}': count braces while
1388 skipping over enclosed quoted strings and command substitutions.
1389 SINDEX is the address of an int describing the current offset in STRING;
1390 it should point to just after the first `{' found. On exit, SINDEX
1391 gets the position of the matching `}'. QUOTED is non-zero if this
1392 occurs inside double quotes. */
1393 /* XXX -- this is very similar to extract_delimited_string -- XXX */
1395 extract_dollar_brace_string (string, sindex, quoted, flags)
1397 int *sindex, quoted, flags;
1401 int pass_character, nesting_level, si, dolbrace_state;
1407 slen = strlen (string + *sindex) + *sindex;
1409 /* The handling of dolbrace_state needs to agree with the code in parse.y:
1410 parse_matched_pair(). The different initial value is to handle the
1411 case where this function is called to parse the word in
1412 ${param op word} (SX_WORD). */
1413 dolbrace_state = (flags & SX_WORD) ? DOLBRACE_WORD : DOLBRACE_PARAM;
1414 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && (flags & SX_POSIXEXP))
1415 dolbrace_state = DOLBRACE_QUOTE;
1418 while (c = string[i])
1423 ADVANCE_CHAR (string, slen, i);
1427 /* CTLESCs and backslashes quote the next character. */
1428 if (c == CTLESC || c == '\\')
1435 if (string[i] == '$' && string[i+1] == LBRACE)
1445 if (nesting_level == 0)
1451 /* Pass the contents of old-style command substitutions through
1456 t = string_extract (string, &si, "`", flags|SX_NOALLOC);
1461 /* Pass the contents of new-style command substitutions and
1462 arithmetic substitutions through verbatim. */
1463 if (string[i] == '$' && string[i+1] == LPAREN)
1466 t = extract_command_subst (string, &si, flags|SX_NOALLOC);
1471 /* Pass the contents of double-quoted strings through verbatim. */
1475 i = skip_double_quoted (string, slen, si);
1476 /* skip_XXX_quoted leaves index one past close quote */
1482 /*itrace("extract_dollar_brace_string: c == single quote flags = %d quoted = %d dolbrace_state = %d", flags, quoted, dolbrace_state);*/
1483 if (posixly_correct && shell_compatibility_level > 42 && dolbrace_state != DOLBRACE_QUOTE && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
1484 ADVANCE_CHAR (string, slen, i);
1488 i = skip_single_quoted (string, slen, si);
1494 /* move past this character, which was not special. */
1495 ADVANCE_CHAR (string, slen, i);
1497 /* This logic must agree with parse.y:parse_matched_pair, since they
1498 share the same defines. */
1499 if (dolbrace_state == DOLBRACE_PARAM && c == '%' && (i - *sindex) > 1)
1500 dolbrace_state = DOLBRACE_QUOTE;
1501 else if (dolbrace_state == DOLBRACE_PARAM && c == '#' && (i - *sindex) > 1)
1502 dolbrace_state = DOLBRACE_QUOTE;
1503 else if (dolbrace_state == DOLBRACE_PARAM && c == '/' && (i - *sindex) > 1)
1504 dolbrace_state = DOLBRACE_QUOTE2; /* XXX */
1505 else if (dolbrace_state == DOLBRACE_PARAM && c == '^' && (i - *sindex) > 1)
1506 dolbrace_state = DOLBRACE_QUOTE;
1507 else if (dolbrace_state == DOLBRACE_PARAM && c == ',' && (i - *sindex) > 1)
1508 dolbrace_state = DOLBRACE_QUOTE;
1509 else if (dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", c) != 0)
1510 dolbrace_state = DOLBRACE_OP;
1511 else if (dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", c) == 0)
1512 dolbrace_state = DOLBRACE_WORD;
1515 if (c == 0 && nesting_level)
1517 if (no_longjmp_on_fatal_error == 0)
1519 last_command_exit_value = EXECUTION_FAILURE;
1520 report_error (_("bad substitution: no closing `%s' in %s"), "}", string);
1521 exp_jump_to_top_level (DISCARD);
1526 return ((char *)NULL);
1530 result = (flags & SX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
1536 /* Remove backslashes which are quoting backquotes from STRING. Modifies
1537 STRING, and returns a pointer to it. */
1539 de_backslash (string)
1542 register size_t slen;
1543 register int i, j, prev_i;
1546 slen = strlen (string);
1549 /* Loop copying string[i] to string[j], i >= j. */
1552 if (string[i] == '\\' && (string[i + 1] == '`' || string[i + 1] == '\\' ||
1553 string[i + 1] == '$'))
1556 ADVANCE_CHAR (string, slen, i);
1558 do string[j++] = string[prev_i++]; while (prev_i < i);
1569 /* Replace instances of \! in a string with !. */
1571 unquote_bang (string)
1575 register char *temp;
1577 temp = (char *)xmalloc (1 + strlen (string));
1579 for (i = 0, j = 0; (temp[j] = string[i]); i++, j++)
1581 if (string[i] == '\\' && string[i + 1] == '!')
1587 strcpy (string, temp);
1592 #define CQ_RETURN(x) do { no_longjmp_on_fatal_error = 0; return (x); } while (0)
1594 /* This function assumes s[i] == open; returns with s[ret] == close; used to
1595 parse array subscripts. FLAGS & 1 means to not attempt to skip over
1596 matched pairs of quotes or backquotes, or skip word expansions; it is
1597 intended to be used after expansion has been performed and during final
1598 assignment parsing (see arrayfunc.c:assign_compound_array_list()). */
1600 skip_matched_pair (string, start, open, close, flags)
1602 int start, open, close, flags;
1604 int i, pass_next, backq, si, c, count;
1609 slen = strlen (string + start) + start;
1610 no_longjmp_on_fatal_error = 1;
1612 i = start + 1; /* skip over leading bracket */
1614 pass_next = backq = 0;
1615 ss = (char *)string;
1616 while (c = string[i])
1623 ADVANCE_CHAR (string, slen, i);
1636 ADVANCE_CHAR (string, slen, i);
1639 else if ((flags & 1) == 0 && c == '`')
1645 else if ((flags & 1) == 0 && c == open)
1651 else if (c == close)
1659 else if ((flags & 1) == 0 && (c == '\'' || c == '"'))
1661 i = (c == '\'') ? skip_single_quoted (ss, slen, ++i)
1662 : skip_double_quoted (ss, slen, ++i);
1663 /* no increment, the skip functions increment past the closing quote. */
1665 else if ((flags&1) == 0 && c == '$' && (string[i+1] == LPAREN || string[i+1] == LBRACE))
1668 if (string[si] == '\0')
1671 if (string[i+1] == LPAREN)
1672 temp = extract_delimited_string (ss, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND); /* ) */
1674 temp = extract_dollar_brace_string (ss, &si, 0, SX_NOALLOC);
1676 if (string[i] == '\0') /* don't increment i past EOS in loop */
1682 ADVANCE_CHAR (string, slen, i);
1688 #if defined (ARRAY_VARS)
1690 skipsubscript (string, start, flags)
1694 return (skip_matched_pair (string, start, '[', ']', flags));
1698 /* Skip characters in STRING until we find a character in DELIMS, and return
1699 the index of that character. START is the index into string at which we
1700 begin. This is similar in spirit to strpbrk, but it returns an index into
1701 STRING and takes a starting index. This little piece of code knows quite
1702 a lot of shell syntax. It's very similar to skip_double_quoted and other
1703 functions of that ilk. */
1705 skip_to_delim (string, start, delims, flags)
1711 int i, pass_next, backq, si, c, invert, skipquote, skipcmd;
1713 char *temp, open[3];
1716 slen = strlen (string + start) + start;
1717 if (flags & SD_NOJMP)
1718 no_longjmp_on_fatal_error = 1;
1719 invert = (flags & SD_INVERT);
1720 skipcmd = (flags & SD_NOSKIPCMD) == 0;
1723 pass_next = backq = 0;
1724 while (c = string[i])
1726 /* If this is non-zero, we should not let quote characters be delimiters
1727 and the current character is a single or double quote. We should not
1728 test whether or not it's a delimiter until after we skip single- or
1729 double-quoted strings. */
1730 skipquote = ((flags & SD_NOQUOTEDELIM) && (c == '\'' || c =='"'));
1736 ADVANCE_CHAR (string, slen, i);
1749 ADVANCE_CHAR (string, slen, i);
1758 else if (skipquote == 0 && invert == 0 && member (c, delims))
1760 else if (c == '\'' || c == '"')
1762 i = (c == '\'') ? skip_single_quoted (string, slen, ++i)
1763 : skip_double_quoted (string, slen, ++i);
1764 /* no increment, the skip functions increment past the closing quote. */
1766 else if (c == '$' && ((skipcmd && string[i+1] == LPAREN) || string[i+1] == LBRACE))
1769 if (string[si] == '\0')
1772 if (string[i+1] == LPAREN)
1773 temp = extract_delimited_string (string, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND); /* ) */
1775 temp = extract_dollar_brace_string (string, &si, 0, SX_NOALLOC);
1777 if (string[i] == '\0') /* don't increment i past EOS in loop */
1782 #if defined (PROCESS_SUBSTITUTION)
1783 else if (skipcmd && (c == '<' || c == '>') && string[i+1] == LPAREN)
1786 if (string[si] == '\0')
1788 temp = extract_process_subst (string, (c == '<') ? "<(" : ">(", &si);
1789 free (temp); /* no SX_ALLOC here */
1791 if (string[i] == '\0')
1796 #endif /* PROCESS_SUBSTITUTION */
1797 #if defined (EXTENDED_GLOB)
1798 else if ((flags & SD_EXTGLOB) && extended_glob && string[i+1] == LPAREN && member (c, "?*+!@"))
1801 if (string[si] == '\0')
1807 temp = extract_delimited_string (string, &si, open, "(", ")", SX_NOALLOC); /* ) */
1810 if (string[i] == '\0') /* don't increment i past EOS in loop */
1816 else if ((flags & SD_GLOB) && c == LBRACK)
1819 if (string[si] == '\0')
1822 temp = extract_delimited_string (string, &si, "[", "[", "]", SX_NOALLOC); /* ] */
1825 if (string[i] == '\0') /* don't increment i past EOS in loop */
1830 else if ((skipquote || invert) && (member (c, delims) == 0))
1833 ADVANCE_CHAR (string, slen, i);
1839 #if defined (READLINE)
1840 /* Return 1 if the portion of STRING ending at EINDEX is quoted (there is
1841 an unclosed quoted string), or if the character at EINDEX is quoted
1842 by a backslash. NO_LONGJMP_ON_FATAL_ERROR is used to flag that the various
1843 single and double-quoted string parsing functions should not return an
1844 error if there are unclosed quotes or braces. The characters that this
1845 recognizes need to be the same as the contents of
1846 rl_completer_quote_characters. */
1849 char_is_quoted (string, eindex)
1853 int i, pass_next, c;
1857 slen = strlen (string);
1858 no_longjmp_on_fatal_error = 1;
1867 if (i >= eindex) /* XXX was if (i >= eindex - 1) */
1869 ADVANCE_CHAR (string, slen, i);
1878 else if (c == '\'' || c == '"')
1880 i = (c == '\'') ? skip_single_quoted (string, slen, ++i)
1881 : skip_double_quoted (string, slen, ++i);
1884 /* no increment, the skip_xxx functions go one past end */
1887 ADVANCE_CHAR (string, slen, i);
1894 unclosed_pair (string, eindex, openstr)
1899 int i, pass_next, openc, olen;
1903 slen = strlen (string);
1904 olen = strlen (openstr);
1905 i = pass_next = openc = 0;
1911 if (i >= eindex) /* XXX was if (i >= eindex - 1) */
1913 ADVANCE_CHAR (string, slen, i);
1916 else if (string[i] == '\\')
1922 else if (STREQN (string + i, openstr, olen))
1927 else if (string[i] == '\'' || string[i] == '"')
1929 i = (string[i] == '\'') ? skip_single_quoted (string, slen, i)
1930 : skip_double_quoted (string, slen, i);
1935 ADVANCE_CHAR (string, slen, i);
1940 /* Split STRING (length SLEN) at DELIMS, and return a WORD_LIST with the
1941 individual words. If DELIMS is NULL, the current value of $IFS is used
1942 to split the string, and the function follows the shell field splitting
1943 rules. SENTINEL is an index to look for. NWP, if non-NULL,
1944 gets the number of words in the returned list. CWP, if non-NULL, gets
1945 the index of the word containing SENTINEL. Non-whitespace chars in
1946 DELIMS delimit separate fields. */
1948 split_at_delims (string, slen, delims, sentinel, flags, nwp, cwp)
1952 int sentinel, flags;
1955 int ts, te, i, nw, cw, ifs_split, dflags;
1956 char *token, *d, *d2;
1957 WORD_LIST *ret, *tl;
1959 if (string == 0 || *string == '\0')
1965 return ((WORD_LIST *)NULL);
1968 d = (delims == 0) ? ifs_value : delims;
1969 ifs_split = delims == 0;
1971 /* Make d2 the non-whitespace characters in delims */
1976 #if defined (HANDLE_MULTIBYTE)
1977 size_t mblength = 1;
1981 slength = strlen (delims);
1982 d2 = (char *)xmalloc (slength + 1);
1986 #if defined (HANDLE_MULTIBYTE)
1987 mbstate_t state_bak;
1989 mblength = MBRLEN (delims + i, slength, &state);
1990 if (MB_INVALIDCH (mblength))
1992 else if (mblength > 1)
1994 memcpy (d2 + ts, delims + i, mblength);
1997 slength -= mblength;
2001 if (whitespace (delims[i]) == 0)
2002 d2[ts++] = delims[i];
2010 ret = (WORD_LIST *)NULL;
2012 /* Remove sequences of whitespace characters at the start of the string, as
2013 long as those characters are delimiters. */
2014 for (i = 0; member (string[i], d) && spctabnl (string[i]); i++)
2016 if (string[i] == '\0')
2022 dflags = flags|SD_NOJMP;
2025 te = skip_to_delim (string, ts, d, dflags);
2027 /* If we have a non-whitespace delimiter character, use it to make a
2028 separate field. This is just about what $IFS splitting does and
2029 is closer to the behavior of the shell parser. */
2030 if (ts == te && d2 && member (string[ts], d2))
2033 /* If we're using IFS splitting, the non-whitespace delimiter char
2034 and any additional IFS whitespace delimits a field. */
2036 while (member (string[te], d) && spctabnl (string[te]))
2039 while (member (string[te], d2))
2043 token = substring (string, ts, te);
2045 ret = add_string_to_list (token, ret);
2049 if (sentinel >= ts && sentinel <= te)
2052 /* If the cursor is at whitespace just before word start, set the
2053 sentinel word to the current word. */
2054 if (cwp && cw == -1 && sentinel == ts-1)
2057 /* If the cursor is at whitespace between two words, make a new, empty
2058 word, add it before (well, after, since the list is in reverse order)
2059 the word we just added, and set the current word to that one. */
2060 if (cwp && cw == -1 && sentinel < ts)
2062 tl = make_word_list (make_word (""), ret->next);
2068 if (string[te] == 0)
2072 while (member (string[i], d) && (ifs_split || spctabnl(string[i])))
2081 /* Special case for SENTINEL at the end of STRING. If we haven't found
2082 the word containing SENTINEL yet, and the index we're looking for is at
2083 the end of STRING (or past the end of the previously-found token,
2084 possible if the end of the line is composed solely of IFS whitespace)
2085 add an additional null argument and set the current word pointer to that. */
2086 if (cwp && cw == -1 && (sentinel >= slen || sentinel >= te))
2088 if (whitespace (string[sentinel - 1]))
2091 ret = add_string_to_list (token, ret);
2104 return (REVERSE_LIST (ret, WORD_LIST *));
2106 #endif /* READLINE */
2110 /* Extract the name of the variable to bind to from the assignment string. */
2112 assignment_name (string)
2118 offset = assignment (string, 0);
2120 return (char *)NULL;
2121 temp = substring (string, 0, offset);
2126 /* **************************************************************** */
2128 /* Functions to convert strings to WORD_LISTs and vice versa */
2130 /* **************************************************************** */
2132 /* Return a single string of all the words in LIST. SEP is the separator
2133 to put between individual elements of LIST in the output string. */
2135 string_list_internal (list, sep)
2139 register WORD_LIST *t;
2141 int word_len, sep_len, result_size;
2144 return ((char *)NULL);
2146 /* Short-circuit quickly if we don't need to separate anything. */
2147 if (list->next == 0)
2148 return (savestring (list->word->word));
2150 /* This is nearly always called with either sep[0] == 0 or sep[1] == 0. */
2151 sep_len = STRLEN (sep);
2154 for (t = list; t; t = t->next)
2157 result_size += sep_len;
2158 result_size += strlen (t->word->word);
2161 r = result = (char *)xmalloc (result_size + 1);
2163 for (t = list; t; t = t->next)
2165 if (t != list && sep_len)
2169 FASTCOPY (sep, r, sep_len);
2176 word_len = strlen (t->word->word);
2177 FASTCOPY (t->word->word, r, word_len);
2185 /* Return a single string of all the words present in LIST, separating
2186 each word with a space. */
2191 return (string_list_internal (list, " "));
2194 /* An external interface that can be used by the rest of the shell to
2195 obtain a string containing the first character in $IFS. Handles all
2196 the multibyte complications. If LENP is non-null, it is set to the
2197 length of the returned string. */
2199 ifs_firstchar (lenp)
2205 ret = xmalloc (MB_LEN_MAX + 1);
2206 #if defined (HANDLE_MULTIBYTE)
2207 if (ifs_firstc_len == 1)
2209 ret[0] = ifs_firstc[0];
2211 len = ret[0] ? 1 : 0;
2215 memcpy (ret, ifs_firstc, ifs_firstc_len);
2216 ret[len = ifs_firstc_len] = '\0';
2219 ret[0] = ifs_firstc;
2221 len = ret[0] ? 0 : 1;
2230 /* Return a single string of all the words present in LIST, obeying the
2231 quoting rules for "$*", to wit: (P1003.2, draft 11, 3.5.2) "If the
2232 expansion [of $*] appears within a double quoted string, it expands
2233 to a single field with the value of each parameter separated by the
2234 first character of the IFS variable, or by a <space> if IFS is unset." */
2236 string_list_dollar_star (list)
2240 #if defined (HANDLE_MULTIBYTE)
2241 # if defined (__GNUC__)
2242 char sep[MB_CUR_MAX + 1];
2250 #if defined (HANDLE_MULTIBYTE)
2251 # if !defined (__GNUC__)
2252 sep = (char *)xmalloc (MB_CUR_MAX + 1);
2253 # endif /* !__GNUC__ */
2254 if (ifs_firstc_len == 1)
2256 sep[0] = ifs_firstc[0];
2261 memcpy (sep, ifs_firstc, ifs_firstc_len);
2262 sep[ifs_firstc_len] = '\0';
2265 sep[0] = ifs_firstc;
2269 ret = string_list_internal (list, sep);
2270 #if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
2276 /* Turn $@ into a string. If (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
2277 is non-zero, the $@ appears within double quotes, and we should quote
2278 the list before converting it into a string. If IFS is unset, and the
2279 word is not quoted, we just need to quote CTLESC and CTLNUL characters
2280 in the words in the list, because the default value of $IFS is
2281 <space><tab><newline>, IFS characters in the words in the list should
2282 also be split. If IFS is null, and the word is not quoted, we need
2283 to quote the words in the list to preserve the positional parameters
2286 string_list_dollar_at (list, quoted)
2291 #if defined (HANDLE_MULTIBYTE)
2292 # if defined (__GNUC__)
2293 char sep[MB_CUR_MAX + 1];
2296 # endif /* !__GNUC__ */
2302 /* XXX this could just be ifs = ifs_value; */
2303 ifs = ifs_var ? value_cell (ifs_var) : (char *)0;
2305 #if defined (HANDLE_MULTIBYTE)
2306 # if !defined (__GNUC__)
2307 sep = (char *)xmalloc (MB_CUR_MAX + 1);
2308 # endif /* !__GNUC__ */
2311 if (ifs_firstc_len == 1)
2313 sep[0] = ifs_firstc[0];
2318 memcpy (sep, ifs_firstc, ifs_firstc_len);
2319 sep[ifs_firstc_len] = '\0';
2328 sep[0] = (ifs == 0 || *ifs == 0) ? ' ' : *ifs;
2332 /* XXX -- why call quote_list if ifs == 0? we can get away without doing
2333 it now that quote_escapes quotes spaces */
2334 tlist = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES|Q_PATQUOTE))
2336 : list_quote_escapes (list);
2338 ret = string_list_internal (tlist, sep);
2339 #if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
2345 /* Turn the positional parameters into a string, understanding quoting and
2346 the various subtleties of using the first character of $IFS as the
2347 separator. Calls string_list_dollar_at, string_list_dollar_star, and
2348 string_list as appropriate. */
2350 string_list_pos_params (pchar, list, quoted)
2358 if (pchar == '*' && (quoted & Q_DOUBLE_QUOTES))
2360 tlist = quote_list (list);
2361 word_list_remove_quoted_nulls (tlist);
2362 ret = string_list_dollar_star (tlist);
2364 else if (pchar == '*' && (quoted & Q_HERE_DOCUMENT))
2366 tlist = quote_list (list);
2367 word_list_remove_quoted_nulls (tlist);
2368 ret = string_list (tlist);
2370 else if (pchar == '*')
2372 /* Even when unquoted, string_list_dollar_star does the right thing
2373 making sure that the first character of $IFS is used as the
2375 ret = string_list_dollar_star (list);
2377 else if (pchar == '@' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
2378 /* We use string_list_dollar_at, but only if the string is quoted, since
2379 that quotes the escapes if it's not, which we don't want. We could
2380 use string_list (the old code did), but that doesn't do the right
2381 thing if the first character of $IFS is not a space. We use
2382 string_list_dollar_star if the string is unquoted so we make sure that
2383 the elements of $@ are separated by the first character of $IFS for
2385 ret = string_list_dollar_at (list, quoted);
2386 else if (pchar == '@')
2387 ret = string_list_dollar_star (list);
2389 ret = string_list ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? quote_list (list) : list);
2394 /* Return the list of words present in STRING. Separate the string into
2395 words at any of the characters found in SEPARATORS. If QUOTED is
2396 non-zero then word in the list will have its quoted flag set, otherwise
2397 the quoted flag is left as make_word () deemed fit.
2399 This obeys the P1003.2 word splitting semantics. If `separators' is
2400 exactly <space><tab><newline>, then the splitting algorithm is that of
2401 the Bourne shell, which treats any sequence of characters from `separators'
2402 as a delimiter. If IFS is unset, which results in `separators' being set
2403 to "", no splitting occurs. If separators has some other value, the
2404 following rules are applied (`IFS white space' means zero or more
2405 occurrences of <space>, <tab>, or <newline>, as long as those characters
2406 are in `separators'):
2408 1) IFS white space is ignored at the start and the end of the
2410 2) Each occurrence of a character in `separators' that is not
2411 IFS white space, along with any adjacent occurrences of
2412 IFS white space delimits a field.
2413 3) Any nonzero-length sequence of IFS white space delimits a field.
2416 /* BEWARE! list_string strips null arguments. Don't call it twice and
2417 expect to have "" preserved! */
2419 /* This performs word splitting and quoted null character removal on
2422 (((separators)[0]) ? ((separators)[1] ? isifs(c) \
2423 : (c) == (separators)[0]) \
2427 list_string (string, separators, quoted)
2428 register char *string, *separators;
2433 char *current_word, *s;
2434 int sindex, sh_style_split, whitesep, xflags;
2437 if (!string || !*string)
2438 return ((WORD_LIST *)NULL);
2440 sh_style_split = separators && separators[0] == ' ' &&
2441 separators[1] == '\t' &&
2442 separators[2] == '\n' &&
2443 separators[3] == '\0';
2444 for (xflags = 0, s = ifs_value; s && *s; s++)
2446 if (*s == CTLESC) xflags |= SX_NOCTLESC;
2447 else if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;
2451 /* Remove sequences of whitespace at the beginning of STRING, as
2452 long as those characters appear in IFS. Do not do this if
2453 STRING is quoted or if there are no separator characters. */
2454 if (!quoted || !separators || !*separators)
2456 for (s = string; *s && spctabnl (*s) && issep (*s); s++);
2459 return ((WORD_LIST *)NULL);
2464 /* OK, now STRING points to a word that does not begin with white space.
2465 The splitting algorithm is:
2466 extract a word, stopping at a separator
2467 skip sequences of spc, tab, or nl as long as they are separators
2468 This obeys the field splitting rules in Posix.2. */
2469 slen = (MB_CUR_MAX > 1) ? strlen (string) : 1;
2470 for (result = (WORD_LIST *)NULL, sindex = 0; string[sindex]; )
2472 /* Don't need string length in ADVANCE_CHAR or string_extract_verbatim
2473 unless multibyte chars are possible. */
2474 current_word = string_extract_verbatim (string, slen, &sindex, separators, xflags);
2475 if (current_word == 0)
2478 /* If we have a quoted empty string, add a quoted null argument. We
2479 want to preserve the quoted null character iff this is a quoted
2480 empty string; otherwise the quoted null characters are removed
2482 if (QUOTED_NULL (current_word))
2484 t = alloc_word_desc ();
2485 t->word = make_quoted_char ('\0');
2486 t->flags |= W_QUOTED|W_HASQUOTEDNULL;
2487 result = make_word_list (t, result);
2489 else if (current_word[0] != '\0')
2491 /* If we have something, then add it regardless. However,
2492 perform quoted null character removal on the current word. */
2493 remove_quoted_nulls (current_word);
2494 result = add_string_to_list (current_word, result);
2495 result->word->flags &= ~W_HASQUOTEDNULL; /* just to be sure */
2496 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
2497 result->word->flags |= W_QUOTED;
2500 /* If we're not doing sequences of separators in the traditional
2501 Bourne shell style, then add a quoted null argument. */
2502 else if (!sh_style_split && !spctabnl (string[sindex]))
2504 t = alloc_word_desc ();
2505 t->word = make_quoted_char ('\0');
2506 t->flags |= W_QUOTED|W_HASQUOTEDNULL;
2507 result = make_word_list (t, result);
2510 free (current_word);
2512 /* Note whether or not the separator is IFS whitespace, used later. */
2513 whitesep = string[sindex] && spctabnl (string[sindex]);
2515 /* Move past the current separator character. */
2519 ADVANCE_CHAR (string, slen, sindex);
2522 /* Now skip sequences of space, tab, or newline characters if they are
2523 in the list of separators. */
2524 while (string[sindex] && spctabnl (string[sindex]) && issep (string[sindex]))
2527 /* If the first separator was IFS whitespace and the current character
2528 is a non-whitespace IFS character, it should be part of the current
2529 field delimiter, not a separate delimiter that would result in an
2530 empty field. Look at POSIX.2, 3.6.5, (3)(b). */
2531 if (string[sindex] && whitesep && issep (string[sindex]) && !spctabnl (string[sindex]))
2534 /* An IFS character that is not IFS white space, along with any
2535 adjacent IFS white space, shall delimit a field. (SUSv3) */
2536 while (string[sindex] && spctabnl (string[sindex]) && isifs (string[sindex]))
2540 return (REVERSE_LIST (result, WORD_LIST *));
2543 /* Parse a single word from STRING, using SEPARATORS to separate fields.
2544 ENDPTR is set to the first character after the word. This is used by
2545 the `read' builtin. This is never called with SEPARATORS != $IFS;
2546 it should be simplified.
2548 XXX - this function is very similar to list_string; they should be
2551 get_word_from_string (stringp, separators, endptr)
2552 char **stringp, *separators, **endptr;
2556 int sindex, sh_style_split, whitesep, xflags;
2559 if (!stringp || !*stringp || !**stringp)
2560 return ((char *)NULL);
2562 sh_style_split = separators && separators[0] == ' ' &&
2563 separators[1] == '\t' &&
2564 separators[2] == '\n' &&
2565 separators[3] == '\0';
2566 for (xflags = 0, s = ifs_value; s && *s; s++)
2568 if (*s == CTLESC) xflags |= SX_NOCTLESC;
2569 if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;
2575 /* Remove sequences of whitespace at the beginning of STRING, as
2576 long as those characters appear in IFS. */
2577 if (sh_style_split || !separators || !*separators)
2579 for (; *s && spctabnl (*s) && isifs (*s); s++);
2581 /* If the string is nothing but whitespace, update it and return. */
2587 return ((char *)NULL);
2591 /* OK, S points to a word that does not begin with white space.
2592 Now extract a word, stopping at a separator, save a pointer to
2593 the first character after the word, then skip sequences of spc,
2594 tab, or nl as long as they are separators.
2596 This obeys the field splitting rules in Posix.2. */
2598 /* Don't need string length in ADVANCE_CHAR or string_extract_verbatim
2599 unless multibyte chars are possible. */
2600 slen = (MB_CUR_MAX > 1) ? strlen (s) : 1;
2601 current_word = string_extract_verbatim (s, slen, &sindex, separators, xflags);
2603 /* Set ENDPTR to the first character after the end of the word. */
2605 *endptr = s + sindex;
2607 /* Note whether or not the separator is IFS whitespace, used later. */
2608 whitesep = s[sindex] && spctabnl (s[sindex]);
2610 /* Move past the current separator character. */
2614 ADVANCE_CHAR (s, slen, sindex);
2617 /* Now skip sequences of space, tab, or newline characters if they are
2618 in the list of separators. */
2619 while (s[sindex] && spctabnl (s[sindex]) && isifs (s[sindex]))
2622 /* If the first separator was IFS whitespace and the current character is
2623 a non-whitespace IFS character, it should be part of the current field
2624 delimiter, not a separate delimiter that would result in an empty field.
2625 Look at POSIX.2, 3.6.5, (3)(b). */
2626 if (s[sindex] && whitesep && isifs (s[sindex]) && !spctabnl (s[sindex]))
2629 /* An IFS character that is not IFS white space, along with any adjacent
2630 IFS white space, shall delimit a field. */
2631 while (s[sindex] && spctabnl (s[sindex]) && isifs (s[sindex]))
2635 /* Update STRING to point to the next field. */
2636 *stringp = s + sindex;
2637 return (current_word);
2640 /* Remove IFS white space at the end of STRING. Start at the end
2641 of the string and walk backwards until the beginning of the string
2642 or we find a character that's not IFS white space and not CTLESC.
2643 Only let CTLESC escape a white space character if SAW_ESCAPE is
2646 strip_trailing_ifs_whitespace (string, separators, saw_escape)
2647 char *string, *separators;
2652 s = string + STRLEN (string) - 1;
2653 while (s > string && ((spctabnl (*s) && isifs (*s)) ||
2654 (saw_escape && *s == CTLESC && spctabnl (s[1]))))
2662 /* Split STRING into words at whitespace. Obeys shell-style quoting with
2663 backslashes, single and double quotes. */
2665 list_string_with_quotes (string)
2671 int c, i, tokstart, len;
2673 for (s = string; s && *s && spctabnl (*s); s++)
2675 if (s == 0 || *s == 0)
2676 return ((WORD_LIST *)NULL);
2680 list = (WORD_LIST *)NULL;
2691 i = skip_single_quoted (s, s_len, ++i);
2693 i = skip_double_quoted (s, s_len, ++i);
2694 else if (c == 0 || spctabnl (c))
2696 /* We have found the end of a token. Make a word out of it and
2697 add it to the word list. */
2698 token = substring (s, tokstart, i);
2699 list = add_string_to_list (token, list);
2701 while (spctabnl (s[i]))
2709 i++; /* normal character */
2711 return (REVERSE_LIST (list, WORD_LIST *));
2715 /********************************************************/
2717 /* Functions to perform assignment statements */
2719 /********************************************************/
2721 #if defined (ARRAY_VARS)
2723 do_compound_assignment (name, value, flags)
2728 int mklocal, mkassoc, mkglobal;
2731 mklocal = flags & ASS_MKLOCAL;
2732 mkassoc = flags & ASS_MKASSOC;
2733 mkglobal = flags & ASS_MKGLOBAL;
2735 if (mklocal && variable_context)
2737 v = find_variable (name);
2738 list = expand_compound_array_assignment (v, value, flags);
2740 v = make_local_assoc_variable (name);
2741 else if (v == 0 || (array_p (v) == 0 && assoc_p (v) == 0) || v->context != variable_context)
2742 v = make_local_array_variable (name, 0);
2744 assign_compound_array_list (v, list, flags);
2746 /* In a function but forcing assignment in global context */
2747 else if (mkglobal && variable_context)
2749 v = find_global_variable (name);
2750 list = expand_compound_array_assignment (v, value, flags);
2751 if (v == 0 && mkassoc)
2752 v = make_new_assoc_variable (name);
2753 else if (v && mkassoc && assoc_p (v) == 0)
2754 v = convert_var_to_assoc (v);
2756 v = make_new_array_variable (name);
2757 else if (v && mkassoc == 0 && array_p (v) == 0)
2758 v = convert_var_to_array (v);
2760 assign_compound_array_list (v, list, flags);
2763 v = assign_array_from_string (name, value, flags);
2769 /* Given STRING, an assignment string, get the value of the right side
2770 of the `=', and bind it to the left side. If EXPAND is true, then
2771 perform parameter expansion, command substitution, and arithmetic
2772 expansion on the right-hand side. Perform tilde expansion in any
2773 case. Do not perform word splitting on the result of expansion. */
2775 do_assignment_internal (word, expand)
2776 const WORD_DESC *word;
2779 int offset, appendop, assign_list, aflags, retval;
2780 char *name, *value, *temp;
2782 #if defined (ARRAY_VARS)
2788 if (word == 0 || word->word == 0)
2791 appendop = assign_list = aflags = 0;
2792 string = word->word;
2793 offset = assignment (string, 0);
2794 name = savestring (string);
2795 value = (char *)NULL;
2797 if (name[offset] == '=')
2799 if (name[offset - 1] == '+')
2802 name[offset - 1] = '\0';
2805 name[offset] = 0; /* might need this set later */
2806 temp = name + offset + 1;
2808 #if defined (ARRAY_VARS)
2809 if (expand && (word->flags & W_COMPASSIGN))
2811 assign_list = ni = 1;
2812 value = extract_array_assignment_list (temp, &ni);
2816 if (expand && temp[0])
2817 value = expand_string_if_necessary (temp, 0, expand_string_assignment);
2819 value = savestring (temp);
2824 value = (char *)xmalloc (1);
2828 if (echo_command_at_execute)
2831 name[offset - 1] = '+';
2832 xtrace_print_assignment (name, value, assign_list, 1);
2834 name[offset - 1] = '\0';
2837 #define ASSIGN_RETURN(r) do { FREE (value); free (name); return (r); } while (0)
2840 aflags |= ASS_APPEND;
2842 #if defined (ARRAY_VARS)
2843 if (t = mbschr (name, '[')) /*]*/
2847 report_error (_("%s: cannot assign list to array member"), name);
2850 entry = assign_array_element (name, value, aflags);
2854 else if (assign_list)
2856 if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL) == 0)
2857 aflags |= ASS_MKLOCAL;
2858 if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL))
2859 aflags |= ASS_MKGLOBAL;
2860 if (word->flags & W_ASSIGNASSOC)
2861 aflags |= ASS_MKASSOC;
2862 entry = do_compound_assignment (name, value, aflags);
2865 #endif /* ARRAY_VARS */
2866 entry = bind_variable (name, value, aflags);
2868 stupidly_hack_special_variables (name);
2870 /* Return 1 if the assignment seems to have been performed correctly. */
2871 if (entry == 0 || readonly_p (entry))
2872 retval = 0; /* assignment failure */
2873 else if (noassign_p (entry))
2875 last_command_exit_value = EXECUTION_FAILURE;
2876 retval = 1; /* error status, but not assignment failure */
2881 if (entry && retval != 0 && noassign_p (entry) == 0)
2882 VUNSETATTR (entry, att_invisible);
2884 ASSIGN_RETURN (retval);
2887 /* Perform the assignment statement in STRING, and expand the
2888 right side by doing tilde, command and parameter expansion. */
2890 do_assignment (string)
2895 td.flags = W_ASSIGNMENT;
2898 return do_assignment_internal (&td, 1);
2902 do_word_assignment (word, flags)
2906 return do_assignment_internal (word, 1);
2909 /* Given STRING, an assignment string, get the value of the right side
2910 of the `=', and bind it to the left side. Do not perform any word
2911 expansions on the right hand side. */
2913 do_assignment_no_expand (string)
2918 td.flags = W_ASSIGNMENT;
2921 return (do_assignment_internal (&td, 0));
2924 /***************************************************
2926 * Functions to manage the positional parameters *
2928 ***************************************************/
2930 /* Return the word list that corresponds to `$*'. */
2932 list_rest_of_args ()
2934 register WORD_LIST *list, *args;
2937 /* Break out of the loop as soon as one of the dollar variables is null. */
2938 for (i = 1, list = (WORD_LIST *)NULL; i < 10 && dollar_vars[i]; i++)
2939 list = make_word_list (make_bare_word (dollar_vars[i]), list);
2941 for (args = rest_of_args; args; args = args->next)
2942 list = make_word_list (make_bare_word (args->word->word), list);
2944 return (REVERSE_LIST (list, WORD_LIST *));
2950 register WORD_LIST *list;
2953 for (n = 0; n < 9 && dollar_vars[n+1]; n++)
2955 for (list = rest_of_args; list; list = list->next)
2960 /* Return the value of a positional parameter. This handles values > 10. */
2962 get_dollar_var_value (ind)
2969 temp = dollar_vars[ind] ? savestring (dollar_vars[ind]) : (char *)NULL;
2970 else /* We want something like ${11} */
2973 for (p = rest_of_args; p && ind--; p = p->next)
2975 temp = p ? savestring (p->word->word) : (char *)NULL;
2980 /* Make a single large string out of the dollar digit variables,
2981 and the rest_of_args. If DOLLAR_STAR is 1, then obey the special
2982 case of "$*" with respect to IFS. */
2984 string_rest_of_args (dollar_star)
2987 register WORD_LIST *list;
2990 list = list_rest_of_args ();
2991 string = dollar_star ? string_list_dollar_star (list) : string_list (list);
2992 dispose_words (list);
2996 /* Return a string containing the positional parameters from START to
2997 END, inclusive. If STRING[0] == '*', we obey the rules for $*,
2998 which only makes a difference if QUOTED is non-zero. If QUOTED includes
2999 Q_HERE_DOCUMENT or Q_DOUBLE_QUOTES, this returns a quoted list, otherwise
3000 no quoting chars are added. */
3002 pos_params (string, start, end, quoted)
3004 int start, end, quoted;
3006 WORD_LIST *save, *params, *h, *t;
3010 /* see if we can short-circuit. if start == end, we want 0 parameters. */
3012 return ((char *)NULL);
3014 save = params = list_rest_of_args ();
3016 return ((char *)NULL);
3018 if (start == 0) /* handle ${@:0[:x]} specially */
3020 t = make_word_list (make_word (dollar_vars[0]), params);
3024 for (i = start ? 1 : 0; params && i < start; i++)
3025 params = params->next;
3027 return ((char *)NULL);
3028 for (h = t = params; params && i < end; i++)
3031 params = params->next;
3034 t->next = (WORD_LIST *)NULL;
3036 ret = string_list_pos_params (string[0], h, quoted);
3041 dispose_words (save);
3045 /******************************************************************/
3047 /* Functions to expand strings to strings or WORD_LISTs */
3049 /******************************************************************/
3051 #if defined (PROCESS_SUBSTITUTION)
3052 #define EXP_CHAR(s) (s == '$' || s == '`' || s == '<' || s == '>' || s == CTLESC || s == '~')
3054 #define EXP_CHAR(s) (s == '$' || s == '`' || s == CTLESC || s == '~')
3057 /* If there are any characters in STRING that require full expansion,
3058 then call FUNC to expand STRING; otherwise just perform quote
3059 removal if necessary. This returns a new string. */
3061 expand_string_if_necessary (string, quoted, func)
3072 /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
3073 slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;
3077 if (EXP_CHAR (string[i]))
3079 else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
3081 ADVANCE_CHAR (string, slen, i);
3086 list = (*func) (string, quoted);
3089 ret = string_list (list);
3090 dispose_words (list);
3095 else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
3096 ret = string_quote_removal (string, quoted);
3098 ret = savestring (string);
3103 static inline char *
3104 expand_string_to_string_internal (string, quoted, func)
3112 if (string == 0 || *string == '\0')
3113 return ((char *)NULL);
3115 list = (*func) (string, quoted);
3118 ret = string_list (list);
3119 dispose_words (list);
3128 expand_string_to_string (string, quoted)
3132 return (expand_string_to_string_internal (string, quoted, expand_string));
3136 expand_string_unsplit_to_string (string, quoted)
3140 return (expand_string_to_string_internal (string, quoted, expand_string_unsplit));
3144 expand_assignment_string_to_string (string, quoted)
3148 return (expand_string_to_string_internal (string, quoted, expand_string_assignment));
3152 expand_arith_string (string, quoted)
3157 WORD_LIST *list, *tlist;
3163 /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
3164 slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;
3168 if (EXP_CHAR (string[i]))
3170 else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
3172 ADVANCE_CHAR (string, slen, i);
3177 /* This is expanded version of expand_string_internal as it's called by
3178 expand_string_leave_quoted */
3179 td.flags = W_NOPROCSUB; /* don't want process substitution */
3180 td.word = savestring (string);
3181 list = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3182 /* This takes care of the calls from expand_string_leave_quoted and
3186 tlist = word_list_split (list);
3187 dispose_words (list);
3190 dequote_list (list);
3192 /* This comes from expand_string_if_necessary */
3195 ret = string_list (list);
3196 dispose_words (list);
3202 else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
3203 ret = string_quote_removal (string, quoted);
3205 ret = savestring (string);
3210 #if defined (COND_COMMAND)
3211 /* Just remove backslashes in STRING. Returns a new string. */
3213 remove_backslashes (string)
3218 r = ret = (char *)xmalloc (strlen (string) + 1);
3219 for (s = string; s && *s; )
3231 /* This needs better error handling. */
3232 /* Expand W for use as an argument to a unary or binary operator in a
3233 [[...]] expression. If SPECIAL is 1, this is the rhs argument
3234 to the != or == operator, and should be treated as a pattern. In
3235 this case, we quote the string specially for the globbing code. If
3236 SPECIAL is 2, this is an rhs argument for the =~ operator, and should
3237 be quoted appropriately for regcomp/regexec. The caller is responsible
3238 for removing the backslashes if the unquoted word is needed later. */
3240 cond_expand_word (w, special)
3248 if (w->word == 0 || w->word[0] == '\0')
3249 return ((char *)NULL);
3251 w->flags |= W_NOSPLIT2;
3252 l = call_expand_word_internal (w, 0, 0, (int *)0, (int *)0);
3255 if (special == 0) /* LHS */
3258 r = string_list (l);
3262 /* Need to figure out whether or not we should call dequote_escapes
3263 or a new dequote_ctlnul function here, and under what
3265 qflags = QGLOB_CVTNULL;
3267 qflags |= QGLOB_REGEXP;
3268 p = string_list (l);
3269 r = quote_string_for_globbing (p, qflags);
3281 /* Call expand_word_internal to expand W and handle error returns.
3282 A convenience function for functions that don't want to handle
3283 any errors or free any memory before aborting. */
3285 call_expand_word_internal (w, q, i, c, e)
3291 result = expand_word_internal (w, q, i, c, e);
3292 if (result == &expand_word_error || result == &expand_word_fatal)
3294 /* By convention, each time this error is returned, w->word has
3295 already been freed (it sometimes may not be in the fatal case,
3296 but that doesn't result in a memory leak because we're going
3297 to exit in most cases). */
3298 w->word = (char *)NULL;
3299 last_command_exit_value = EXECUTION_FAILURE;
3300 exp_jump_to_top_level ((result == &expand_word_error) ? DISCARD : FORCE_EOF);
3308 /* Perform parameter expansion, command substitution, and arithmetic
3309 expansion on STRING, as if it were a word. Leave the result quoted.
3310 Since this does not perform word splitting, it leaves quoted nulls
3313 expand_string_internal (string, quoted)
3320 if (string == 0 || *string == 0)
3321 return ((WORD_LIST *)NULL);
3324 td.word = savestring (string);
3326 tresult = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3332 /* Expand STRING by performing parameter expansion, command substitution,
3333 and arithmetic expansion. Dequote the resulting WORD_LIST before
3334 returning it, but do not perform word splitting. The call to
3335 remove_quoted_nulls () is in here because word splitting normally
3336 takes care of quote removal. */
3338 expand_string_unsplit (string, quoted)
3344 if (string == 0 || *string == '\0')
3345 return ((WORD_LIST *)NULL);
3347 expand_no_split_dollar_star = 1;
3348 value = expand_string_internal (string, quoted);
3349 expand_no_split_dollar_star = 0;
3355 remove_quoted_nulls (value->word->word);
3356 value->word->flags &= ~W_HASQUOTEDNULL;
3358 dequote_list (value);
3363 /* Expand the rhs of an assignment statement */
3365 expand_string_assignment (string, quoted)
3372 if (string == 0 || *string == '\0')
3373 return ((WORD_LIST *)NULL);
3375 expand_no_split_dollar_star = 1;
3377 td.flags = W_ASSIGNRHS;
3378 td.word = savestring (string);
3379 value = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3382 expand_no_split_dollar_star = 0;
3388 remove_quoted_nulls (value->word->word);
3389 value->word->flags &= ~W_HASQUOTEDNULL;
3391 dequote_list (value);
3397 /* Expand one of the PS? prompt strings. This is a sort of combination of
3398 expand_string_unsplit and expand_string_internal, but returns the
3399 passed string when an error occurs. Might want to trap other calls
3400 to jump_to_top_level here so we don't endlessly loop. */
3402 expand_prompt_string (string, quoted, wflags)
3410 if (string == 0 || *string == 0)
3411 return ((WORD_LIST *)NULL);
3414 td.word = savestring (string);
3416 no_longjmp_on_fatal_error = 1;
3417 value = expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3418 no_longjmp_on_fatal_error = 0;
3420 if (value == &expand_word_error || value == &expand_word_fatal)
3422 value = make_word_list (make_bare_word (string), (WORD_LIST *)NULL);
3430 remove_quoted_nulls (value->word->word);
3431 value->word->flags &= ~W_HASQUOTEDNULL;
3433 dequote_list (value);
3438 /* Expand STRING just as if you were expanding a word, but do not dequote
3439 the resultant WORD_LIST. This is called only from within this file,
3440 and is used to correctly preserve quoted characters when expanding
3441 things like ${1+"$@"}. This does parameter expansion, command
3442 substitution, arithmetic expansion, and word splitting. */
3444 expand_string_leave_quoted (string, quoted)
3451 if (string == 0 || *string == '\0')
3452 return ((WORD_LIST *)NULL);
3454 tlist = expand_string_internal (string, quoted);
3458 tresult = word_list_split (tlist);
3459 dispose_words (tlist);
3462 return ((WORD_LIST *)NULL);
3465 /* This does not perform word splitting or dequote the WORD_LIST
3468 expand_string_for_rhs (string, quoted, dollar_at_p, has_dollar_at)
3470 int quoted, *dollar_at_p, *has_dollar_at;
3475 if (string == 0 || *string == '\0')
3476 return (WORD_LIST *)NULL;
3478 td.flags = W_NOSPLIT2; /* no splitting, remove "" and '' */
3480 tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, has_dollar_at);
3484 /* Expand STRING just as if you were expanding a word. This also returns
3485 a list of words. Note that filename globbing is *NOT* done for word
3486 or string expansion, just when the shell is expanding a command. This
3487 does parameter expansion, command substitution, arithmetic expansion,
3488 and word splitting. Dequote the resultant WORD_LIST before returning. */
3490 expand_string (string, quoted)
3496 if (string == 0 || *string == '\0')
3497 return ((WORD_LIST *)NULL);
3499 result = expand_string_leave_quoted (string, quoted);
3500 return (result ? dequote_list (result) : result);
3503 /***************************************************
3505 * Functions to handle quoting chars *
3507 ***************************************************/
3511 A string with s[0] == CTLNUL && s[1] == 0 is a quoted null string.
3512 The parser passes CTLNUL as CTLESC CTLNUL. */
3514 /* Quote escape characters in string s, but no other characters. This is
3515 used to protect CTLESC and CTLNUL in variable values from the rest of
3516 the word expansion process after the variable is expanded (word splitting
3517 and filename generation). If IFS is null, we quote spaces as well, just
3518 in case we split on spaces later (in the case of unquoted $@, we will
3519 eventually attempt to split the entire word on spaces). Corresponding
3520 code exists in dequote_escapes. Even if we don't end up splitting on
3521 spaces, quoting spaces is not a problem. This should never be called on
3522 a string that is quoted with single or double quotes or part of a here
3523 document (effectively double-quoted). */
3525 quote_escapes (string)
3528 register char *s, *t;
3530 char *result, *send;
3531 int quote_spaces, skip_ctlesc, skip_ctlnul;
3534 slen = strlen (string);
3535 send = string + slen;
3537 quote_spaces = (ifs_value && *ifs_value == 0);
3539 for (skip_ctlesc = skip_ctlnul = 0, s = ifs_value; s && *s; s++)
3540 skip_ctlesc |= *s == CTLESC, skip_ctlnul |= *s == CTLNUL;
3542 t = result = (char *)xmalloc ((slen * 2) + 1);
3547 if ((skip_ctlesc == 0 && *s == CTLESC) || (skip_ctlnul == 0 && *s == CTLNUL) || (quote_spaces && *s == ' '))
3549 COPY_CHAR_P (t, s, send);
3557 list_quote_escapes (list)
3560 register WORD_LIST *w;
3563 for (w = list; w; w = w->next)
3566 w->word->word = quote_escapes (t);
3572 /* Inverse of quote_escapes; remove CTLESC protecting CTLESC or CTLNUL.
3574 The parser passes us CTLESC as CTLESC CTLESC and CTLNUL as CTLESC CTLNUL.
3575 This is necessary to make unquoted CTLESC and CTLNUL characters in the
3576 data stream pass through properly.
3578 We need to remove doubled CTLESC characters inside quoted strings before
3579 quoting the entire string, so we do not double the number of CTLESC
3582 Also used by parts of the pattern substitution code. */
3584 dequote_escapes (string)
3587 register char *s, *t, *s1;
3589 char *result, *send;
3596 slen = strlen (string);
3597 send = string + slen;
3599 t = result = (char *)xmalloc (slen + 1);
3601 if (strchr (string, CTLESC) == 0)
3602 return (strcpy (result, string));
3604 quote_spaces = (ifs_value && *ifs_value == 0);
3609 if (*s == CTLESC && (s[1] == CTLESC || s[1] == CTLNUL || (quote_spaces && s[1] == ' ')))
3615 COPY_CHAR_P (t, s, send);
3623 list_dequote_escapes (list)
3626 register WORD_LIST *w;
3629 for (w = list; w; w = w->next)
3632 w->word->word = dequote_escapes (t);
3638 /* Return a new string with the quoted representation of character C.
3639 This turns "" into QUOTED_NULL, so the W_HASQUOTEDNULL flag needs to be
3640 set in any resultant WORD_DESC where this value is the word. */
3642 make_quoted_char (c)
3647 temp = (char *)xmalloc (3);
3662 /* Quote STRING, returning a new string. This turns "" into QUOTED_NULL, so
3663 the W_HASQUOTEDNULL flag needs to be set in any resultant WORD_DESC where
3664 this value is the word. */
3666 quote_string (string)
3671 char *result, *send;
3675 result = (char *)xmalloc (2);
3683 slen = strlen (string);
3684 send = string + slen;
3686 result = (char *)xmalloc ((slen * 2) + 1);
3688 for (t = result; string < send; )
3691 COPY_CHAR_P (t, string, send);
3698 /* De-quote quoted characters in STRING. */
3700 dequote_string (string)
3703 register char *s, *t;
3705 char *result, *send;
3708 slen = strlen (string);
3710 t = result = (char *)xmalloc (slen + 1);
3712 if (QUOTED_NULL (string))
3718 /* If no character in the string can be quoted, don't bother examining
3719 each character. Just return a copy of the string passed to us. */
3720 if (strchr (string, CTLESC) == NULL)
3721 return (strcpy (result, string));
3723 send = string + slen;
3733 COPY_CHAR_P (t, s, send);
3740 /* Quote the entire WORD_LIST list. */
3745 register WORD_LIST *w;
3748 for (w = list; w; w = w->next)
3751 w->word->word = quote_string (t);
3753 w->word->flags |= W_HASQUOTEDNULL; /* XXX - turn on W_HASQUOTEDNULL here? */
3754 w->word->flags |= W_QUOTED;
3760 /* De-quote quoted characters in each word in LIST. */
3766 register WORD_LIST *tlist;
3768 for (tlist = list; tlist; tlist = tlist->next)
3770 s = dequote_string (tlist->word->word);
3771 if (QUOTED_NULL (tlist->word->word))
3772 tlist->word->flags &= ~W_HASQUOTEDNULL;
3773 free (tlist->word->word);
3774 tlist->word->word = s;
3779 /* Remove CTLESC protecting a CTLESC or CTLNUL in place. Return the passed
3782 remove_quoted_escapes (string)
3789 t = dequote_escapes (string);
3797 /* Perform quoted null character removal on STRING. We don't allow any
3798 quoted null characters in the middle or at the ends of strings because
3799 of how expand_word_internal works. remove_quoted_nulls () turns
3800 STRING into an empty string iff it only consists of a quoted null,
3801 and removes all unquoted CTLNUL characters. */
3803 remove_quoted_nulls (string)
3806 register size_t slen;
3807 register int i, j, prev_i;
3810 if (strchr (string, CTLNUL) == 0) /* XXX */
3811 return string; /* XXX */
3813 slen = strlen (string);
3818 if (string[i] == CTLESC)
3820 /* Old code had j++, but we cannot assume that i == j at this
3821 point -- what if a CTLNUL has already been removed from the
3822 string? We don't want to drop the CTLESC or recopy characters
3823 that we've already copied down. */
3824 i++; string[j++] = CTLESC;
3828 else if (string[i] == CTLNUL)
3835 ADVANCE_CHAR (string, slen, i);
3838 do string[j++] = string[prev_i++]; while (prev_i < i);
3848 /* Perform quoted null character removal on each element of LIST.
3849 This modifies LIST. */
3851 word_list_remove_quoted_nulls (list)
3854 register WORD_LIST *t;
3856 for (t = list; t; t = t->next)
3858 remove_quoted_nulls (t->word->word);
3859 t->word->flags &= ~W_HASQUOTEDNULL;
3863 /* **************************************************************** */
3865 /* Functions for Matching and Removing Patterns */
3867 /* **************************************************************** */
3869 #if defined (HANDLE_MULTIBYTE)
3870 #if 0 /* Currently unused */
3871 static unsigned char *
3872 mb_getcharlens (string, len)
3876 int i, offset, last;
3883 ret = (unsigned char *)xmalloc (len);
3884 memset (ret, 0, len);
3885 while (string[last])
3887 ADVANCE_CHAR (string, len, offset);
3888 ret[last] = offset - last;
3896 /* Remove the portion of PARAM matched by PATTERN according to OP, where OP
3897 can have one of 4 values:
3898 RP_LONG_LEFT remove longest matching portion at start of PARAM
3899 RP_SHORT_LEFT remove shortest matching portion at start of PARAM
3900 RP_LONG_RIGHT remove longest matching portion at end of PARAM
3901 RP_SHORT_RIGHT remove shortest matching portion at end of PARAM
3904 #define RP_LONG_LEFT 1
3905 #define RP_SHORT_LEFT 2
3906 #define RP_LONG_RIGHT 3
3907 #define RP_SHORT_RIGHT 4
3909 /* Returns its first argument if nothing matched; new memory otherwise */
3911 remove_upattern (param, pattern, op)
3912 char *param, *pattern;
3917 register char *p, *ret, c;
3919 len = STRLEN (param);
3924 case RP_LONG_LEFT: /* remove longest match at start */
3925 for (p = end; p >= param; p--)
3928 if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3931 return (savestring (p));
3938 case RP_SHORT_LEFT: /* remove shortest match at start */
3939 for (p = param; p <= end; p++)
3942 if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3945 return (savestring (p));
3951 case RP_LONG_RIGHT: /* remove longest match at end */
3952 for (p = param; p <= end; p++)
3954 if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3957 ret = savestring (param);
3964 case RP_SHORT_RIGHT: /* remove shortest match at end */
3965 for (p = end; p >= param; p--)
3967 if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3970 ret = savestring (param);
3978 return (param); /* no match, return original string */
3981 #if defined (HANDLE_MULTIBYTE)
3982 /* Returns its first argument if nothing matched; new memory otherwise */
3984 remove_wpattern (wparam, wstrlen, wpattern, op)
3995 case RP_LONG_LEFT: /* remove longest match at start */
3996 for (n = wstrlen; n >= 0; n--)
3998 wc = wparam[n]; wparam[n] = L'\0';
3999 if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4002 return (wcsdup (wparam + n));
4008 case RP_SHORT_LEFT: /* remove shortest match at start */
4009 for (n = 0; n <= wstrlen; n++)
4011 wc = wparam[n]; wparam[n] = L'\0';
4012 if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4015 return (wcsdup (wparam + n));
4021 case RP_LONG_RIGHT: /* remove longest match at end */
4022 for (n = 0; n <= wstrlen; n++)
4024 if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4026 wc = wparam[n]; wparam[n] = L'\0';
4027 ret = wcsdup (wparam);
4034 case RP_SHORT_RIGHT: /* remove shortest match at end */
4035 for (n = wstrlen; n >= 0; n--)
4037 if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4039 wc = wparam[n]; wparam[n] = L'\0';
4040 ret = wcsdup (wparam);
4048 return (wparam); /* no match, return original string */
4050 #endif /* HANDLE_MULTIBYTE */
4053 remove_pattern (param, pattern, op)
4054 char *param, *pattern;
4061 if (*param == '\0' || pattern == NULL || *pattern == '\0') /* minor optimization */
4062 return (savestring (param));
4064 #if defined (HANDLE_MULTIBYTE)
4067 wchar_t *ret, *oret;
4069 wchar_t *wparam, *wpattern;
4072 n = xdupmbstowcs (&wpattern, NULL, pattern);
4073 if (n == (size_t)-1)
4075 xret = remove_upattern (param, pattern, op);
4076 return ((xret == param) ? savestring (param) : xret);
4078 n = xdupmbstowcs (&wparam, NULL, param);
4080 if (n == (size_t)-1)
4083 xret = remove_upattern (param, pattern, op);
4084 return ((xret == param) ? savestring (param) : xret);
4086 oret = ret = remove_wpattern (wparam, n, wpattern, op);
4087 /* Don't bother to convert wparam back to multibyte string if nothing
4088 matched; just return copy of original string */
4093 return (savestring (param));
4100 xret = (char *)xmalloc (n + 1);
4101 memset (&ps, '\0', sizeof (mbstate_t));
4102 n = wcsrtombs (xret, (const wchar_t **)&ret, n, &ps);
4103 xret[n] = '\0'; /* just to make sure */
4110 xret = remove_upattern (param, pattern, op);
4111 return ((xret == param) ? savestring (param) : xret);
4115 /* Match PAT anywhere in STRING and return the match boundaries.
4116 This returns 1 in case of a successful match, 0 otherwise. SP
4117 and EP are pointers into the string where the match begins and
4118 ends, respectively. MTYPE controls what kind of match is attempted.
4119 MATCH_BEG and MATCH_END anchor the match at the beginning and end
4120 of the string, respectively. The longest match is returned. */
4122 match_upattern (string, pat, mtype, sp, ep)
4128 register char *p, *p1, *npat;
4132 /* If the pattern doesn't match anywhere in the string, go ahead and
4133 short-circuit right away. A minor optimization, saves a bunch of
4134 unnecessary calls to strmatch (up to N calls for a string of N
4135 characters) if the match is unsuccessful. To preserve the semantics
4136 of the substring matches below, we make sure that the pattern has
4137 `*' as first and last character, making a new pattern if necessary. */
4138 /* XXX - check this later if I ever implement `**' with special meaning,
4139 since this will potentially result in `**' at the beginning or end */
4141 if (pat[0] != '*' || (pat[0] == '*' && pat[1] == LPAREN && extended_glob) || pat[len - 1] != '*')
4143 p = npat = (char *)xmalloc (len + 3);
4145 if (*p1 != '*' || (*p1 == '*' && p1[1] == LPAREN && extended_glob))
4149 if (p1[-1] != '*' || p[-2] == '\\')
4155 c = strmatch (npat, string, FNMATCH_EXTFLAG);
4158 if (c == FNM_NOMATCH)
4161 len = STRLEN (string);
4164 mlen = umatchlen (pat, len);
4169 for (p = string; p <= end; p++)
4171 if (match_pattern_char (pat, p))
4173 p1 = (mlen == -1) ? end : p + mlen;
4174 /* p1 - p = length of portion of string to be considered
4175 p = current position in string
4176 mlen = number of characters consumed by match (-1 for entire string)
4178 we want to break immediately if the potential match len
4179 is greater than the number of characters remaining in the
4184 for ( ; p1 >= p; p1--)
4186 c = *p1; *p1 = '\0';
4187 if (strmatch (pat, p, FNMATCH_EXTFLAG) == 0)
4196 /* If MLEN != -1, we have a fixed length pattern. */
4207 if (match_pattern_char (pat, string) == 0)
4210 for (p = (mlen == -1) ? end : string + mlen; p >= string; p--)
4213 if (strmatch (pat, string, FNMATCH_EXTFLAG) == 0)
4221 /* If MLEN != -1, we have a fixed length pattern. */
4229 for (p = end - ((mlen == -1) ? len : mlen); p <= end; p++)
4231 if (strmatch (pat, p, FNMATCH_EXTFLAG) == 0)
4237 /* If MLEN != -1, we have a fixed length pattern. */
4248 #if defined (HANDLE_MULTIBYTE)
4249 /* Match WPAT anywhere in WSTRING and return the match boundaries.
4250 This returns 1 in case of a successful match, 0 otherwise. Wide
4251 character version. */
4253 match_wpattern (wstring, indices, wstrlen, wpat, mtype, sp, ep)
4261 wchar_t wc, *wp, *nwpat, *wp1;
4264 int n, n1, n2, simple;
4266 simple = (wpat[0] != L'\\' && wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'[');
4267 #if defined (EXTENDED_GLOB)
4269 simple &= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@')); /*)*/
4272 /* If the pattern doesn't match anywhere in the string, go ahead and
4273 short-circuit right away. A minor optimization, saves a bunch of
4274 unnecessary calls to strmatch (up to N calls for a string of N
4275 characters) if the match is unsuccessful. To preserve the semantics
4276 of the substring matches below, we make sure that the pattern has
4277 `*' as first and last character, making a new pattern if necessary. */
4278 len = wcslen (wpat);
4279 if (wpat[0] != L'*' || (wpat[0] == L'*' && wpat[1] == WLPAREN && extended_glob) || wpat[len - 1] != L'*')
4281 wp = nwpat = (wchar_t *)xmalloc ((len + 3) * sizeof (wchar_t));
4283 if (*wp1 != L'*' || (*wp1 == '*' && wp1[1] == WLPAREN && extended_glob))
4285 while (*wp1 != L'\0')
4287 if (wp1[-1] != L'*' || wp1[-2] == L'\\')
4293 len = wcsmatch (nwpat, wstring, FNMATCH_EXTFLAG);
4296 if (len == FNM_NOMATCH)
4299 mlen = wmatchlen (wpat, wstrlen);
4301 /* itrace("wmatchlen (%ls) -> %d", wpat, mlen); */
4305 for (n = 0; n <= wstrlen; n++)
4307 n2 = simple ? (*wpat == wstring[n]) : match_pattern_wchar (wpat, wstring + n);
4310 n1 = (mlen == -1) ? wstrlen : n + mlen;
4314 for ( ; n1 >= n; n1--)
4316 wc = wstring[n1]; wstring[n1] = L'\0';
4317 if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG) == 0)
4325 /* If MLEN != -1, we have a fixed length pattern. */
4335 if (match_pattern_wchar (wpat, wstring) == 0)
4338 for (n = (mlen == -1) ? wstrlen : mlen; n >= 0; n--)
4340 wc = wstring[n]; wstring[n] = L'\0';
4341 if (wcsmatch (wpat, wstring, FNMATCH_EXTFLAG) == 0)
4349 /* If MLEN != -1, we have a fixed length pattern. */
4357 for (n = wstrlen - ((mlen == -1) ? wstrlen : mlen); n <= wstrlen; n++)
4359 if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG) == 0)
4362 *ep = indices[wstrlen];
4365 /* If MLEN != -1, we have a fixed length pattern. */
4375 #endif /* HANDLE_MULTIBYTE */
4378 match_pattern (string, pat, mtype, sp, ep)
4383 #if defined (HANDLE_MULTIBYTE)
4386 wchar_t *wstring, *wpat;
4388 size_t slen, plen, mslen, mplen;
4391 if (string == 0 || *string == 0 || pat == 0 || *pat == 0)
4394 #if defined (HANDLE_MULTIBYTE)
4397 if (mbsmbchar (string) == 0 && mbsmbchar (pat) == 0)
4398 return (match_upattern (string, pat, mtype, sp, ep));
4400 n = xdupmbstowcs (&wpat, NULL, pat);
4401 if (n == (size_t)-1)
4402 return (match_upattern (string, pat, mtype, sp, ep));
4403 n = xdupmbstowcs (&wstring, &indices, string);
4404 if (n == (size_t)-1)
4407 return (match_upattern (string, pat, mtype, sp, ep));
4409 ret = match_wpattern (wstring, indices, n, wpat, mtype, sp, ep);
4419 return (match_upattern (string, pat, mtype, sp, ep));
4423 getpatspec (c, value)
4428 return ((*value == '#') ? RP_LONG_LEFT : RP_SHORT_LEFT);
4430 return ((*value == '%') ? RP_LONG_RIGHT : RP_SHORT_RIGHT);
4433 /* Posix.2 says that the WORD should be run through tilde expansion,
4434 parameter expansion, command substitution and arithmetic expansion.
4435 This leaves the result quoted, so quote_string_for_globbing () has
4436 to be called to fix it up for strmatch (). If QUOTED is non-zero,
4437 it means that the entire expression was enclosed in double quotes.
4438 This means that quoting characters in the pattern do not make any
4439 special pattern characters quoted. For example, the `*' in the
4440 following retains its special meaning: "${foo#'*'}". */
4442 getpattern (value, quoted, expandpat)
4444 int quoted, expandpat;
4451 /* There is a problem here: how to handle single or double quotes in the
4452 pattern string when the whole expression is between double quotes?
4453 POSIX.2 says that enclosing double quotes do not cause the pattern to
4454 be quoted, but does that leave us a problem with @ and array[@] and their
4455 expansions inside a pattern? */
4457 if (expandpat && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *tword)
4460 pat = string_extract_double_quoted (tword, &i, 1);
4466 /* expand_string_for_rhs () leaves WORD quoted and does not perform
4468 l = *value ? expand_string_for_rhs (value,
4469 (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? Q_PATQUOTE : quoted,
4470 (int *)NULL, (int *)NULL)
4472 pat = string_list (l);
4476 tword = quote_string_for_globbing (pat, QGLOB_CVTNULL);
4484 /* Handle removing a pattern from a string as a result of ${name%[%]value}
4485 or ${name#[#]value}. */
4487 variable_remove_pattern (value, pattern, patspec, quoted)
4488 char *value, *pattern;
4489 int patspec, quoted;
4493 tword = remove_pattern (value, pattern, patspec);
4500 list_remove_pattern (list, pattern, patspec, itype, quoted)
4503 int patspec, itype, quoted;
4509 for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)
4511 tword = remove_pattern (l->word->word, pattern, patspec);
4512 w = alloc_word_desc ();
4513 w->word = tword ? tword : savestring ("");
4514 new = make_word_list (w, new);
4517 l = REVERSE_LIST (new, WORD_LIST *);
4518 tword = string_list_pos_params (itype, l, quoted);
4525 parameter_list_remove_pattern (itype, pattern, patspec, quoted)
4528 int patspec, quoted;
4533 list = list_rest_of_args ();
4535 return ((char *)NULL);
4536 ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
4537 dispose_words (list);
4541 #if defined (ARRAY_VARS)
4543 array_remove_pattern (var, pattern, patspec, varname, quoted)
4547 char *varname; /* so we can figure out how it's indexed */
4557 /* compute itype from varname here */
4558 v = array_variable_part (varname, &ret, 0);
4561 if (v && invisible_p (var))
4562 return ((char *)NULL);
4566 a = (v && array_p (v)) ? array_cell (v) : 0;
4567 h = (v && assoc_p (v)) ? assoc_cell (v) : 0;
4569 list = a ? array_to_word_list (a) : (h ? assoc_to_word_list (h) : 0);
4571 return ((char *)NULL);
4572 ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
4573 dispose_words (list);
4577 #endif /* ARRAY_VARS */
4580 parameter_brace_remove_pattern (varname, value, ind, patstr, rtype, quoted, flags)
4581 char *varname, *value;
4584 int rtype, quoted, flags;
4586 int vtype, patspec, starsub;
4587 char *temp1, *val, *pattern;
4591 return ((char *)NULL);
4593 this_command_name = varname;
4595 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
4597 return ((char *)NULL);
4599 starsub = vtype & VT_STARSUB;
4600 vtype &= ~VT_STARSUB;
4602 patspec = getpatspec (rtype, patstr);
4603 if (patspec == RP_LONG_LEFT || patspec == RP_LONG_RIGHT)
4606 /* Need to pass getpattern newly-allocated memory in case of expansion --
4607 the expansion code will free the passed string on an error. */
4608 temp1 = savestring (patstr);
4609 pattern = getpattern (temp1, quoted, 1);
4612 temp1 = (char *)NULL; /* shut up gcc */
4616 case VT_ARRAYMEMBER:
4617 temp1 = remove_pattern (val, pattern, patspec);
4618 if (vtype == VT_VARIABLE)
4622 val = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
4623 ? quote_string (temp1)
4624 : quote_escapes (temp1);
4629 #if defined (ARRAY_VARS)
4631 temp1 = array_remove_pattern (v, pattern, patspec, varname, quoted);
4632 if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
4634 val = quote_escapes (temp1);
4641 temp1 = parameter_list_remove_pattern (varname[0], pattern, patspec, quoted);
4642 if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
4644 val = quote_escapes (temp1);
4655 /*******************************************
4657 * Functions to expand WORD_DESCs *
4659 *******************************************/
4661 /* Expand WORD, performing word splitting on the result. This does
4662 parameter expansion, command substitution, arithmetic expansion,
4663 word splitting, and quote removal. */
4666 expand_word (word, quoted)
4670 WORD_LIST *result, *tresult;
4672 tresult = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
4673 result = word_list_split (tresult);
4674 dispose_words (tresult);
4675 return (result ? dequote_list (result) : result);
4678 /* Expand WORD, but do not perform word splitting on the result. This
4679 does parameter expansion, command substitution, arithmetic expansion,
4680 and quote removal. */
4682 expand_word_unsplit (word, quoted)
4688 expand_no_split_dollar_star = 1;
4689 #if defined (HANDLE_MULTIBYTE)
4690 if (ifs_firstc[0] == 0)
4692 if (ifs_firstc == 0)
4694 word->flags |= W_NOSPLIT;
4695 word->flags |= W_NOSPLIT2;
4696 result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
4697 expand_no_split_dollar_star = 0;
4699 return (result ? dequote_list (result) : result);
4702 /* Perform shell expansions on WORD, but do not perform word splitting or
4703 quote removal on the result. Virtually identical to expand_word_unsplit;
4704 could be combined if implementations don't diverge. */
4706 expand_word_leave_quoted (word, quoted)
4712 expand_no_split_dollar_star = 1;
4713 #if defined (HANDLE_MULTIBYTE)
4714 if (ifs_firstc[0] == 0)
4716 if (ifs_firstc == 0)
4718 word->flags |= W_NOSPLIT;
4719 word->flags |= W_NOSPLIT2;
4720 result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
4721 expand_no_split_dollar_star = 0;
4726 #if defined (PROCESS_SUBSTITUTION)
4728 /*****************************************************************/
4730 /* Hacking Process Substitution */
4732 /*****************************************************************/
4734 #if !defined (HAVE_DEV_FD)
4735 /* Named pipes must be removed explicitly with `unlink'. This keeps a list
4736 of FIFOs the shell has open. unlink_fifo_list will walk the list and
4737 unlink all of them. add_fifo_list adds the name of an open FIFO to the
4738 list. NFIFO is a count of the number of FIFOs in the list. */
4739 #define FIFO_INCR 20
4746 static struct temp_fifo *fifo_list = (struct temp_fifo *)NULL;
4748 static int fifo_list_size;
4751 copy_fifo_list (sizep)
4756 return (char *)NULL;
4760 add_fifo_list (pathname)
4763 if (nfifo >= fifo_list_size - 1)
4765 fifo_list_size += FIFO_INCR;
4766 fifo_list = (struct temp_fifo *)xrealloc (fifo_list,
4767 fifo_list_size * sizeof (struct temp_fifo));
4770 fifo_list[nfifo].file = savestring (pathname);
4778 if ((fifo_list[i].proc == -1) || (kill(fifo_list[i].proc, 0) == -1))
4780 unlink (fifo_list[i].file);
4781 free (fifo_list[i].file);
4782 fifo_list[i].file = (char *)NULL;
4783 fifo_list[i].proc = -1;
4795 for (i = saved = 0; i < nfifo; i++)
4797 if ((fifo_list[i].proc == -1) || (kill(fifo_list[i].proc, 0) == -1))
4799 unlink (fifo_list[i].file);
4800 free (fifo_list[i].file);
4801 fifo_list[i].file = (char *)NULL;
4802 fifo_list[i].proc = -1;
4808 /* If we didn't remove some of the FIFOs, compact the list. */
4811 for (i = j = 0; i < nfifo; i++)
4812 if (fifo_list[i].file)
4814 fifo_list[j].file = fifo_list[i].file;
4815 fifo_list[j].proc = fifo_list[i].proc;
4824 /* Take LIST, which is a bitmap denoting active FIFOs in fifo_list
4825 from some point in the past, and close all open FIFOs in fifo_list
4826 that are not marked as active in LIST. If LIST is NULL, close
4827 everything in fifo_list. LSIZE is the number of elements in LIST, in
4828 case it's larger than fifo_list_size (size of fifo_list). */
4830 close_new_fifos (list, lsize)
4838 unlink_fifo_list ();
4842 for (i = 0; i < lsize; i++)
4843 if (list[i] == 0 && i < fifo_list_size && fifo_list[i].proc != -1)
4846 for (i = lsize; i < fifo_list_size; i++)
4867 tname = sh_mktmpname ("sh-np", MT_USERANDOM|MT_USETMPDIR);
4868 if (mkfifo (tname, 0600) < 0)
4871 return ((char *)NULL);
4874 add_fifo_list (tname);
4878 #else /* HAVE_DEV_FD */
4880 /* DEV_FD_LIST is a bitmap of file descriptors attached to pipes the shell
4881 has open to children. NFDS is a count of the number of bits currently
4882 set in DEV_FD_LIST. TOTFDS is a count of the highest possible number
4884 static char *dev_fd_list = (char *)NULL;
4886 static int totfds; /* The highest possible number of open files. */
4889 copy_fifo_list (sizep)
4894 if (nfds == 0 || totfds == 0)
4898 return (char *)NULL;
4903 ret = (char *)xmalloc (totfds);
4904 return (memcpy (ret, dev_fd_list, totfds));
4911 if (dev_fd_list == 0 || fd >= totfds)
4916 totfds = getdtablesize ();
4917 if (totfds < 0 || totfds > 256)
4922 dev_fd_list = (char *)xrealloc (dev_fd_list, totfds);
4923 memset (dev_fd_list + ofds, '\0', totfds - ofds);
4926 dev_fd_list[fd] = 1;
4933 return 0; /* used for cleanup; not needed with /dev/fd */
4946 if (dev_fd_list[fd])
4949 dev_fd_list[fd] = 0;
4962 for (i = 0; nfds && i < totfds; i++)
4968 /* Take LIST, which is a snapshot copy of dev_fd_list from some point in
4969 the past, and close all open fds in dev_fd_list that are not marked
4970 as open in LIST. If LIST is NULL, close everything in dev_fd_list.
4971 LSIZE is the number of elements in LIST, in case it's larger than
4972 totfds (size of dev_fd_list). */
4974 close_new_fifos (list, lsize)
4982 unlink_fifo_list ();
4986 for (i = 0; i < lsize; i++)
4987 if (list[i] == 0 && i < totfds && dev_fd_list[i])
4990 for (i = lsize; i < totfds; i++)
4994 #if defined (NOTDEF)
4995 print_dev_fd_list ()
4999 fprintf (stderr, "pid %ld: dev_fd_list:", (long)getpid ());
5002 for (i = 0; i < totfds; i++)
5005 fprintf (stderr, " %d", i);
5007 fprintf (stderr, "\n");
5012 make_dev_fd_filename (fd)
5015 char *ret, intbuf[INT_STRLEN_BOUND (int) + 1], *p;
5017 ret = (char *)xmalloc (sizeof (DEV_FD_PREFIX) + 8);
5019 strcpy (ret, DEV_FD_PREFIX);
5020 p = inttostr (fd, intbuf, sizeof (intbuf));
5021 strcpy (ret + sizeof (DEV_FD_PREFIX) - 1, p);
5027 #endif /* HAVE_DEV_FD */
5029 /* Return a filename that will open a connection to the process defined by
5030 executing STRING. HAVE_DEV_FD, if defined, means open a pipe and return
5031 a filename in /dev/fd corresponding to a descriptor that is one of the
5032 ends of the pipe. If not defined, we use named pipes on systems that have
5033 them. Systems without /dev/fd and named pipes are out of luck.
5035 OPEN_FOR_READ_IN_CHILD, if 1, means open the named pipe for reading or
5036 use the read end of the pipe and dup that file descriptor to fd 0 in
5037 the child. If OPEN_FOR_READ_IN_CHILD is 0, we open the named pipe for
5038 writing or use the write end of the pipe in the child, and dup that
5039 file descriptor to fd 1 in the child. The parent does the opposite. */
5042 process_substitute (string, open_for_read_in_child)
5044 int open_for_read_in_child;
5049 #if defined (HAVE_DEV_FD)
5050 int parent_pipe_fd, child_pipe_fd;
5052 #endif /* HAVE_DEV_FD */
5053 #if defined (JOB_CONTROL)
5054 pid_t old_pipeline_pgrp;
5057 if (!string || !*string || wordexp_only)
5058 return ((char *)NULL);
5060 #if !defined (HAVE_DEV_FD)
5061 pathname = make_named_pipe ();
5062 #else /* HAVE_DEV_FD */
5063 if (pipe (fildes) < 0)
5065 sys_error (_("cannot make pipe for process substitution"));
5066 return ((char *)NULL);
5068 /* If OPEN_FOR_READ_IN_CHILD == 1, we want to use the write end of
5069 the pipe in the parent, otherwise the read end. */
5070 parent_pipe_fd = fildes[open_for_read_in_child];
5071 child_pipe_fd = fildes[1 - open_for_read_in_child];
5072 /* Move the parent end of the pipe to some high file descriptor, to
5073 avoid clashes with FDs used by the script. */
5074 parent_pipe_fd = move_to_high_fd (parent_pipe_fd, 1, 64);
5076 pathname = make_dev_fd_filename (parent_pipe_fd);
5077 #endif /* HAVE_DEV_FD */
5081 sys_error (_("cannot make pipe for process substitution"));
5082 return ((char *)NULL);
5085 old_pid = last_made_pid;
5087 #if defined (JOB_CONTROL)
5088 old_pipeline_pgrp = pipeline_pgrp;
5089 pipeline_pgrp = shell_pgrp;
5091 #endif /* JOB_CONTROL */
5093 pid = make_child ((char *)NULL, 1);
5096 reset_terminating_signals (); /* XXX */
5097 free_pushed_string_input ();
5098 /* Cancel traps, in trap.c. */
5099 restore_original_signals (); /* XXX - what about special builtins? bash-4.2 */
5100 setup_async_signals ();
5101 subshell_environment |= SUBSHELL_COMSUB|SUBSHELL_PROCSUB;
5104 #if defined (JOB_CONTROL)
5105 set_sigchld_handler ();
5106 stop_making_children ();
5107 /* XXX - should we only do this in the parent? (as in command subst) */
5108 pipeline_pgrp = old_pipeline_pgrp;
5109 #endif /* JOB_CONTROL */
5113 sys_error (_("cannot make child for process substitution"));
5115 #if defined (HAVE_DEV_FD)
5116 close (parent_pipe_fd);
5117 close (child_pipe_fd);
5118 #endif /* HAVE_DEV_FD */
5119 return ((char *)NULL);
5124 #if defined (JOB_CONTROL)
5125 restore_pipeline (1);
5128 #if !defined (HAVE_DEV_FD)
5129 fifo_list[nfifo-1].proc = pid;
5132 last_made_pid = old_pid;
5134 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
5136 #endif /* JOB_CONTROL && PGRP_PIPE */
5138 #if defined (HAVE_DEV_FD)
5139 close (child_pipe_fd);
5140 #endif /* HAVE_DEV_FD */
5145 set_sigint_handler ();
5147 #if defined (JOB_CONTROL)
5148 set_job_control (0);
5149 #endif /* JOB_CONTROL */
5151 #if !defined (HAVE_DEV_FD)
5152 /* Open the named pipe in the child. */
5153 fd = open (pathname, open_for_read_in_child ? O_RDONLY : O_WRONLY);
5156 /* Two separate strings for ease of translation. */
5157 if (open_for_read_in_child)
5158 sys_error (_("cannot open named pipe %s for reading"), pathname);
5160 sys_error (_("cannot open named pipe %s for writing"), pathname);
5164 if (open_for_read_in_child)
5166 if (sh_unset_nodelay_mode (fd) < 0)
5168 sys_error (_("cannot reset nodelay mode for fd %d"), fd);
5172 #else /* HAVE_DEV_FD */
5174 #endif /* HAVE_DEV_FD */
5176 if (dup2 (fd, open_for_read_in_child ? 0 : 1) < 0)
5178 sys_error (_("cannot duplicate named pipe %s as fd %d"), pathname,
5179 open_for_read_in_child ? 0 : 1);
5183 if (fd != (open_for_read_in_child ? 0 : 1))
5186 /* Need to close any files that this process has open to pipes inherited
5188 if (current_fds_to_close)
5190 close_fd_bitmap (current_fds_to_close);
5191 current_fds_to_close = (struct fd_bitmap *)NULL;
5194 #if defined (HAVE_DEV_FD)
5195 /* Make sure we close the parent's end of the pipe and clear the slot
5196 in the fd list so it is not closed later, if reallocated by, for
5197 instance, pipe(2). */
5198 close (parent_pipe_fd);
5199 dev_fd_list[parent_pipe_fd] = 0;
5200 #endif /* HAVE_DEV_FD */
5202 /* subshells shouldn't have this flag, which controls using the temporary
5203 environment for variable lookups. */
5204 expanding_redir = 0;
5206 result = parse_and_execute (string, "process substitution", (SEVAL_NONINT|SEVAL_NOHIST));
5208 #if !defined (HAVE_DEV_FD)
5209 /* Make sure we close the named pipe in the child before we exit. */
5210 close (open_for_read_in_child ? 0 : 1);
5211 #endif /* !HAVE_DEV_FD */
5213 last_command_exit_value = result;
5214 result = run_exit_trap ();
5218 #endif /* PROCESS_SUBSTITUTION */
5220 /***********************************/
5222 /* Command Substitution */
5224 /***********************************/
5227 read_comsub (fd, quoted, rflag)
5231 char *istring, buf[128], *bufp, *s;
5232 int istring_index, istring_size, c, tflag, skip_ctlesc, skip_ctlnul;
5235 istring = (char *)NULL;
5236 istring_index = istring_size = bufn = tflag = 0;
5238 for (skip_ctlesc = skip_ctlnul = 0, s = ifs_value; s && *s; s++)
5239 skip_ctlesc |= *s == CTLESC, skip_ctlnul |= *s == CTLNUL;
5241 /* Read the output of the command through the pipe. This may need to be
5242 changed to understand multibyte characters in the future. */
5249 bufn = zread (fd, buf, sizeof (buf));
5259 internal_warning ("read_comsub: ignored null byte in input");
5264 /* Add the character to ISTRING, possibly after resizing it. */
5265 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size, DEFAULT_ARRAY_SIZE);
5267 /* This is essentially quote_string inline */
5268 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) /* || c == CTLESC || c == CTLNUL */)
5269 istring[istring_index++] = CTLESC;
5270 /* Escape CTLESC and CTLNUL in the output to protect those characters
5271 from the rest of the word expansions (word splitting and globbing.)
5272 This is essentially quote_escapes inline. */
5273 else if (skip_ctlesc == 0 && c == CTLESC)
5275 tflag |= W_HASCTLESC;
5276 istring[istring_index++] = CTLESC;
5278 else if ((skip_ctlnul == 0 && c == CTLNUL) || (c == ' ' && (ifs_value && *ifs_value == 0)))
5279 istring[istring_index++] = CTLESC;
5281 istring[istring_index++] = c;
5284 #if defined (__CYGWIN__)
5285 if (c == '\n' && istring_index > 1 && istring[istring_index - 2] == '\r')
5288 istring[istring_index - 1] = '\n';
5295 istring[istring_index] = '\0';
5297 /* If we read no output, just return now and save ourselves some
5299 if (istring_index == 0)
5304 return (char *)NULL;
5307 /* Strip trailing newlines from the output of the command. */
5308 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
5310 while (istring_index > 0)
5312 if (istring[istring_index - 1] == '\n')
5316 /* If the newline was quoted, remove the quoting char. */
5317 if (istring[istring_index - 1] == CTLESC)
5323 istring[istring_index] = '\0';
5326 strip_trailing (istring, istring_index - 1, 1);
5333 /* Perform command substitution on STRING. This returns a WORD_DESC * with the
5334 contained string possibly quoted. */
5336 command_substitute (string, quoted)
5340 pid_t pid, old_pid, old_pipeline_pgrp, old_async_pid;
5342 int result, fildes[2], function_value, pflags, rc, tflag;
5345 istring = (char *)NULL;
5347 /* Don't fork () if there is no need to. In the case of no command to
5348 run, just return NULL. */
5349 if (!string || !*string || (string[0] == '\n' && !string[1]))
5350 return ((WORD_DESC *)NULL);
5352 if (wordexp_only && read_but_dont_execute)
5354 last_command_exit_value = EX_WEXPCOMSUB;
5355 jump_to_top_level (EXITPROG);
5358 /* We're making the assumption here that the command substitution will
5359 eventually run a command from the file system. Since we'll run
5360 maybe_make_export_env in this subshell before executing that command,
5361 the parent shell and any other shells it starts will have to remake
5362 the environment. If we make it before we fork, other shells won't
5363 have to. Don't bother if we have any temporary variable assignments,
5364 though, because the export environment will be remade after this
5365 command completes anyway, but do it if all the words to be expanded
5366 are variable assignments. */
5367 if (subst_assign_varlist == 0 || garglist == 0)
5368 maybe_make_export_env (); /* XXX */
5370 /* Flags to pass to parse_and_execute() */
5371 pflags = (interactive && sourcelevel == 0) ? SEVAL_RESETLINE : 0;
5373 /* Pipe the output of executing STRING into the current shell. */
5374 if (pipe (fildes) < 0)
5376 sys_error (_("cannot make pipe for command substitution"));
5380 old_pid = last_made_pid;
5381 #if defined (JOB_CONTROL)
5382 old_pipeline_pgrp = pipeline_pgrp;
5383 /* Don't reset the pipeline pgrp if we're already a subshell in a pipeline. */
5384 if ((subshell_environment & SUBSHELL_PIPE) == 0)
5385 pipeline_pgrp = shell_pgrp;
5386 cleanup_the_pipeline ();
5387 #endif /* JOB_CONTROL */
5389 old_async_pid = last_asynchronous_pid;
5390 pid = make_child ((char *)NULL, subshell_environment&SUBSHELL_ASYNC);
5391 last_asynchronous_pid = old_async_pid;
5395 /* Reset the signal handlers in the child, but don't free the
5396 trap strings. Set a flag noting that we have to free the
5397 trap strings if we run trap to change a signal disposition. */
5398 reset_signal_handlers ();
5399 subshell_environment |= SUBSHELL_RESETTRAP;
5402 #if defined (JOB_CONTROL)
5403 /* XXX DO THIS ONLY IN PARENT ? XXX */
5404 set_sigchld_handler ();
5405 stop_making_children ();
5407 pipeline_pgrp = old_pipeline_pgrp;
5409 stop_making_children ();
5410 #endif /* JOB_CONTROL */
5414 sys_error (_("cannot make child for command substitution"));
5417 last_made_pid = old_pid;
5422 return ((WORD_DESC *)NULL);
5427 set_sigint_handler (); /* XXX */
5429 free_pushed_string_input ();
5431 if (dup2 (fildes[1], 1) < 0)
5433 sys_error (_("command_substitute: cannot duplicate pipe as fd 1"));
5434 exit (EXECUTION_FAILURE);
5437 /* If standard output is closed in the parent shell
5438 (such as after `exec >&-'), file descriptor 1 will be
5439 the lowest available file descriptor, and end up in
5440 fildes[0]. This can happen for stdin and stderr as well,
5441 but stdout is more important -- it will cause no output
5442 to be generated from this command. */
5443 if ((fildes[1] != fileno (stdin)) &&
5444 (fildes[1] != fileno (stdout)) &&
5445 (fildes[1] != fileno (stderr)))
5448 if ((fildes[0] != fileno (stdin)) &&
5449 (fildes[0] != fileno (stdout)) &&
5450 (fildes[0] != fileno (stderr)))
5454 /* Let stdio know the fd may have changed from text to binary mode, and
5455 make sure to preserve stdout line buffering. */
5456 freopen (NULL, "w", stdout);
5457 sh_setlinebuf (stdout);
5458 #endif /* __CYGWIN__ */
5460 /* The currently executing shell is not interactive. */
5463 /* This is a subshell environment. */
5464 subshell_environment |= SUBSHELL_COMSUB;
5466 /* When not in POSIX mode, command substitution does not inherit
5468 if (posixly_correct == 0)
5470 builtin_ignoring_errexit = 0;
5471 change_flag ('e', FLAG_OFF);
5475 remove_quoted_escapes (string);
5477 startup_state = 2; /* see if we can avoid a fork */
5478 /* Give command substitution a place to jump back to on failure,
5479 so we don't go back up to main (). */
5480 result = setjmp_nosigs (top_level);
5482 /* If we're running a command substitution inside a shell function,
5483 trap `return' so we don't return from the function in the subshell
5484 and go off to never-never land. */
5485 if (result == 0 && return_catch_flag)
5486 function_value = setjmp_nosigs (return_catch);
5490 if (result == ERREXIT)
5491 rc = last_command_exit_value;
5492 else if (result == EXITPROG)
5493 rc = last_command_exit_value;
5495 rc = EXECUTION_FAILURE;
5496 else if (function_value)
5497 rc = return_catch_value;
5501 rc = parse_and_execute (string, "command substitution", pflags|SEVAL_NOHIST);
5505 last_command_exit_value = rc;
5506 rc = run_exit_trap ();
5507 #if defined (PROCESS_SUBSTITUTION)
5508 unlink_fifo_list ();
5514 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
5516 #endif /* JOB_CONTROL && PGRP_PIPE */
5521 istring = read_comsub (fildes[0], quoted, &tflag);
5525 current_command_subst_pid = pid;
5526 last_command_exit_value = wait_for (pid);
5527 last_command_subst_pid = pid;
5528 last_made_pid = old_pid;
5530 #if defined (JOB_CONTROL)
5531 /* If last_command_exit_value > 128, then the substituted command
5532 was terminated by a signal. If that signal was SIGINT, then send
5533 SIGINT to ourselves. This will break out of loops, for instance. */
5534 if (last_command_exit_value == (128 + SIGINT) && last_command_exit_signal == SIGINT)
5535 kill (getpid (), SIGINT);
5537 /* wait_for gives the terminal back to shell_pgrp. If some other
5538 process group should have it, give it away to that group here.
5539 pipeline_pgrp is non-zero only while we are constructing a
5540 pipeline, so what we are concerned about is whether or not that
5541 pipeline was started in the background. A pipeline started in
5542 the background should never get the tty back here. */
5543 if (interactive && pipeline_pgrp != (pid_t)0 && (subshell_environment & SUBSHELL_ASYNC) == 0)
5544 give_terminal_to (pipeline_pgrp, 0);
5545 #endif /* JOB_CONTROL */
5547 ret = alloc_word_desc ();
5548 ret->word = istring;
5555 /********************************************************
5557 * Utility functions for parameter expansion *
5559 ********************************************************/
5561 #if defined (ARRAY_VARS)
5564 array_length_reference (s)
5575 var = array_variable_part (s, &t, &len);
5577 /* If unbound variables should generate an error, report one and return
5579 if ((var == 0 || invisible_p (var) || (assoc_p (var) == 0 && array_p (var) == 0)) && unbound_vars_is_error)
5583 last_command_exit_value = EXECUTION_FAILURE;
5588 else if (var == 0 || invisible_p (var))
5591 /* We support a couple of expansions for variables that are not arrays.
5592 We'll return the length of the value for v[0], and 1 for v[@] or
5593 v[*]. Return 0 for everything else. */
5595 array = array_p (var) ? array_cell (var) : (ARRAY *)NULL;
5596 h = assoc_p (var) ? assoc_cell (var) : (HASH_TABLE *)NULL;
5598 if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
5601 return (h ? assoc_num_elements (h) : 0);
5602 else if (array_p (var))
5603 return (array ? array_num_elements (array) : 0);
5605 return (var_isset (var) ? 1 : 0);
5611 akey = expand_assignment_string_to_string (t, 0); /* [ */
5613 if (akey == 0 || *akey == 0)
5615 err_badarraysub (t);
5619 t = assoc_reference (assoc_cell (var), akey);
5624 ind = array_expand_index (var, t, len);
5625 /* negative subscripts to indexed arrays count back from end */
5626 if (var && array_p (var) && ind < 0)
5627 ind = array_max_index (array_cell (var)) + 1 + ind;
5630 err_badarraysub (t);
5634 t = array_reference (array, ind);
5636 t = (ind == 0) ? value_cell (var) : (char *)NULL;
5639 len = MB_STRLEN (t);
5642 #endif /* ARRAY_VARS */
5645 valid_brace_expansion_word (name, var_is_special)
5649 if (DIGIT (*name) && all_digits (name))
5651 else if (var_is_special)
5653 #if defined (ARRAY_VARS)
5654 else if (valid_array_reference (name))
5656 #endif /* ARRAY_VARS */
5657 else if (legal_identifier (name))
5664 chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at)
5667 int *quoted_dollar_atp, *contains_dollar_at;
5673 if (quoted_dollar_atp)
5674 *quoted_dollar_atp = 0;
5675 if (contains_dollar_at)
5676 *contains_dollar_at = 0;
5680 /* check for $@ and $* */
5681 if (name[0] == '@' && name[1] == 0)
5683 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5684 *quoted_dollar_atp = 1;
5685 if (contains_dollar_at)
5686 *contains_dollar_at = 1;
5689 else if (name[0] == '*' && name[1] == '\0' && quoted == 0)
5691 if (contains_dollar_at)
5692 *contains_dollar_at = 1;
5696 /* Now check for ${array[@]} and ${array[*]} */
5697 #if defined (ARRAY_VARS)
5698 else if (valid_array_reference (name))
5700 temp1 = mbschr (name, '[');
5701 if (temp1 && temp1[1] == '@' && temp1[2] == ']')
5703 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5704 *quoted_dollar_atp = 1;
5705 if (contains_dollar_at)
5706 *contains_dollar_at = 1;
5709 /* ${array[*]}, when unquoted, should be treated like ${array[@]},
5710 which should result in separate words even when IFS is unset. */
5711 if (temp1 && temp1[1] == '*' && temp1[2] == ']' && quoted == 0)
5713 if (contains_dollar_at)
5714 *contains_dollar_at = 1;
5722 /* Parameter expand NAME, and return a new string which is the expansion,
5723 or NULL if there was no expansion.
5724 VAR_IS_SPECIAL is non-zero if NAME is one of the special variables in
5725 the shell, e.g., "@", "$", "*", etc. QUOTED, if non-zero, means that
5726 NAME was found inside of a double-quoted expression. */
5728 parameter_brace_expand_word (name, var_is_special, quoted, pflags, indp)
5730 int var_is_special, quoted, pflags;
5747 /* Handle multiple digit arguments, as in ${11}. */
5748 if (legal_number (name, &arg_index))
5750 tt = get_dollar_var_value (arg_index);
5752 temp = (*tt && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5754 : quote_escapes (tt);
5756 temp = (char *)NULL;
5759 else if (var_is_special) /* ${@} */
5762 tt = (char *)xmalloc (2 + strlen (name));
5763 tt[sindex = 0] = '$';
5764 strcpy (tt + 1, name);
5766 ret = param_expand (tt, &sindex, quoted, (int *)NULL, (int *)NULL,
5767 (int *)NULL, (int *)NULL, pflags);
5770 #if defined (ARRAY_VARS)
5771 else if (valid_array_reference (name))
5774 /* XXX - does this leak if name[@] or name[*]? */
5775 if (pflags & PF_ASSIGNRHS)
5777 temp = array_variable_name (name, &tt, (int *)0);
5778 if (ALL_ELEMENT_SUB (tt[0]) && tt[1] == ']')
5779 temp = array_value (name, quoted|Q_DOUBLE_QUOTES, 0, &atype, &ind);
5781 temp = array_value (name, quoted, 0, &atype, &ind);
5784 temp = array_value (name, quoted, 0, &atype, &ind);
5785 if (atype == 0 && temp)
5787 temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5788 ? quote_string (temp)
5789 : quote_escapes (temp);
5790 rflags |= W_ARRAYIND;
5794 else if (atype == 1 && temp && QUOTED_NULL (temp) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5795 rflags |= W_HASQUOTEDNULL;
5798 else if (var = find_variable (name))
5800 if (var_isset (var) && invisible_p (var) == 0)
5802 #if defined (ARRAY_VARS)
5804 temp = assoc_reference (assoc_cell (var), "0");
5805 else if (array_p (var))
5806 temp = array_reference (array_cell (var), 0);
5808 temp = value_cell (var);
5810 temp = value_cell (var);
5814 temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5815 ? quote_string (temp)
5816 : quote_escapes (temp);
5819 temp = (char *)NULL;
5821 else if (var = find_variable_last_nameref (name))
5823 temp = nameref_cell (var);
5824 #if defined (ARRAY_VARS)
5825 /* Handle expanding nameref whose value is x[n] */
5826 if (temp && *temp && valid_array_reference (temp))
5829 goto expand_arrayref;
5833 /* y=2 ; typeset -n x=y; echo ${x} is not the same as echo ${2} in ksh */
5834 if (temp && *temp && legal_identifier (temp) == 0)
5836 last_command_exit_value = EXECUTION_FAILURE;
5837 report_error (_("%s: invalid variable name for name reference"), temp);
5838 temp = &expand_param_error;
5841 temp = (char *)NULL;
5844 temp = (char *)NULL;
5848 ret = alloc_word_desc ();
5850 ret->flags |= rflags;
5856 parameter_brace_find_indir (name, var_is_special, quoted, find_nameref)
5858 int var_is_special, quoted, find_nameref;
5864 if (find_nameref && var_is_special == 0 && (v = find_variable_last_nameref (name)) &&
5865 nameref_p (v) && (t = nameref_cell (v)) && *t)
5866 return (savestring (t));
5868 /* If var_is_special == 0, and name is not an array reference, this does
5869 more expansion than necessary. It should really look up the variable's
5870 value and not try to expand it. */
5871 w = parameter_brace_expand_word (name, var_is_special, quoted, PF_IGNUNBOUND, 0);
5873 /* Have to dequote here if necessary */
5876 temp = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
5877 ? dequote_string (t)
5878 : dequote_escapes (t);
5882 dispose_word_desc (w);
5887 /* Expand an indirect reference to a variable: ${!NAME} expands to the
5888 value of the variable whose name is the value of NAME. */
5890 parameter_brace_expand_indir (name, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at)
5892 int var_is_special, quoted;
5893 int *quoted_dollar_atp, *contains_dollar_at;
5899 /* See if it's a nameref first, behave in ksh93-compatible fashion.
5900 There is at least one incompatibility: given ${!foo[0]} where foo=bar,
5901 bash performs an indirect lookup on foo[0] and expands the result;
5902 ksh93 expands bar[0]. We could do that here -- there are enough usable
5903 primitives to do that -- but do not at this point. */
5904 if (var_is_special == 0 && (v = find_variable_last_nameref (name)))
5906 if (nameref_p (v) && (t = nameref_cell (v)) && *t)
5908 w = alloc_word_desc ();
5909 w->word = savestring (t);
5915 t = parameter_brace_find_indir (name, var_is_special, quoted, 0);
5917 chk_atstar (t, quoted, quoted_dollar_atp, contains_dollar_at);
5919 return (WORD_DESC *)NULL;
5921 w = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted, 0, 0);
5927 /* Expand the right side of a parameter expansion of the form ${NAMEcVALUE},
5928 depending on the value of C, the separating character. C can be one of
5929 "-", "+", or "=". QUOTED is true if the entire brace expression occurs
5930 between double quotes. */
5932 parameter_brace_expand_rhs (name, value, c, quoted, qdollaratp, hasdollarat)
5934 int c, quoted, *qdollaratp, *hasdollarat;
5938 char *t, *t1, *temp;
5941 /* If the entire expression is between double quotes, we want to treat
5942 the value as a double-quoted string, with the exception that we strip
5943 embedded unescaped double quotes (for sh backwards compatibility). */
5944 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *value)
5947 temp = string_extract_double_quoted (value, &hasdol, 1);
5952 w = alloc_word_desc ();
5954 /* XXX was 0 not quoted */
5955 l = *temp ? expand_string_for_rhs (temp, quoted, &hasdol, (int *)NULL)
5958 *hasdollarat = hasdol || (l && l->next);
5963 /* The expansion of TEMP returned something. We need to treat things
5964 slightly differently if HASDOL is non-zero. If we have "$@", the
5965 individual words have already been quoted. We need to turn them
5966 into a string with the words separated by the first character of
5967 $IFS without any additional quoting, so string_list_dollar_at won't
5968 do the right thing. We use string_list_dollar_star instead. */
5969 temp = (hasdol || l->next) ? string_list_dollar_star (l) : string_list (l);
5971 /* If l->next is not null, we know that TEMP contained "$@", since that
5972 is the only expansion that creates more than one word. */
5973 if (qdollaratp && ((hasdol && quoted) || l->next))
5975 /* If we have a quoted null result (QUOTED_NULL(temp)) and the word is
5976 a quoted null (l->next == 0 && QUOTED_NULL(l->word->word)), the
5977 flags indicate it (l->word->flags & W_HASQUOTEDNULL), and the
5978 expansion is quoted (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
5979 (which is more paranoia than anything else), we need to return the
5980 quoted null string and set the flags to indicate it. */
5981 if (l->next == 0 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp) && QUOTED_NULL (l->word->word) && (l->word->flags & W_HASQUOTEDNULL))
5983 w->flags |= W_HASQUOTEDNULL;
5987 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && hasdol)
5989 /* The brace expansion occurred between double quotes and there was
5990 a $@ in TEMP. It does not matter if the $@ is quoted, as long as
5991 it does not expand to anything. In this case, we want to return
5992 a quoted empty string. */
5993 temp = make_quoted_char ('\0');
5994 w->flags |= W_HASQUOTEDNULL;
5997 temp = (char *)NULL;
5999 if (c == '-' || c == '+')
6006 t = temp ? savestring (temp) : savestring ("");
6007 t1 = dequote_string (t);
6009 #if defined (ARRAY_VARS)
6010 if (valid_array_reference (name))
6011 assign_array_element (name, t1, 0);
6013 #endif /* ARRAY_VARS */
6014 bind_variable (name, t1, 0);
6016 if (STREQ (name, "IFS") == 0)
6018 stupidly_hack_special_variables (name);
6020 /* From Posix group discussion Feb-March 2010. Issue 7 0000221 */
6027 /* Deal with the right hand side of a ${name:?value} expansion in the case
6028 that NAME is null or not set. If VALUE is non-null it is expanded and
6029 used as the error message to print, otherwise a standard message is
6032 parameter_brace_expand_error (name, value)
6038 last_command_exit_value = EXECUTION_FAILURE; /* ensure it's non-zero */
6039 if (value && *value)
6041 l = expand_string (value, 0);
6042 temp = string_list (l);
6043 report_error ("%s: %s", name, temp ? temp : ""); /* XXX was value not "" */
6048 report_error (_("%s: parameter null or not set"), name);
6050 /* Free the data we have allocated during this expansion, since we
6051 are about to longjmp out. */
6056 /* Return 1 if NAME is something for which parameter_brace_expand_length is
6059 valid_length_expression (name)
6062 return (name[1] == '\0' || /* ${#} */
6063 ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0') || /* special param */
6064 (DIGIT (name[1]) && all_digits (name + 1)) || /* ${#11} */
6065 #if defined (ARRAY_VARS)
6066 valid_array_reference (name + 1) || /* ${#a[7]} */
6068 legal_identifier (name + 1)); /* ${#PS1} */
6071 /* Handle the parameter brace expansion that requires us to return the
6072 length of a parameter. */
6074 parameter_brace_expand_length (name)
6078 intmax_t number, arg_index;
6080 #if defined (ARRAY_VARS)
6084 if (name[1] == '\0') /* ${#} */
6085 number = number_of_args ();
6086 else if ((name[1] == '@' || name[1] == '*') && name[2] == '\0') /* ${#@}, ${#*} */
6087 number = number_of_args ();
6088 else if ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0')
6090 /* Take the lengths of some of the shell's special parameters. */
6094 t = which_set_flags ();
6097 t = itos (last_command_exit_value);
6100 t = itos (dollar_dollar_pid);
6103 if (last_asynchronous_pid == NO_PID)
6104 t = (char *)NULL; /* XXX - error if set -u set? */
6106 t = itos (last_asynchronous_pid);
6109 t = itos (number_of_args ());
6112 number = STRLEN (t);
6115 #if defined (ARRAY_VARS)
6116 else if (valid_array_reference (name + 1))
6117 number = array_length_reference (name + 1);
6118 #endif /* ARRAY_VARS */
6123 if (legal_number (name + 1, &arg_index)) /* ${#1} */
6125 t = get_dollar_var_value (arg_index);
6126 if (t == 0 && unbound_vars_is_error)
6128 number = MB_STRLEN (t);
6131 #if defined (ARRAY_VARS)
6132 else if ((var = find_variable (name + 1)) && (invisible_p (var) == 0) && (array_p (var) || assoc_p (var)))
6135 t = assoc_reference (assoc_cell (var), "0");
6137 t = array_reference (array_cell (var), 0);
6138 if (t == 0 && unbound_vars_is_error)
6140 number = MB_STRLEN (t);
6145 newname = savestring (name);
6147 list = expand_string (newname, Q_DOUBLE_QUOTES);
6148 t = list ? string_list (list) : (char *)NULL;
6151 dispose_words (list);
6153 number = t ? MB_STRLEN (t) : 0;
6161 /* Skip characters in SUBSTR until DELIM. SUBSTR is an arithmetic expression,
6162 so we do some ad-hoc parsing of an arithmetic expression to find
6163 the first DELIM, instead of using strchr(3). Two rules:
6164 1. If the substring contains a `(', read until closing `)'.
6165 2. If the substring contains a `?', read past one `:' for each `?'.
6169 skiparith (substr, delim)
6174 int skipcol, pcount, i;
6177 sublen = strlen (substr);
6178 i = skipcol = pcount = 0;
6181 /* Balance parens */
6182 if (substr[i] == LPAREN)
6188 if (substr[i] == RPAREN && pcount)
6196 ADVANCE_CHAR (substr, sublen, i);
6200 /* Skip one `:' for each `?' */
6201 if (substr[i] == ':' && skipcol)
6207 if (substr[i] == delim)
6209 if (substr[i] == '?')
6215 ADVANCE_CHAR (substr, sublen, i);
6218 return (substr + i);
6221 /* Verify and limit the start and end of the desired substring. If
6222 VTYPE == 0, a regular shell variable is being used; if it is 1,
6223 then the positional parameters are being used; if it is 2, then
6224 VALUE is really a pointer to an array variable that should be used.
6225 Return value is 1 if both values were OK, 0 if there was a problem
6226 with an invalid expression, or -1 if the values were out of range. */
6228 verify_substring_values (v, value, substr, vtype, e1p, e2p)
6230 char *value, *substr;
6232 intmax_t *e1p, *e2p;
6234 char *t, *temp1, *temp2;
6237 #if defined (ARRAY_VARS)
6242 /* duplicate behavior of strchr(3) */
6243 t = skiparith (substr, ':');
6244 if (*t && *t == ':')
6249 temp1 = expand_arith_string (substr, Q_DOUBLE_QUOTES);
6250 *e1p = evalexp (temp1, &expok);
6255 len = -1; /* paranoia */
6259 case VT_ARRAYMEMBER:
6260 len = MB_STRLEN (value);
6263 len = number_of_args () + 1;
6265 len++; /* add one arg if counting from $0 */
6267 #if defined (ARRAY_VARS)
6269 /* For arrays, the first value deals with array indices. Negative
6270 offsets count from one past the array's maximum index. Associative
6271 arrays treat the number of elements as the maximum index. */
6275 len = assoc_num_elements (h) + (*e1p < 0);
6280 len = array_max_index (a) + (*e1p < 0); /* arrays index from 0 to n - 1 */
6286 if (len == -1) /* paranoia */
6289 if (*e1p < 0) /* negative offsets count from end */
6292 if (*e1p > len || *e1p < 0)
6295 #if defined (ARRAY_VARS)
6296 /* For arrays, the second offset deals with the number of elements. */
6297 if (vtype == VT_ARRAYVAR)
6298 len = assoc_p (v) ? assoc_num_elements (h) : array_num_elements (a);
6304 temp2 = savestring (t);
6305 temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES);
6308 *e2p = evalexp (temp1, &expok);
6313 if ((vtype == VT_ARRAYVAR || vtype == VT_POSPARMS) && *e2p < 0)
6315 /* bash-4.3: allow positional parameter length < 0 to count backwards
6316 from end of positional parameters */
6317 if (vtype == VT_ARRAYVAR && *e2p < 0)
6320 internal_error (_("%s: substring expression < 0"), t);
6323 #if defined (ARRAY_VARS)
6324 /* In order to deal with sparse arrays, push the intelligence about how
6325 to deal with the number of elements desired down to the array-
6326 specific functions. */
6327 if (vtype != VT_ARRAYVAR)
6333 if (*e2p < 0 || *e2p < *e1p)
6335 internal_error (_("%s: substring expression < 0"), t);
6340 *e2p += *e1p; /* want E2 chars starting at E1 */
6351 /* Return the type of variable specified by VARNAME (simple variable,
6352 positional param, or array variable). Also return the value specified
6353 by VARNAME (value of a variable or a reference to an array element).
6354 QUOTED is the standard description of quoting state, using Q_* defines.
6355 FLAGS is currently a set of flags to pass to array_value. If IND is
6356 non-null and not INTMAX_MIN, and FLAGS includes AV_USEIND, IND is
6357 passed to array_value so the array index is not computed again.
6358 If this returns VT_VARIABLE, the caller assumes that CTLESC and CTLNUL
6359 characters in the value are quoted with CTLESC and takes appropriate
6360 steps. For convenience, *VALP is set to the dequoted VALUE. */
6362 get_var_and_type (varname, value, ind, quoted, flags, varp, valp)
6363 char *varname, *value;
6369 int vtype, want_indir;
6372 #if defined (ARRAY_VARS)
6377 want_indir = *varname == '!' &&
6378 (legal_variable_starter ((unsigned char)varname[1]) || DIGIT (varname[1])
6379 || VALID_INDIR_PARAM (varname[1]));
6381 vname = parameter_brace_find_indir (varname+1, SPECIAL_VAR (varname, 1), quoted, 1);
6385 /* This sets vtype to VT_VARIABLE or VT_POSPARMS */
6386 vtype = (vname[0] == '@' || vname[0] == '*') && vname[1] == '\0';
6387 if (vtype == VT_POSPARMS && vname[0] == '*')
6388 vtype |= VT_STARSUB;
6389 *varp = (SHELL_VAR *)NULL;
6391 #if defined (ARRAY_VARS)
6392 if (valid_array_reference (vname))
6394 v = array_variable_part (vname, &temp, (int *)0);
6395 /* If we want to signal array_value to use an already-computed index,
6396 set LIND to that index */
6397 lind = (ind != INTMAX_MIN && (flags & AV_USEIND)) ? ind : 0;
6398 if (v && invisible_p (v))
6400 vtype = VT_ARRAYMEMBER;
6401 *varp = (SHELL_VAR *)NULL;
6402 *valp = (char *)NULL;
6404 if (v && (array_p (v) || assoc_p (v)))
6406 if (ALL_ELEMENT_SUB (temp[0]) && temp[1] == ']')
6408 /* Callers have to differentiate between indexed and associative */
6409 vtype = VT_ARRAYVAR;
6411 vtype |= VT_STARSUB;
6412 *valp = array_p (v) ? (char *)array_cell (v) : (char *)assoc_cell (v);
6416 vtype = VT_ARRAYMEMBER;
6417 *valp = array_value (vname, Q_DOUBLE_QUOTES, flags, (int *)NULL, &lind);
6421 else if (v && (ALL_ELEMENT_SUB (temp[0]) && temp[1] == ']'))
6423 vtype = VT_VARIABLE;
6425 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6426 *valp = dequote_string (value);
6428 *valp = dequote_escapes (value);
6432 vtype = VT_ARRAYMEMBER;
6434 *valp = array_value (vname, Q_DOUBLE_QUOTES, flags, (int *)NULL, &lind);
6437 else if ((v = find_variable (vname)) && (invisible_p (v) == 0) && (assoc_p (v) || array_p (v)))
6439 vtype = VT_ARRAYMEMBER;
6441 *valp = assoc_p (v) ? assoc_reference (assoc_cell (v), "0") : array_reference (array_cell (v), 0);
6446 if (value && vtype == VT_VARIABLE)
6448 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6449 *valp = dequote_string (value);
6451 *valp = dequote_escapes (value);
6463 /******************************************************/
6465 /* Functions to extract substrings of variable values */
6467 /******************************************************/
6469 #if defined (HANDLE_MULTIBYTE)
6470 /* Character-oriented rather than strictly byte-oriented substrings. S and
6471 E, rather being strict indices into STRING, indicate character (possibly
6472 multibyte character) positions that require calculation.
6473 Used by the ${param:offset[:length]} expansion. */
6475 mb_substring (string, s, e)
6480 int start, stop, i, slen;
6484 /* Don't need string length in ADVANCE_CHAR unless multibyte chars possible. */
6485 slen = (MB_CUR_MAX > 1) ? STRLEN (string) : 0;
6488 while (string[start] && i--)
6489 ADVANCE_CHAR (string, slen, start);
6492 while (string[stop] && i--)
6493 ADVANCE_CHAR (string, slen, stop);
6494 tt = substring (string, start, stop);
6499 /* Process a variable substring expansion: ${name:e1[:e2]}. If VARNAME
6500 is `@', use the positional parameters; otherwise, use the value of
6501 VARNAME. If VARNAME is an array variable, use the array elements. */
6504 parameter_brace_substring (varname, value, ind, substr, quoted, flags)
6505 char *varname, *value;
6511 int vtype, r, starsub;
6512 char *temp, *val, *tt, *oname;
6516 return ((char *)NULL);
6518 oname = this_command_name;
6519 this_command_name = varname;
6521 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
6524 this_command_name = oname;
6525 return ((char *)NULL);
6528 starsub = vtype & VT_STARSUB;
6529 vtype &= ~VT_STARSUB;
6531 r = verify_substring_values (v, val, substr, vtype, &e1, &e2);
6532 this_command_name = oname;
6535 if (vtype == VT_VARIABLE)
6537 return ((r == 0) ? &expand_param_error : (char *)NULL);
6543 case VT_ARRAYMEMBER:
6544 #if defined (HANDLE_MULTIBYTE)
6546 tt = mb_substring (val, e1, e2);
6549 tt = substring (val, e1, e2);
6551 if (vtype == VT_VARIABLE)
6553 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6554 temp = quote_string (tt);
6556 temp = tt ? quote_escapes (tt) : (char *)NULL;
6560 tt = pos_params (varname, e1, e2, quoted);
6561 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
6563 temp = tt ? quote_escapes (tt) : (char *)NULL;
6569 #if defined (ARRAY_VARS)
6572 /* we convert to list and take first e2 elements starting at e1th
6573 element -- officially undefined for now */
6574 temp = assoc_subrange (assoc_cell (v), e1, e2, starsub, quoted);
6576 /* We want E2 to be the number of elements desired (arrays can be sparse,
6577 so verify_substring_values just returns the numbers specified and we
6578 rely on array_subrange to understand how to deal with them). */
6579 temp = array_subrange (array_cell (v), e1, e2, starsub, quoted);
6580 /* array_subrange now calls array_quote_escapes as appropriate, so the
6581 caller no longer needs to. */
6585 temp = (char *)NULL;
6591 /****************************************************************/
6593 /* Functions to perform pattern substitution on variable values */
6595 /****************************************************************/
6598 shouldexp_replacement (s)
6603 for (p = s; p && *p; p++)
6614 pat_subst (string, pat, rep, mflags)
6615 char *string, *pat, *rep;
6618 char *ret, *s, *e, *str, *rstr, *mstr;
6619 int rsize, rptr, l, replen, mtype, rxpand, rslen, mlen;
6622 return (savestring (""));
6624 mtype = mflags & MATCH_TYPEMASK;
6626 #if 0 /* bash-4.2 ? */
6627 rxpand = (rep && *rep) ? shouldexp_replacement (rep) : 0;
6633 * 1. A null pattern with mtype == MATCH_BEG means to prefix STRING
6634 * with REP and return the result.
6635 * 2. A null pattern with mtype == MATCH_END means to append REP to
6636 * STRING and return the result.
6637 * These don't understand or process `&' in the replacement string.
6639 if ((pat == 0 || *pat == 0) && (mtype == MATCH_BEG || mtype == MATCH_END))
6641 replen = STRLEN (rep);
6642 l = STRLEN (string);
6643 ret = (char *)xmalloc (replen + l + 2);
6645 strcpy (ret, string);
6646 else if (mtype == MATCH_BEG)
6649 strcpy (ret + replen, string);
6653 strcpy (ret, string);
6654 strcpy (ret + l, rep);
6659 ret = (char *)xmalloc (rsize = 64);
6662 for (replen = STRLEN (rep), rptr = 0, str = string;;)
6664 if (match_pattern (str, pat, mtype, &s, &e) == 0)
6672 mstr = xmalloc (mlen + 1);
6673 for (x = 0; x < mlen; x++)
6676 rstr = strcreplace (rep, '&', mstr, 0);
6677 rslen = strlen (rstr);
6685 RESIZE_MALLOCED_BUFFER (ret, rptr, (l + rslen), rsize, 64);
6687 /* OK, now copy the leading unmatched portion of the string (from
6688 str to s) to ret starting at rptr (the current offset). Then copy
6689 the replacement string at ret + rptr + (s - str). Increment
6690 rptr (if necessary) and str and go on. */
6693 strncpy (ret + rptr, str, l);
6698 strncpy (ret + rptr, rstr, rslen);
6701 str = e; /* e == end of match */
6706 if (((mflags & MATCH_GLOBREP) == 0) || mtype != MATCH_ANY)
6711 /* On a zero-length match, make sure we copy one character, since
6712 we increment one character to avoid infinite recursion. */
6713 RESIZE_MALLOCED_BUFFER (ret, rptr, 1, rsize, 64);
6714 ret[rptr++] = *str++;
6715 e++; /* avoid infinite recursion on zero-length match */
6719 /* Now copy the unmatched portion of the input string */
6722 RESIZE_MALLOCED_BUFFER (ret, rptr, STRLEN(str) + 1, rsize, 64);
6723 strcpy (ret + rptr, str);
6731 /* Do pattern match and replacement on the positional parameters. */
6733 pos_params_pat_subst (string, pat, rep, mflags)
6734 char *string, *pat, *rep;
6737 WORD_LIST *save, *params;
6742 save = params = list_rest_of_args ();
6744 return ((char *)NULL);
6746 for ( ; params; params = params->next)
6748 ret = pat_subst (params->word->word, pat, rep, mflags);
6749 w = alloc_word_desc ();
6750 w->word = ret ? ret : savestring ("");
6751 dispose_word (params->word);
6755 pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
6756 qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
6758 ret = string_list_pos_params (pchar, save, qflags);
6760 dispose_words (save);
6765 /* Perform pattern substitution on VALUE, which is the expansion of
6766 VARNAME. PATSUB is an expression supplying the pattern to match
6767 and the string to substitute. QUOTED is a flags word containing
6768 the type of quoting currently in effect. */
6770 parameter_brace_patsub (varname, value, ind, patsub, quoted, flags)
6771 char *varname, *value;
6776 int vtype, mflags, starsub, delim;
6777 char *val, *temp, *pat, *rep, *p, *lpatsub, *tt;
6781 return ((char *)NULL);
6783 this_command_name = varname;
6785 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
6787 return ((char *)NULL);
6789 starsub = vtype & VT_STARSUB;
6790 vtype &= ~VT_STARSUB;
6793 /* PATSUB is never NULL when this is called. */
6796 mflags |= MATCH_GLOBREP;
6800 /* Malloc this because expand_string_if_necessary or one of the expansion
6801 functions in its call chain may free it on a substitution error. */
6802 lpatsub = savestring (patsub);
6804 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6805 mflags |= MATCH_QUOTED;
6808 mflags |= MATCH_STARSUB;
6810 /* If the pattern starts with a `/', make sure we skip over it when looking
6811 for the replacement delimiter. */
6812 delim = skip_to_delim (lpatsub, ((*patsub == '/') ? 1 : 0), "/", 0);
6813 if (lpatsub[delim] == '/')
6816 rep = lpatsub + delim + 1;
6821 if (rep && *rep == '\0')
6824 /* Perform the same expansions on the pattern as performed by the
6825 pattern removal expansions. */
6826 pat = getpattern (lpatsub, quoted, 1);
6830 /* We want to perform quote removal on the expanded replacement even if
6831 the entire expansion is double-quoted because the parser and string
6832 extraction functions treated quotes in the replacement string as
6833 special. THIS IS NOT BACKWARDS COMPATIBLE WITH BASH-4.2. */
6834 if (shell_compatibility_level > 42)
6835 rep = expand_string_if_necessary (rep, quoted & ~(Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT), expand_string_unsplit);
6836 /* This is the bash-4.2 code. */
6837 else if ((mflags & MATCH_QUOTED) == 0)
6838 rep = expand_string_if_necessary (rep, quoted, expand_string_unsplit);
6840 rep = expand_string_to_string_internal (rep, quoted, expand_string_unsplit);
6843 /* ksh93 doesn't allow the match specifier to be a part of the expanded
6844 pattern. This is an extension. Make sure we don't anchor the pattern
6845 at the beginning or end of the string if we're doing global replacement,
6848 if (mflags & MATCH_GLOBREP)
6849 mflags |= MATCH_ANY;
6850 else if (pat && pat[0] == '#')
6852 mflags |= MATCH_BEG;
6855 else if (pat && pat[0] == '%')
6857 mflags |= MATCH_END;
6861 mflags |= MATCH_ANY;
6863 /* OK, we now want to substitute REP for PAT in VAL. If
6864 flags & MATCH_GLOBREP is non-zero, the substitution is done
6865 everywhere, otherwise only the first occurrence of PAT is
6866 replaced. The pattern matching code doesn't understand
6867 CTLESC quoting CTLESC and CTLNUL so we use the dequoted variable
6868 values passed in (VT_VARIABLE) so the pattern substitution
6869 code works right. We need to requote special chars after
6870 we're done for VT_VARIABLE and VT_ARRAYMEMBER, and for the
6871 other cases if QUOTED == 0, since the posparams and arrays
6872 indexed by * or @ do special things when QUOTED != 0. */
6877 case VT_ARRAYMEMBER:
6878 temp = pat_subst (val, p, rep, mflags);
6879 if (vtype == VT_VARIABLE)
6883 tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);
6889 temp = pos_params_pat_subst (val, p, rep, mflags);
6890 if (temp && (mflags & MATCH_QUOTED) == 0)
6892 tt = quote_escapes (temp);
6897 #if defined (ARRAY_VARS)
6899 temp = assoc_p (v) ? assoc_patsub (assoc_cell (v), p, rep, mflags)
6900 : array_patsub (array_cell (v), p, rep, mflags);
6901 /* Don't call quote_escapes anymore; array_patsub calls
6902 array_quote_escapes as appropriate before adding the
6903 space separators; ditto for assoc_patsub. */
6915 /****************************************************************/
6917 /* Functions to perform case modification on variable values */
6919 /****************************************************************/
6921 /* Do case modification on the positional parameters. */
6924 pos_params_modcase (string, pat, modop, mflags)
6929 WORD_LIST *save, *params;
6934 save = params = list_rest_of_args ();
6936 return ((char *)NULL);
6938 for ( ; params; params = params->next)
6940 ret = sh_modcase (params->word->word, pat, modop);
6941 w = alloc_word_desc ();
6942 w->word = ret ? ret : savestring ("");
6943 dispose_word (params->word);
6947 pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
6948 qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
6950 ret = string_list_pos_params (pchar, save, qflags);
6951 dispose_words (save);
6956 /* Perform case modification on VALUE, which is the expansion of
6957 VARNAME. MODSPEC is an expression supplying the type of modification
6958 to perform. QUOTED is a flags word containing the type of quoting
6959 currently in effect. */
6961 parameter_brace_casemod (varname, value, ind, modspec, patspec, quoted, flags)
6962 char *varname, *value;
6967 int vtype, starsub, modop, mflags, x;
6968 char *val, *temp, *pat, *p, *lpat, *tt;
6972 return ((char *)NULL);
6974 this_command_name = varname;
6976 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
6978 return ((char *)NULL);
6980 starsub = vtype & VT_STARSUB;
6981 vtype &= ~VT_STARSUB;
6985 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6986 mflags |= MATCH_QUOTED;
6988 mflags |= MATCH_STARSUB;
6993 x = p && p[0] == modspec;
6994 modop = x ? CASE_UPPER : CASE_UPFIRST;
6997 else if (modspec == ',')
6999 x = p && p[0] == modspec;
7000 modop = x ? CASE_LOWER : CASE_LOWFIRST;
7003 else if (modspec == '~')
7005 x = p && p[0] == modspec;
7006 modop = x ? CASE_TOGGLEALL : CASE_TOGGLE;
7010 lpat = p ? savestring (p) : 0;
7011 /* Perform the same expansions on the pattern as performed by the
7012 pattern removal expansions. FOR LATER */
7013 pat = lpat ? getpattern (lpat, quoted, 1) : 0;
7015 /* OK, now we do the case modification. */
7019 case VT_ARRAYMEMBER:
7020 temp = sh_modcase (val, pat, modop);
7021 if (vtype == VT_VARIABLE)
7025 tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);
7032 temp = pos_params_modcase (val, pat, modop, mflags);
7033 if (temp && (mflags & MATCH_QUOTED) == 0)
7035 tt = quote_escapes (temp);
7041 #if defined (ARRAY_VARS)
7043 temp = assoc_p (v) ? assoc_modcase (assoc_cell (v), pat, modop, mflags)
7044 : array_modcase (array_cell (v), pat, modop, mflags);
7045 /* Don't call quote_escapes; array_modcase calls array_quote_escapes
7046 as appropriate before adding the space separators; ditto for
7058 /* Check for unbalanced parens in S, which is the contents of $(( ... )). If
7059 any occur, this must be a nested command substitution, so return 0.
7060 Otherwise, return 1. A valid arithmetic expression must always have a
7061 ( before a matching ), so any cases where there are more right parens
7062 means that this must not be an arithmetic expression, though the parser
7063 will not accept it without a balanced total number of parens. */
7065 chk_arithsub (s, len)
7077 else if (s[i] == RPAREN)
7087 ADVANCE_CHAR (s, len, i);
7093 ADVANCE_CHAR (s, len, i);
7097 i = skip_single_quoted (s, len, ++i);
7101 i = skip_double_quoted ((char *)s, len, ++i);
7106 return (count == 0);
7109 /****************************************************************/
7111 /* Functions to perform parameter expansion on a string */
7113 /****************************************************************/
7115 /* ${[#][!]name[[:][^[^]][,[,]]#[#]%[%]-=?+[word][:e1[:e2]]]} */
7117 parameter_brace_expand (string, indexp, quoted, pflags, quoted_dollar_atp, contains_dollar_at)
7119 int *indexp, quoted, *quoted_dollar_atp, *contains_dollar_at, pflags;
7121 int check_nullness, var_is_set, var_is_null, var_is_special;
7122 int want_substring, want_indir, want_patsub, want_casemod;
7123 char *name, *value, *temp, *temp1;
7124 WORD_DESC *tdesc, *ret;
7125 int t_index, sindex, c, tflag, modspec;
7129 temp = temp1 = value = (char *)NULL;
7130 var_is_set = var_is_null = var_is_special = check_nullness = 0;
7131 want_substring = want_indir = want_patsub = want_casemod = 0;
7135 /* ${#var} doesn't have any of the other parameter expansions on it. */
7136 if (string[t_index] == '#' && legal_variable_starter (string[t_index+1])) /* {{ */
7137 name = string_extract (string, &t_index, "}", SX_VARNAME);
7139 #if defined (CASEMOD_EXPANSIONS)
7140 /* To enable case-toggling expansions using the `~' operator character
7141 change the 1 to 0. */
7142 # if defined (CASEMOD_CAPCASE)
7143 name = string_extract (string, &t_index, "#%^,~:-=?+/}", SX_VARNAME);
7145 name = string_extract (string, &t_index, "#%^,:-=?+/}", SX_VARNAME);
7146 # endif /* CASEMOD_CAPCASE */
7148 name = string_extract (string, &t_index, "#%:-=?+/}", SX_VARNAME);
7149 #endif /* CASEMOD_EXPANSIONS */
7156 /* If the name really consists of a special variable, then make sure
7157 that we have the entire name. We don't allow indirect references
7158 to special variables except `#', `?', `@' and `*'. */
7159 if ((sindex == t_index && VALID_SPECIAL_LENGTH_PARAM (string[t_index])) ||
7160 (sindex == t_index - 1 && string[sindex] == '!' && VALID_INDIR_PARAM (string[t_index])))
7163 temp1 = string_extract (string, &t_index, "#%:-=?+/}", 0);
7164 name = (char *)xrealloc (name, 3 + (strlen (temp1)));
7165 *name = string[sindex];
7166 if (string[sindex] == '!')
7168 /* indirect reference of $#, $?, $@, or $* */
7169 name[1] = string[sindex + 1];
7170 strcpy (name + 2, temp1);
7173 strcpy (name + 1, temp1);
7178 /* Find out what character ended the variable name. Then
7179 do the appropriate thing. */
7180 if (c = string[sindex])
7183 /* If c is followed by one of the valid parameter expansion
7184 characters, move past it as normal. If not, assume that
7185 a substring specification is being given, and do not move
7187 if (c == ':' && VALID_PARAM_EXPAND_CHAR (string[sindex]))
7190 if (c = string[sindex])
7193 else if (c == ':' && string[sindex] != RBRACE)
7195 else if (c == '/' /* && string[sindex] != RBRACE */) /* XXX */
7197 #if defined (CASEMOD_EXPANSIONS)
7198 else if (c == '^' || c == ',' || c == '~')
7205 /* Catch the valid and invalid brace expressions that made it through the
7207 /* ${#-} is a valid expansion and means to take the length of $-.
7208 Similarly for ${#?} and ${##}... */
7209 if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
7210 VALID_SPECIAL_LENGTH_PARAM (c) && string[sindex] == RBRACE)
7212 name = (char *)xrealloc (name, 3);
7215 c = string[sindex++];
7218 /* ...but ${#%}, ${#:}, ${#=}, ${#+}, and ${#/} are errors. */
7219 if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
7220 member (c, "%:=+/") && string[sindex] == RBRACE)
7222 temp = (char *)NULL;
7223 goto bad_substitution;
7226 /* Indirect expansion begins with a `!'. A valid indirect expansion is
7227 either a variable name, one of the positional parameters or a special
7228 variable that expands to one of the positional parameters. */
7229 want_indir = *name == '!' &&
7230 (legal_variable_starter ((unsigned char)name[1]) || DIGIT (name[1])
7231 || VALID_INDIR_PARAM (name[1]));
7233 /* Determine the value of this variable. */
7235 /* Check for special variables, directly referenced. */
7236 if (SPECIAL_VAR (name, want_indir))
7239 /* Check for special expansion things, like the length of a parameter */
7240 if (*name == '#' && name[1])
7242 /* If we are not pointing at the character just after the
7243 closing brace, then we haven't gotten all of the name.
7244 Since it begins with a special character, this is a bad
7245 substitution. Also check NAME for validity before trying
7247 if (string[sindex - 1] != RBRACE || (valid_length_expression (name) == 0))
7249 temp = (char *)NULL;
7250 goto bad_substitution;
7253 number = parameter_brace_expand_length (name);
7254 if (number == INTMAX_MIN && unbound_vars_is_error)
7256 last_command_exit_value = EXECUTION_FAILURE;
7257 err_unboundvar (name+1);
7259 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7265 return (&expand_wdesc_error);
7268 ret = alloc_word_desc ();
7269 ret->word = itos (number);
7274 /* ${@} is identical to $@. */
7275 if (name[0] == '@' && name[1] == '\0')
7277 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7278 *quoted_dollar_atp = 1;
7280 if (contains_dollar_at)
7281 *contains_dollar_at = 1;
7283 tflag |= W_DOLLARAT;
7286 /* Process ${!PREFIX*} expansion. */
7287 if (want_indir && string[sindex - 1] == RBRACE &&
7288 (string[sindex - 2] == '*' || string[sindex - 2] == '@') &&
7289 legal_variable_starter ((unsigned char) name[1]))
7294 temp1 = savestring (name + 1);
7295 number = strlen (temp1);
7296 temp1[number - 1] = '\0';
7297 x = all_variables_matching_prefix (temp1);
7298 xlist = strvec_to_word_list (x, 0, 0);
7299 if (string[sindex - 2] == '*')
7300 temp = string_list_dollar_star (xlist);
7303 temp = string_list_dollar_at (xlist, quoted);
7304 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7305 *quoted_dollar_atp = 1;
7306 if (contains_dollar_at)
7307 *contains_dollar_at = 1;
7309 tflag |= W_DOLLARAT;
7312 dispose_words (xlist);
7318 ret = alloc_word_desc ();
7320 ret->flags = tflag; /* XXX */
7324 #if defined (ARRAY_VARS)
7325 /* Process ${!ARRAY[@]} and ${!ARRAY[*]} expansion. */ /* [ */
7326 if (want_indir && string[sindex - 1] == RBRACE &&
7327 string[sindex - 2] == ']' && valid_array_reference (name+1))
7331 temp1 = savestring (name + 1);
7332 x = array_variable_name (temp1, &x1, (int *)0); /* [ */
7334 if (ALL_ELEMENT_SUB (x1[0]) && x1[1] == ']')
7336 temp = array_keys (temp1, quoted); /* handles assoc vars too */
7339 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7340 *quoted_dollar_atp = 1;
7341 if (contains_dollar_at)
7342 *contains_dollar_at = 1;
7344 tflag |= W_DOLLARAT;
7350 ret = alloc_word_desc ();
7352 ret->flags = tflag; /* XXX */
7358 #endif /* ARRAY_VARS */
7360 /* Make sure that NAME is valid before trying to go on. */
7361 if (valid_brace_expansion_word (want_indir ? name + 1 : name,
7362 var_is_special) == 0)
7364 temp = (char *)NULL;
7365 goto bad_substitution;
7369 tdesc = parameter_brace_expand_indir (name + 1, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at);
7371 tdesc = parameter_brace_expand_word (name, var_is_special, quoted, PF_IGNUNBOUND|(pflags&(PF_NOSPLIT2|PF_ASSIGNRHS)), &ind);
7376 tflag = tdesc->flags;
7377 dispose_word_desc (tdesc);
7382 if (temp == &expand_param_error || temp == &expand_param_fatal)
7386 return (temp == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
7389 #if defined (ARRAY_VARS)
7390 if (valid_array_reference (name))
7391 chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at);
7394 var_is_set = temp != (char *)0;
7395 var_is_null = check_nullness && (var_is_set == 0 || *temp == 0);
7396 /* XXX - this may not need to be restricted to special variables */
7398 var_is_null |= var_is_set && var_is_special && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp);
7400 /* Get the rest of the stuff inside the braces. */
7401 if (c && c != RBRACE)
7403 /* Extract the contents of the ${ ... } expansion
7404 according to the Posix.2 rules. */
7405 value = extract_dollar_brace_string (string, &sindex, quoted, (c == '%' || c == '#' || c =='/' || c == '^' || c == ',' || c ==':') ? SX_POSIXEXP|SX_WORD : SX_WORD);
7406 if (string[sindex] == RBRACE)
7409 goto bad_substitution;
7412 value = (char *)NULL;
7416 /* All the cases where an expansion can possibly generate an unbound
7418 if (want_substring || want_patsub || want_casemod || c == '#' || c == '%' || c == RBRACE)
7420 if (var_is_set == 0 && unbound_vars_is_error && ((name[0] != '@' && name[0] != '*') || name[1]))
7422 last_command_exit_value = EXECUTION_FAILURE;
7423 err_unboundvar (name);
7427 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7431 /* If this is a substring spec, process it and add the result. */
7434 temp1 = parameter_brace_substring (name, temp, ind, value, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7439 if (temp1 == &expand_param_error)
7440 return (&expand_wdesc_error);
7441 else if (temp1 == &expand_param_fatal)
7442 return (&expand_wdesc_fatal);
7444 ret = alloc_word_desc ();
7446 /* We test quoted_dollar_atp because we want variants with double-quoted
7447 "$@" to take a different code path. In fact, we make sure at the end
7448 of expand_word_internal that we're only looking at these flags if
7449 quoted_dollar_at == 0. */
7451 (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
7452 QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7453 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7456 else if (want_patsub)
7458 temp1 = parameter_brace_patsub (name, temp, ind, value, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7463 if (temp1 == &expand_param_error)
7464 return (&expand_wdesc_error);
7465 else if (temp1 == &expand_param_fatal)
7466 return (&expand_wdesc_fatal);
7468 ret = alloc_word_desc ();
7471 (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
7472 QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7473 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7476 #if defined (CASEMOD_EXPANSIONS)
7477 else if (want_casemod)
7479 temp1 = parameter_brace_casemod (name, temp, ind, modspec, value, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7484 if (temp1 == &expand_param_error)
7485 return (&expand_wdesc_error);
7486 else if (temp1 == &expand_param_fatal)
7487 return (&expand_wdesc_fatal);
7489 ret = alloc_word_desc ();
7492 (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
7493 QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7494 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7499 /* Do the right thing based on which character ended the variable name. */
7505 last_command_exit_value = EXECUTION_FAILURE;
7506 report_error (_("%s: bad substitution"), string ? string : "??");
7510 return &expand_wdesc_error;
7515 case '#': /* ${param#[#]pattern} */
7516 case '%': /* ${param%[%]pattern} */
7517 if (value == 0 || *value == '\0' || temp == 0 || *temp == '\0')
7522 temp1 = parameter_brace_remove_pattern (name, temp, ind, value, c, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7527 ret = alloc_word_desc ();
7529 if (temp1 && QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7530 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7537 if (var_is_set && var_is_null == 0)
7539 /* If the operator is `+', we don't want the value of the named
7540 variable for anything, just the value of the right hand side. */
7543 /* XXX -- if we're double-quoted and the named variable is "$@",
7544 we want to turn off any special handling of "$@" --
7545 we're not using it, so whatever is on the rhs applies. */
7546 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7547 *quoted_dollar_atp = 0;
7548 if (contains_dollar_at)
7549 *contains_dollar_at = 0;
7554 /* From Posix discussion on austin-group list. Issue 221
7555 requires that backslashes escaping `}' inside
7556 double-quoted ${...} be removed. */
7557 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
7558 quoted |= Q_DOLBRACE;
7559 ret = parameter_brace_expand_rhs (name, value, c,
7562 contains_dollar_at);
7563 /* XXX - fix up later, esp. noting presence of
7564 W_HASQUOTEDNULL in ret->flags */
7568 temp = (char *)NULL;
7574 /* Otherwise do nothing; just use the value in TEMP. */
7576 else /* VAR not set or VAR is NULL. */
7579 temp = (char *)NULL;
7580 if (c == '=' && var_is_special)
7582 last_command_exit_value = EXECUTION_FAILURE;
7583 report_error (_("$%s: cannot assign in this way"), name);
7586 return &expand_wdesc_error;
7590 parameter_brace_expand_error (name, value);
7591 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7595 /* XXX -- if we're double-quoted and the named variable is "$@",
7596 we want to turn off any special handling of "$@" --
7597 we're not using it, so whatever is on the rhs applies. */
7598 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7599 *quoted_dollar_atp = 0;
7600 if (contains_dollar_at)
7601 *contains_dollar_at = 0;
7603 /* From Posix discussion on austin-group list. Issue 221 requires
7604 that backslashes escaping `}' inside double-quoted ${...} be
7606 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
7607 quoted |= Q_DOLBRACE;
7608 ret = parameter_brace_expand_rhs (name, value, c, quoted,
7610 contains_dollar_at);
7611 /* XXX - fix up later, esp. noting presence of
7612 W_HASQUOTEDNULL in tdesc->flags */
7623 ret = alloc_word_desc ();
7630 /* Expand a single ${xxx} expansion. The braces are optional. When
7631 the braces are used, parameter_brace_expand() does the work,
7632 possibly calling param_expand recursively. */
7634 param_expand (string, sindex, quoted, expanded_something,
7635 contains_dollar_at, quoted_dollar_at_p, had_quoted_null_p,
7638 int *sindex, quoted, *expanded_something, *contains_dollar_at;
7639 int *quoted_dollar_at_p, *had_quoted_null_p, pflags;
7641 char *temp, *temp1, uerror[3];
7642 int zindex, t_index, expok;
7647 WORD_DESC *tdesc, *ret;
7651 c = string[++zindex];
7653 temp = (char *)NULL;
7654 ret = tdesc = (WORD_DESC *)NULL;
7657 /* Do simple cases first. Switch on what follows '$'. */
7671 temp1 = dollar_vars[TODIGIT (c)];
7672 if (unbound_vars_is_error && temp1 == (char *)NULL)
7677 last_command_exit_value = EXECUTION_FAILURE;
7678 err_unboundvar (uerror);
7679 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7682 temp = (*temp1 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7683 ? quote_string (temp1)
7684 : quote_escapes (temp1);
7686 temp = (char *)NULL;
7690 /* $$ -- pid of the invoking shell. */
7692 temp = itos (dollar_dollar_pid);
7695 /* $# -- number of positional parameters. */
7697 temp = itos (number_of_args ());
7700 /* $? -- return value of the last synchronous command. */
7702 temp = itos (last_command_exit_value);
7705 /* $- -- flags supplied to the shell on invocation or by `set'. */
7707 temp = which_set_flags ();
7710 /* $! -- Pid of the last asynchronous command. */
7712 /* If no asynchronous pids have been created, expand to nothing.
7713 If `set -u' has been executed, and no async processes have
7714 been created, this is an expansion error. */
7715 if (last_asynchronous_pid == NO_PID)
7717 if (expanded_something)
7718 *expanded_something = 0;
7719 temp = (char *)NULL;
7720 if (unbound_vars_is_error)
7725 last_command_exit_value = EXECUTION_FAILURE;
7726 err_unboundvar (uerror);
7727 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7731 temp = itos (last_asynchronous_pid);
7734 /* The only difference between this and $@ is when the arg is quoted. */
7735 case '*': /* `$*' */
7736 list = list_rest_of_args ();
7739 /* According to austin-group posix proposal by Geoff Clare in
7740 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
7742 "The shell shall write a message to standard error and
7743 immediately exit when it tries to expand an unset parameter
7744 other than the '@' and '*' special parameters."
7747 if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
7752 last_command_exit_value = EXECUTION_FAILURE;
7753 err_unboundvar (uerror);
7754 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7758 /* If there are no command-line arguments, this should just
7759 disappear if there are other characters in the expansion,
7760 even if it's quoted. */
7761 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && list == 0)
7762 temp = (char *)NULL;
7763 else if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES|Q_PATQUOTE))
7765 /* If we have "$*" we want to make a string of the positional
7766 parameters, separated by the first character of $IFS, and
7767 quote the whole string, including the separators. If IFS
7768 is unset, the parameters are separated by ' '; if $IFS is
7769 null, the parameters are concatenated. */
7770 temp = (quoted & (Q_DOUBLE_QUOTES|Q_PATQUOTE)) ? string_list_dollar_star (list) : string_list (list);
7773 temp1 = quote_string (temp);
7775 tflag |= W_HASQUOTEDNULL;
7782 /* We check whether or not we're eventually going to split $* here,
7783 for example when IFS is empty and we are processing the rhs of
7784 an assignment statement. In that case, we don't separate the
7785 arguments at all. Otherwise, if the $* is not quoted it is
7787 # if defined (HANDLE_MULTIBYTE)
7788 if (expand_no_split_dollar_star && ifs_firstc[0] == 0)
7790 if (expand_no_split_dollar_star && ifs_firstc == 0)
7792 temp = string_list_dollar_star (list);
7795 temp = string_list_dollar_at (list, quoted);
7796 if (quoted == 0 && (ifs_is_set == 0 || ifs_is_null))
7797 tflag |= W_SPLITSPACE;
7800 if (expand_no_split_dollar_star == 0 && contains_dollar_at)
7801 *contains_dollar_at = 1;
7804 dispose_words (list);
7807 /* When we have "$@" what we want is "$1" "$2" "$3" ... This
7808 means that we have to turn quoting off after we split into
7809 the individually quoted arguments so that the final split
7810 on the first character of $IFS is still done. */
7811 case '@': /* `$@' */
7812 list = list_rest_of_args ();
7815 /* According to austin-group posix proposal by Geoff Clare in
7816 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
7818 "The shell shall write a message to standard error and
7819 immediately exit when it tries to expand an unset parameter
7820 other than the '@' and '*' special parameters."
7823 if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
7828 last_command_exit_value = EXECUTION_FAILURE;
7829 err_unboundvar (uerror);
7830 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7834 /* We want to flag the fact that we saw this. We can't turn
7835 off quoting entirely, because other characters in the
7836 string might need it (consider "\"$@\""), but we need some
7837 way to signal that the final split on the first character
7838 of $IFS should be done, even though QUOTED is 1. */
7839 /* XXX - should this test include Q_PATQUOTE? */
7840 if (quoted_dollar_at_p && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7841 *quoted_dollar_at_p = 1;
7842 if (contains_dollar_at)
7843 *contains_dollar_at = 1;
7845 /* We want to separate the positional parameters with the first
7846 character of $IFS in case $IFS is something other than a space.
7847 We also want to make sure that splitting is done no matter what --
7848 according to POSIX.2, this expands to a list of the positional
7849 parameters no matter what IFS is set to. */
7850 temp = string_list_dollar_at (list, (pflags & PF_ASSIGNRHS) ? (quoted|Q_DOUBLE_QUOTES) : quoted);
7852 tflag |= W_DOLLARAT;
7853 dispose_words (list);
7857 tdesc = parameter_brace_expand (string, &zindex, quoted, pflags,
7859 contains_dollar_at);
7861 if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
7863 temp = tdesc ? tdesc->word : (char *)0;
7866 /* Quoted nulls should be removed if there is anything else
7868 /* Note that we saw the quoted null so we can add one back at
7869 the end of this function if there are no other characters
7870 in the string, discard TEMP, and go on. The exception to
7871 this is when we have "${@}" and $1 is '', since $@ needs
7872 special handling. */
7873 if (tdesc && tdesc->word && (tdesc->flags & W_HASQUOTEDNULL) && QUOTED_NULL (temp))
7875 if (had_quoted_null_p)
7876 *had_quoted_null_p = 1;
7877 if (*quoted_dollar_at_p == 0)
7880 tdesc->word = temp = (char *)NULL;
7888 /* Do command or arithmetic substitution. */
7890 /* We have to extract the contents of this paren substitution. */
7891 t_index = zindex + 1;
7892 temp = extract_command_subst (string, &t_index, 0);
7895 /* For Posix.2-style `$(( ))' arithmetic substitution,
7896 extract the expression and pass it to the evaluator. */
7897 if (temp && *temp == LPAREN)
7901 temp2 = savestring (temp1);
7902 t_index = strlen (temp2) - 1;
7904 if (temp2[t_index] != RPAREN)
7910 /* Cut off ending `)' */
7911 temp2[t_index] = '\0';
7913 if (chk_arithsub (temp2, t_index) == 0)
7917 internal_warning (_("future versions of the shell will force evaluation as an arithmetic substitution"));
7922 /* Expand variables found inside the expression. */
7923 temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES);
7927 /* No error messages. */
7928 this_command_name = (char *)NULL;
7929 number = evalexp (temp1, &expok);
7934 if (interactive_shell == 0 && posixly_correct)
7936 last_command_exit_value = EXECUTION_FAILURE;
7937 return (&expand_wdesc_fatal);
7940 return (&expand_wdesc_error);
7942 temp = itos (number);
7947 if (pflags & PF_NOCOMSUB)
7948 /* we need zindex+1 because string[zindex] == RPAREN */
7949 temp1 = substring (string, *sindex, zindex+1);
7952 tdesc = command_substitute (temp, quoted);
7953 temp1 = tdesc ? tdesc->word : (char *)NULL;
7955 dispose_word_desc (tdesc);
7961 /* Do POSIX.2d9-style arithmetic substitution. This will probably go
7962 away in a future bash release. */
7964 /* Extract the contents of this arithmetic substitution. */
7965 t_index = zindex + 1;
7966 temp = extract_arithmetic_subst (string, &t_index);
7970 temp = savestring (string);
7971 if (expanded_something)
7972 *expanded_something = 0;
7976 /* Do initial variable expansion. */
7977 temp1 = expand_arith_string (temp, Q_DOUBLE_QUOTES);
7982 /* Find the variable in VARIABLE_LIST. */
7983 temp = (char *)NULL;
7985 for (t_index = zindex; (c = string[zindex]) && legal_variable_char (c); zindex++)
7987 temp1 = (zindex > t_index) ? substring (string, t_index, zindex) : (char *)NULL;
7989 /* If this isn't a variable name, then just output the `$'. */
7990 if (temp1 == 0 || *temp1 == '\0')
7993 temp = (char *)xmalloc (2);
7996 if (expanded_something)
7997 *expanded_something = 0;
8001 /* If the variable exists, return its value cell. */
8002 var = find_variable (temp1);
8004 if (var && invisible_p (var) == 0 && var_isset (var))
8006 #if defined (ARRAY_VARS)
8007 if (assoc_p (var) || array_p (var))
8009 temp = array_p (var) ? array_reference (array_cell (var), 0)
8010 : assoc_reference (assoc_cell (var), "0");
8012 temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
8013 ? quote_string (temp)
8014 : quote_escapes (temp);
8015 else if (unbound_vars_is_error)
8016 goto unbound_variable;
8021 temp = value_cell (var);
8023 temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
8024 ? quote_string (temp)
8025 : quote_escapes (temp);
8032 else if (var = find_variable_last_nameref (temp1))
8034 temp = nameref_cell (var);
8035 #if defined (ARRAY_VARS)
8036 if (temp && *temp && valid_array_reference (temp))
8038 tdesc = parameter_brace_expand_word (temp, SPECIAL_VAR (temp, 0), quoted, pflags, (arrayind_t *)NULL);
8039 if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
8046 /* y=2 ; typeset -n x=y; echo $x is not the same as echo $2 in ksh */
8047 if (temp && *temp && legal_identifier (temp) == 0)
8049 last_command_exit_value = EXECUTION_FAILURE;
8050 report_error (_("%s: invalid variable name for name reference"), temp);
8051 return (&expand_wdesc_error); /* XXX */
8054 temp = (char *)NULL;
8057 temp = (char *)NULL;
8060 if (unbound_vars_is_error)
8062 last_command_exit_value = EXECUTION_FAILURE;
8063 err_unboundvar (temp1);
8072 last_command_exit_value = EXECUTION_FAILURE;
8073 return ((unbound_vars_is_error && interactive_shell == 0)
8074 ? &expand_wdesc_fatal
8075 : &expand_wdesc_error);
8086 ret = alloc_word_desc ();
8087 ret->flags = tflag; /* XXX */
8093 /* Make a word list which is the result of parameter and variable
8094 expansion, command substitution, arithmetic substitution, and
8095 quote removal of WORD. Return a pointer to a WORD_LIST which is
8096 the result of the expansion. If WORD contains a null word, the
8097 word list returned is also null.
8099 QUOTED contains flag values defined in shell.h.
8101 ISEXP is used to tell expand_word_internal that the word should be
8102 treated as the result of an expansion. This has implications for
8103 how IFS characters in the word are treated.
8105 CONTAINS_DOLLAR_AT and EXPANDED_SOMETHING are return values; when non-null
8106 they point to an integer value which receives information about expansion.
8107 CONTAINS_DOLLAR_AT gets non-zero if WORD contained "$@", else zero.
8108 EXPANDED_SOMETHING get non-zero if WORD contained any parameter expansions,
8111 This only does word splitting in the case of $@ expansion. In that
8112 case, we split on ' '. */
8114 /* Values for the local variable quoted_state. */
8116 #define PARTIALLY_QUOTED 1
8117 #define WHOLLY_QUOTED 2
8120 expand_word_internal (word, quoted, isexp, contains_dollar_at, expanded_something)
8123 int *contains_dollar_at;
8124 int *expanded_something;
8129 /* The intermediate string that we build while expanding. */
8132 /* The current size of the above object. */
8135 /* Index into ISTRING. */
8138 /* Temporary string storage. */
8141 /* The text of WORD. */
8142 register char *string;
8144 /* The size of STRING. */
8147 /* The index into STRING. */
8150 /* This gets 1 if we see a $@ while quoted. */
8151 int quoted_dollar_at;
8153 /* One of UNQUOTED, PARTIALLY_QUOTED, or WHOLLY_QUOTED, depending on
8154 whether WORD contains no quoting characters, a partially quoted
8155 string (e.g., "xx"ab), or is fully quoted (e.g., "xxab"). */
8159 int had_quoted_null;
8160 int has_dollar_at, temp_has_dollar_at;
8161 int split_on_spaces;
8163 int pflags; /* flags passed to param_expand */
8165 int assignoff; /* If assignment, offset of `=' */
8167 register unsigned char c; /* Current character. */
8168 int t_index; /* For calls to string_extract_xxx. */
8174 istring = (char *)xmalloc (istring_size = DEFAULT_INITIAL_ARRAY_SIZE);
8175 istring[istring_index = 0] = '\0';
8176 quoted_dollar_at = had_quoted_null = has_dollar_at = 0;
8177 split_on_spaces = 0;
8178 quoted_state = UNQUOTED;
8180 string = word->word;
8182 goto finished_with_string;
8183 /* Don't need the string length for the SADD... and COPY_ macros unless
8184 multibyte characters are possible. */
8185 string_size = (MB_CUR_MAX > 1) ? strlen (string) : 1;
8187 if (contains_dollar_at)
8188 *contains_dollar_at = 0;
8192 /* Begin the expansion. */
8198 /* Case on top-level character. */
8202 goto finished_with_string;
8206 #if HANDLE_MULTIBYTE
8207 if (MB_CUR_MAX > 1 && string[sindex])
8209 SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
8214 temp = (char *)xmalloc (3);
8216 temp[1] = c = string[sindex];
8227 istring = sub_append_string (temp, istring, &istring_index, &istring_size);
8233 #if defined (PROCESS_SUBSTITUTION)
8234 /* Process substitution. */
8238 if (string[++sindex] != LPAREN || (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (word->flags & (W_DQUOTE|W_NOPROCSUB)) || posixly_correct)
8240 sindex--; /* add_character: label increments sindex */
8244 t_index = sindex + 1; /* skip past both '<' and LPAREN */
8246 temp1 = extract_process_subst (string, (c == '<') ? "<(" : ">(", &t_index); /*))*/
8249 /* If the process substitution specification is `<()', we want to
8250 open the pipe for writing in the child and produce output; if
8251 it is `>()', we want to open the pipe for reading in the child
8252 and consume input. */
8253 temp = temp1 ? process_substitute (temp1, (c == '>')) : (char *)0;
8257 goto dollar_add_string;
8259 #endif /* PROCESS_SUBSTITUTION */
8262 /* Posix.2 section 3.6.1 says that tildes following `=' in words
8263 which are not assignment statements are not expanded. If the
8264 shell isn't in posix mode, though, we perform tilde expansion
8265 on `likely candidate' unquoted assignment statements (flags
8266 include W_ASSIGNMENT but not W_QUOTED). A likely candidate
8267 contains an unquoted :~ or =~. Something to think about: we
8268 now have a flag that says to perform tilde expansion on arguments
8269 to `assignment builtins' like declare and export that look like
8270 assignment statements. We now do tilde expansion on such words
8271 even in POSIX mode. */
8272 if (word->flags & (W_ASSIGNRHS|W_NOTILDE))
8274 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8275 goto add_ifs_character;
8279 /* If we're not in posix mode or forcing assignment-statement tilde
8280 expansion, note where the `=' appears in the word and prepare to
8281 do tilde expansion following the first `='. */
8282 if ((word->flags & W_ASSIGNMENT) &&
8283 (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
8284 assignoff == -1 && sindex > 0)
8286 if (sindex == assignoff && string[sindex+1] == '~') /* XXX */
8287 word->flags |= W_ITILDE;
8289 else if ((word->flags & W_ASSIGNMENT) &&
8290 (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
8291 string[sindex+1] == '~')
8292 word->flags |= W_ITILDE;
8294 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8295 goto add_ifs_character;
8300 if (word->flags & W_NOTILDE)
8302 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8303 goto add_ifs_character;
8308 if ((word->flags & (W_ASSIGNMENT|W_ASSIGNRHS|W_TILDEEXP)) &&
8309 string[sindex+1] == '~')
8310 word->flags |= W_ITILDE;
8312 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8313 goto add_ifs_character;
8318 /* If the word isn't supposed to be tilde expanded, or we're not
8319 at the start of a word or after an unquoted : or = in an
8320 assignment statement, we don't do tilde expansion. */
8321 if ((word->flags & (W_NOTILDE|W_DQUOTE)) ||
8322 (sindex > 0 && ((word->flags & W_ITILDE) == 0)) ||
8323 (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
8325 word->flags &= ~W_ITILDE;
8326 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
8327 goto add_ifs_character;
8332 if (word->flags & W_ASSIGNRHS)
8334 else if (word->flags & (W_ASSIGNMENT|W_TILDEEXP))
8339 temp = bash_tilde_find_word (string + sindex, tflag, &t_index);
8341 word->flags &= ~W_ITILDE;
8343 if (temp && *temp && t_index > 0)
8345 temp1 = bash_tilde_expand (temp, tflag);
8346 if (temp1 && *temp1 == '~' && STREQ (temp, temp1))
8350 goto add_character; /* tilde expansion failed */
8355 goto add_quoted_string; /* XXX was add_string */
8364 if (expanded_something)
8365 *expanded_something = 1;
8367 temp_has_dollar_at = 0;
8368 pflags = (word->flags & W_NOCOMSUB) ? PF_NOCOMSUB : 0;
8369 if (word->flags & W_NOSPLIT2)
8370 pflags |= PF_NOSPLIT2;
8371 if (word->flags & W_ASSIGNRHS)
8372 pflags |= PF_ASSIGNRHS;
8373 tword = param_expand (string, &sindex, quoted, expanded_something,
8374 &temp_has_dollar_at, "ed_dollar_at,
8375 &had_quoted_null, pflags);
8376 has_dollar_at += temp_has_dollar_at;
8377 split_on_spaces += (tword->flags & W_SPLITSPACE);
8379 if (tword == &expand_wdesc_error || tword == &expand_wdesc_fatal)
8383 return ((tword == &expand_wdesc_error) ? &expand_word_error
8384 : &expand_word_fatal);
8386 if (contains_dollar_at && has_dollar_at)
8387 *contains_dollar_at = 1;
8389 if (tword && (tword->flags & W_HASQUOTEDNULL))
8390 had_quoted_null = 1;
8392 temp = tword ? tword->word : (char *)NULL;
8393 dispose_word_desc (tword);
8395 /* Kill quoted nulls; we will add them back at the end of
8396 expand_word_internal if nothing else in the string */
8397 if (had_quoted_null && temp && QUOTED_NULL (temp))
8400 temp = (char *)NULL;
8406 case '`': /* Backquoted command substitution. */
8410 temp = string_extract (string, &sindex, "`", SX_REQMATCH);
8411 /* The test of sindex against t_index is to allow bare instances of
8412 ` to pass through, for backwards compatibility. */
8413 if (temp == &extract_string_error || temp == &extract_string_fatal)
8415 if (sindex - 1 == t_index)
8420 last_command_exit_value = EXECUTION_FAILURE;
8421 report_error (_("bad substitution: no closing \"`\" in %s") , string+t_index);
8424 return ((temp == &extract_string_error) ? &expand_word_error
8425 : &expand_word_fatal);
8428 if (expanded_something)
8429 *expanded_something = 1;
8431 if (word->flags & W_NOCOMSUB)
8432 /* sindex + 1 because string[sindex] == '`' */
8433 temp1 = substring (string, t_index, sindex + 1);
8436 de_backslash (temp);
8437 tword = command_substitute (temp, quoted);
8438 temp1 = tword ? tword->word : (char *)NULL;
8440 dispose_word_desc (tword);
8444 goto dollar_add_string;
8448 if (string[sindex + 1] == '\n')
8454 c = string[++sindex];
8456 if (quoted & Q_HERE_DOCUMENT)
8458 else if (quoted & Q_DOUBLE_QUOTES)
8463 /* From Posix discussion on austin-group list: Backslash escaping
8464 a } in ${...} is removed. Issue 0000221 */
8465 if ((quoted & Q_DOLBRACE) && c == RBRACE)
8467 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
8469 /* This is the fix for " $@\ " */
8470 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0) && isexp == 0 && isifs (c))
8472 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
8473 DEFAULT_ARRAY_SIZE);
8474 istring[istring_index++] = CTLESC;
8475 istring[istring_index++] = '\\';
8476 istring[istring_index] = '\0';
8478 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
8480 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0))
8482 SCOPY_CHAR_I (twochars, '\\', c, string, sindex, string_size);
8487 sindex--; /* add_character: label increments sindex */
8492 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
8497 /* BEFORE jumping here, we need to increment sindex if appropriate */
8498 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
8499 DEFAULT_ARRAY_SIZE);
8500 istring[istring_index++] = twochars[0];
8501 istring[istring_index++] = twochars[1];
8502 istring[istring_index] = '\0';
8507 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
8511 temp = string_extract_double_quoted (string, &sindex, 0);
8513 /* If the quotes surrounded the entire string, then the
8514 whole word was quoted. */
8515 quoted_state = (t_index == 1 && string[sindex] == '\0')
8521 tword = alloc_word_desc ();
8524 temp = (char *)NULL;
8526 temp_has_dollar_at = 0; /* XXX */
8527 /* Need to get W_HASQUOTEDNULL flag through this function. */
8528 list = expand_word_internal (tword, Q_DOUBLE_QUOTES, 0, &temp_has_dollar_at, (int *)NULL);
8529 has_dollar_at += temp_has_dollar_at;
8531 if (list == &expand_word_error || list == &expand_word_fatal)
8535 /* expand_word_internal has already freed temp_word->word
8536 for us because of the way it prints error messages. */
8537 tword->word = (char *)NULL;
8538 dispose_word (tword);
8542 dispose_word (tword);
8544 /* "$@" (a double-quoted dollar-at) expands into nothing,
8545 not even a NULL word, when there are no positional
8547 if (list == 0 && has_dollar_at)
8553 /* If we get "$@", we know we have expanded something, so we
8554 need to remember it for the final split on $IFS. This is
8555 a special case; it's the only case where a quoted string
8556 can expand into more than one word. It's going to come back
8557 from the above call to expand_word_internal as a list with
8558 a single word, in which all characters are quoted and
8559 separated by blanks. What we want to do is to turn it back
8560 into a list for the next piece of code. */
8562 dequote_list (list);
8564 if (list && list->word && (list->word->flags & W_HASQUOTEDNULL))
8565 had_quoted_null = 1; /* XXX */
8570 if (contains_dollar_at)
8571 *contains_dollar_at = 1;
8572 if (expanded_something)
8573 *expanded_something = 1;
8578 /* What we have is "". This is a minor optimization. */
8580 list = (WORD_LIST *)NULL;
8583 /* The code above *might* return a list (consider the case of "$@",
8584 where it returns "$1", "$2", etc.). We can't throw away the
8585 rest of the list, and we have to make sure each word gets added
8586 as quoted. We test on tresult->next: if it is non-NULL, we
8587 quote the whole list, save it to a string with string_list, and
8588 add that string. We don't need to quote the results of this
8589 (and it would be wrong, since that would quote the separators
8590 as well), so we go directly to add_string. */
8595 /* Testing quoted_dollar_at makes sure that "$@" is
8596 split correctly when $IFS does not contain a space. */
8597 temp = quoted_dollar_at
8598 ? string_list_dollar_at (list, Q_DOUBLE_QUOTES)
8599 : string_list (quote_list (list));
8600 dispose_words (list);
8605 temp = savestring (list->word->word);
8606 tflag = list->word->flags;
8607 dispose_words (list);
8609 /* If the string is not a quoted null string, we want
8610 to remove any embedded unquoted CTLNUL characters.
8611 We do not want to turn quoted null strings back into
8612 the empty string, though. We do this because we
8613 want to remove any quoted nulls from expansions that
8614 contain other characters. For example, if we have
8615 x"$*"y or "x$*y" and there are no positional parameters,
8616 the $* should expand into nothing. */
8617 /* We use the W_HASQUOTEDNULL flag to differentiate the
8618 cases: a quoted null character as above and when
8619 CTLNUL is contained in the (non-null) expansion
8620 of some variable. We use the had_quoted_null flag to
8621 pass the value through this function to its caller. */
8622 if ((tflag & W_HASQUOTEDNULL) && QUOTED_NULL (temp) == 0)
8623 remove_quoted_nulls (temp); /* XXX */
8627 temp = (char *)NULL;
8629 /* We do not want to add quoted nulls to strings that are only
8630 partially quoted; we can throw them away. The exception to
8631 this is when we are going to be performing word splitting,
8632 since we have to preserve a null argument if the next character
8633 will cause word splitting. */
8634 if (temp == 0 && quoted_state == PARTIALLY_QUOTED && (word->flags & (W_NOSPLIT|W_NOSPLIT2)))
8642 temp = quote_string (temp);
8650 sindex--; /* add_character: label increments sindex */
8657 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
8661 temp = string_extract_single_quoted (string, &sindex);
8663 /* If the entire STRING was surrounded by single quotes,
8664 then the string is wholly quoted. */
8665 quoted_state = (t_index == 1 && string[sindex] == '\0')
8669 /* If all we had was '', it is a null expansion. */
8673 temp = (char *)NULL;
8676 remove_quoted_escapes (temp); /* ??? */
8678 /* We do not want to add quoted nulls to strings that are only
8679 partially quoted; such nulls are discarded. */
8680 if (temp == 0 && (quoted_state == PARTIALLY_QUOTED))
8683 /* If we have a quoted null expansion, add a quoted NULL to istring. */
8687 sindex--; /* add_character: label increments sindex */
8691 goto add_quoted_string;
8696 /* This is the fix for " $@ " */
8698 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (isexp == 0 && isifs (c)))
8700 if (string[sindex]) /* from old goto dollar_add_string */
8709 #if HANDLE_MULTIBYTE
8715 SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
8720 twochars[0] = CTLESC;
8727 SADD_MBCHAR (temp, string, sindex, string_size);
8730 RESIZE_MALLOCED_BUFFER (istring, istring_index, 1, istring_size,
8731 DEFAULT_ARRAY_SIZE);
8732 istring[istring_index++] = c;
8733 istring[istring_index] = '\0';
8735 /* Next character. */
8740 finished_with_string:
8741 /* OK, we're ready to return. If we have a quoted string, and
8742 quoted_dollar_at is not set, we do no splitting at all; otherwise
8743 we split on ' '. The routines that call this will handle what to
8744 do if nothing has been expanded. */
8746 /* Partially and wholly quoted strings which expand to the empty
8747 string are retained as an empty arguments. Unquoted strings
8748 which expand to the empty string are discarded. The single
8749 exception is the case of expanding "$@" when there are no
8750 positional parameters. In that case, we discard the expansion. */
8752 /* Because of how the code that handles "" and '' in partially
8753 quoted strings works, we need to make ISTRING into a QUOTED_NULL
8754 if we saw quoting characters, but the expansion was empty.
8755 "" and '' are tossed away before we get to this point when
8756 processing partially quoted strings. This makes "" and $xxx""
8757 equivalent when xxx is unset. We also look to see whether we
8758 saw a quoted null from a ${} expansion and add one back if we
8761 /* If we expand to nothing and there were no single or double quotes
8762 in the word, we throw it away. Otherwise, we return a NULL word.
8763 The single exception is for $@ surrounded by double quotes when
8764 there are no positional parameters. In that case, we also throw
8767 if (*istring == '\0')
8769 if (quoted_dollar_at == 0 && (had_quoted_null || quoted_state == PARTIALLY_QUOTED))
8771 istring[0] = CTLNUL;
8773 tword = make_bare_word (istring);
8774 tword->flags |= W_HASQUOTEDNULL; /* XXX */
8775 list = make_word_list (tword, (WORD_LIST *)NULL);
8776 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
8777 tword->flags |= W_QUOTED;
8779 /* According to sh, ksh, and Posix.2, if a word expands into nothing
8780 and a double-quoted "$@" appears anywhere in it, then the entire
8782 else if (quoted_state == UNQUOTED || quoted_dollar_at)
8783 list = (WORD_LIST *)NULL;
8787 tword = make_bare_word (istring);
8788 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
8789 tword->flags |= W_QUOTED;
8790 list = make_word_list (tword, (WORD_LIST *)NULL);
8794 list = (WORD_LIST *)NULL;
8797 else if (word->flags & W_NOSPLIT)
8799 tword = make_bare_word (istring);
8800 if (word->flags & W_ASSIGNMENT)
8801 tword->flags |= W_ASSIGNMENT; /* XXX */
8802 if (word->flags & W_COMPASSIGN)
8803 tword->flags |= W_COMPASSIGN; /* XXX */
8804 if (word->flags & W_NOGLOB)
8805 tword->flags |= W_NOGLOB; /* XXX */
8806 if (word->flags & W_NOBRACE)
8807 tword->flags |= W_NOBRACE; /* XXX */
8808 if (word->flags & W_NOEXPAND)
8809 tword->flags |= W_NOEXPAND; /* XXX */
8810 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
8811 tword->flags |= W_QUOTED;
8812 if (had_quoted_null && QUOTED_NULL (istring))
8813 tword->flags |= W_HASQUOTEDNULL;
8814 list = make_word_list (tword, (WORD_LIST *)NULL);
8820 ifs_chars = (quoted_dollar_at || has_dollar_at) ? ifs_value : (char *)NULL;
8822 /* If we have $@, we need to split the results no matter what. If
8823 IFS is unset or NULL, string_list_dollar_at has separated the
8824 positional parameters with a space, so we split on space (we have
8825 set ifs_chars to " \t\n" above if ifs is unset). If IFS is set,
8826 string_list_dollar_at has separated the positional parameters
8827 with the first character of $IFS, so we split on $IFS. If
8828 SPLIT_ON_SPACES is set, we expanded $* (unquoted) with IFS either
8829 unset or null, and we want to make sure that we split on spaces
8830 regardless of what else has happened to IFS since the expansion. */
8831 if (split_on_spaces)
8832 list = list_string (istring, " ", 1); /* XXX quoted == 1? */
8833 else if (has_dollar_at && ifs_chars)
8834 list = list_string (istring, *ifs_chars ? ifs_chars : " ", 1);
8837 tword = make_bare_word (istring);
8838 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || (quoted_state == WHOLLY_QUOTED))
8839 tword->flags |= W_QUOTED;
8840 if (word->flags & W_ASSIGNMENT)
8841 tword->flags |= W_ASSIGNMENT;
8842 if (word->flags & W_COMPASSIGN)
8843 tword->flags |= W_COMPASSIGN;
8844 if (word->flags & W_NOGLOB)
8845 tword->flags |= W_NOGLOB;
8846 if (word->flags & W_NOBRACE)
8847 tword->flags |= W_NOBRACE;
8848 if (word->flags & W_NOEXPAND)
8849 tword->flags |= W_NOEXPAND;
8850 if (had_quoted_null && QUOTED_NULL (istring))
8851 tword->flags |= W_HASQUOTEDNULL; /* XXX */
8852 list = make_word_list (tword, (WORD_LIST *)NULL);
8860 /* **************************************************************** */
8862 /* Functions for Quote Removal */
8864 /* **************************************************************** */
8866 /* Perform quote removal on STRING. If QUOTED > 0, assume we are obeying the
8867 backslash quoting rules for within double quotes or a here document. */
8869 string_quote_removal (string, quoted)
8874 char *r, *result_string, *temp, *send;
8875 int sindex, tindex, dquote;
8879 /* The result can be no longer than the original string. */
8880 slen = strlen (string);
8881 send = string + slen;
8883 r = result_string = (char *)xmalloc (slen + 1);
8885 for (dquote = sindex = 0; c = string[sindex];)
8890 c = string[++sindex];
8896 if (((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote) && (sh_syntaxtab[c] & CBSDQUOTE) == 0)
8901 SCOPY_CHAR_M (r, string, send, sindex);
8905 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote)
8911 tindex = sindex + 1;
8912 temp = string_extract_single_quoted (string, &tindex);
8923 dquote = 1 - dquote;
8929 return (result_string);
8934 /* Perform quote removal on word WORD. This allocates and returns a new
8937 word_quote_removal (word, quoted)
8944 t = string_quote_removal (word->word, quoted);
8945 w = alloc_word_desc ();
8946 w->word = t ? t : savestring ("");
8950 /* Perform quote removal on all words in LIST. If QUOTED is non-zero,
8951 the members of the list are treated as if they are surrounded by
8952 double quotes. Return a new list, or NULL if LIST is NULL. */
8954 word_list_quote_removal (list, quoted)
8958 WORD_LIST *result, *t, *tresult, *e;
8960 for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
8962 tresult = make_word_list (word_quote_removal (t->word, quoted), (WORD_LIST *)NULL);
8964 result = (WORD_LIST *) list_append (result, tresult);
8967 result = e = tresult;
8980 /*******************************************
8982 * Functions to perform word splitting *
8984 *******************************************/
8994 ifs_value = (v && value_cell (v)) ? value_cell (v) : " \t\n";
8996 ifs_is_set = ifs_var != 0;
8997 ifs_is_null = ifs_is_set && (*ifs_value == 0);
8999 /* Should really merge ifs_cmap with sh_syntaxtab. XXX - doesn't yet
9000 handle multibyte chars in IFS */
9001 memset (ifs_cmap, '\0', sizeof (ifs_cmap));
9002 for (t = ifs_value ; t && *t; t++)
9008 #if defined (HANDLE_MULTIBYTE)
9011 ifs_firstc[0] = '\0';
9017 ifs_len = strnlen (ifs_value, MB_CUR_MAX);
9018 ifs_firstc_len = MBLEN (ifs_value, ifs_len);
9019 if (ifs_firstc_len == 1 || ifs_firstc_len == 0 || MB_INVALIDCH (ifs_firstc_len))
9021 ifs_firstc[0] = ifs_value[0];
9022 ifs_firstc[1] = '\0';
9026 memcpy (ifs_firstc, ifs_value, ifs_firstc_len);
9029 ifs_firstc = ifs_value ? *ifs_value : 0;
9039 /* This splits a single word into a WORD LIST on $IFS, but only if the word
9040 is not quoted. list_string () performs quote removal for us, even if we
9041 don't do any splitting. */
9043 word_split (w, ifs_chars)
9053 xifs = ((w->flags & W_QUOTED) || ifs_chars == 0) ? "" : ifs_chars;
9054 result = list_string (w->word, xifs, w->flags & W_QUOTED);
9057 result = (WORD_LIST *)NULL;
9062 /* Perform word splitting on LIST and return the RESULT. It is possible
9063 to return (WORD_LIST *)NULL. */
9065 word_list_split (list)
9068 WORD_LIST *result, *t, *tresult, *e;
9070 for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
9072 tresult = word_split (t->word, ifs_value);
9074 result = e = tresult;
9085 /**************************************************
9087 * Functions to expand an entire WORD_LIST *
9089 **************************************************/
9091 /* Do any word-expansion-specific cleanup and jump to top_level */
9093 exp_jump_to_top_level (v)
9096 set_pipestatus_from_exit (last_command_exit_value);
9098 /* Cleanup code goes here. */
9099 expand_no_split_dollar_star = 0; /* XXX */
9100 expanding_redir = 0;
9101 assigning_in_environment = 0;
9103 if (parse_and_execute_level == 0)
9104 top_level_cleanup (); /* from sig.c */
9106 jump_to_top_level (v);
9109 /* Put NLIST (which is a WORD_LIST * of only one element) at the front of
9110 ELIST, and set ELIST to the new list. */
9111 #define PREPEND_LIST(nlist, elist) \
9112 do { nlist->next = elist; elist = nlist; } while (0)
9114 /* Separate out any initial variable assignments from TLIST. If set -k has
9115 been executed, remove all assignment statements from TLIST. Initial
9116 variable assignments and other environment assignments are placed
9117 on SUBST_ASSIGN_VARLIST. */
9119 separate_out_assignments (tlist)
9122 register WORD_LIST *vp, *lp;
9125 return ((WORD_LIST *)NULL);
9127 if (subst_assign_varlist)
9128 dispose_words (subst_assign_varlist); /* Clean up after previous error */
9130 subst_assign_varlist = (WORD_LIST *)NULL;
9133 /* Separate out variable assignments at the start of the command.
9134 Loop invariant: vp->next == lp
9136 lp = list of words left after assignment statements skipped
9137 tlist = original list of words
9139 while (lp && (lp->word->flags & W_ASSIGNMENT))
9145 /* If lp != tlist, we have some initial assignment statements.
9146 We make SUBST_ASSIGN_VARLIST point to the list of assignment
9147 words and TLIST point to the remaining words. */
9150 subst_assign_varlist = tlist;
9151 /* ASSERT(vp->next == lp); */
9152 vp->next = (WORD_LIST *)NULL; /* terminate variable list */
9153 tlist = lp; /* remainder of word list */
9156 /* vp == end of variable list */
9157 /* tlist == remainder of original word list without variable assignments */
9159 /* All the words in tlist were assignment statements */
9160 return ((WORD_LIST *)NULL);
9162 /* ASSERT(tlist != NULL); */
9163 /* ASSERT((tlist->word->flags & W_ASSIGNMENT) == 0); */
9165 /* If the -k option is in effect, we need to go through the remaining
9166 words, separate out the assignment words, and place them on
9167 SUBST_ASSIGN_VARLIST. */
9168 if (place_keywords_in_env)
9170 WORD_LIST *tp; /* tp == running pointer into tlist */
9175 /* Loop Invariant: tp->next == lp */
9176 /* Loop postcondition: tlist == word list without assignment statements */
9179 if (lp->word->flags & W_ASSIGNMENT)
9181 /* Found an assignment statement, add this word to end of
9182 subst_assign_varlist (vp). */
9183 if (!subst_assign_varlist)
9184 subst_assign_varlist = vp = lp;
9191 /* Remove the word pointed to by LP from TLIST. */
9192 tp->next = lp->next;
9193 /* ASSERT(vp == lp); */
9194 lp->next = (WORD_LIST *)NULL;
9207 #define WEXP_VARASSIGN 0x001
9208 #define WEXP_BRACEEXP 0x002
9209 #define WEXP_TILDEEXP 0x004
9210 #define WEXP_PARAMEXP 0x008
9211 #define WEXP_PATHEXP 0x010
9213 /* All of the expansions, including variable assignments at the start of
9215 #define WEXP_ALL (WEXP_VARASSIGN|WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
9217 /* All of the expansions except variable assignments at the start of
9219 #define WEXP_NOVARS (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
9221 /* All of the `shell expansions': brace expansion, tilde expansion, parameter
9222 expansion, command substitution, arithmetic expansion, word splitting, and
9224 #define WEXP_SHELLEXP (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP)
9226 /* Take the list of words in LIST and do the various substitutions. Return
9227 a new list of words which is the expanded list, and without things like
9228 variable assignments. */
9234 return (expand_word_list_internal (list, WEXP_ALL));
9237 /* Same as expand_words (), but doesn't hack variable or environment
9240 expand_words_no_vars (list)
9243 return (expand_word_list_internal (list, WEXP_NOVARS));
9247 expand_words_shellexp (list)
9250 return (expand_word_list_internal (list, WEXP_SHELLEXP));
9254 glob_expand_word_list (tlist, eflags)
9258 char **glob_array, *temp_string;
9259 register int glob_index;
9260 WORD_LIST *glob_list, *output_list, *disposables, *next;
9263 output_list = disposables = (WORD_LIST *)NULL;
9264 glob_array = (char **)NULL;
9267 /* For each word, either globbing is attempted or the word is
9268 added to orig_list. If globbing succeeds, the results are
9269 added to orig_list and the word (tlist) is added to the list
9270 of disposable words. If globbing fails and failed glob
9271 expansions are left unchanged (the shell default), the
9272 original word is added to orig_list. If globbing fails and
9273 failed glob expansions are removed, the original word is
9274 added to the list of disposable words. orig_list ends up
9275 in reverse order and requires a call to REVERSE_LIST to
9276 be set right. After all words are examined, the disposable
9280 /* If the word isn't an assignment and contains an unquoted
9281 pattern matching character, then glob it. */
9282 if ((tlist->word->flags & W_NOGLOB) == 0 &&
9283 unquoted_glob_pattern_p (tlist->word->word))
9285 glob_array = shell_glob_filename (tlist->word->word);
9287 /* Handle error cases.
9288 I don't think we should report errors like "No such file
9289 or directory". However, I would like to report errors
9290 like "Read failed". */
9292 if (glob_array == 0 || GLOB_FAILED (glob_array))
9294 glob_array = (char **)xmalloc (sizeof (char *));
9295 glob_array[0] = (char *)NULL;
9298 /* Dequote the current word in case we have to use it. */
9299 if (glob_array[0] == NULL)
9301 temp_string = dequote_string (tlist->word->word);
9302 free (tlist->word->word);
9303 tlist->word->word = temp_string;
9306 /* Make the array into a word list. */
9307 glob_list = (WORD_LIST *)NULL;
9308 for (glob_index = 0; glob_array[glob_index]; glob_index++)
9310 tword = make_bare_word (glob_array[glob_index]);
9311 glob_list = make_word_list (tword, glob_list);
9316 output_list = (WORD_LIST *)list_append (glob_list, output_list);
9317 PREPEND_LIST (tlist, disposables);
9319 else if (fail_glob_expansion != 0)
9321 last_command_exit_value = EXECUTION_FAILURE;
9322 report_error (_("no match: %s"), tlist->word->word);
9323 exp_jump_to_top_level (DISCARD);
9325 else if (allow_null_glob_expansion == 0)
9327 /* Failed glob expressions are left unchanged. */
9328 PREPEND_LIST (tlist, output_list);
9332 /* Failed glob expressions are removed. */
9333 PREPEND_LIST (tlist, disposables);
9338 /* Dequote the string. */
9339 temp_string = dequote_string (tlist->word->word);
9340 free (tlist->word->word);
9341 tlist->word->word = temp_string;
9342 PREPEND_LIST (tlist, output_list);
9345 strvec_dispose (glob_array);
9346 glob_array = (char **)NULL;
9352 dispose_words (disposables);
9355 output_list = REVERSE_LIST (output_list, WORD_LIST *);
9357 return (output_list);
9360 #if defined (BRACE_EXPANSION)
9362 brace_expand_word_list (tlist, eflags)
9366 register char **expansions;
9368 WORD_LIST *disposables, *output_list, *next;
9372 for (disposables = output_list = (WORD_LIST *)NULL; tlist; tlist = next)
9376 if (tlist->word->flags & W_NOBRACE)
9378 /*itrace("brace_expand_word_list: %s: W_NOBRACE", tlist->word->word);*/
9379 PREPEND_LIST (tlist, output_list);
9383 if ((tlist->word->flags & (W_COMPASSIGN|W_ASSIGNARG)) == (W_COMPASSIGN|W_ASSIGNARG))
9385 /*itrace("brace_expand_word_list: %s: W_COMPASSIGN|W_ASSIGNARG", tlist->word->word);*/
9386 PREPEND_LIST (tlist, output_list);
9390 /* Only do brace expansion if the word has a brace character. If
9391 not, just add the word list element to BRACES and continue. In
9392 the common case, at least when running shell scripts, this will
9393 degenerate to a bunch of calls to `mbschr', and then what is
9394 basically a reversal of TLIST into BRACES, which is corrected
9395 by a call to REVERSE_LIST () on BRACES when the end of TLIST
9397 if (mbschr (tlist->word->word, LBRACE))
9399 expansions = brace_expand (tlist->word->word);
9401 for (eindex = 0; temp_string = expansions[eindex]; eindex++)
9403 w = alloc_word_desc ();
9404 w->word = temp_string;
9406 /* If brace expansion didn't change the word, preserve
9407 the flags. We may want to preserve the flags
9408 unconditionally someday -- XXX */
9409 if (STREQ (temp_string, tlist->word->word))
9410 w->flags = tlist->word->flags;
9412 w = make_word_flags (w, temp_string);
9414 output_list = make_word_list (w, output_list);
9418 /* Add TLIST to the list of words to be freed after brace
9419 expansion has been performed. */
9420 PREPEND_LIST (tlist, disposables);
9423 PREPEND_LIST (tlist, output_list);
9427 dispose_words (disposables);
9430 output_list = REVERSE_LIST (output_list, WORD_LIST *);
9432 return (output_list);
9436 #if defined (ARRAY_VARS)
9437 /* Take WORD, a compound associative array assignment, and internally run
9438 'declare -A w', where W is the variable name portion of WORD. */
9440 make_internal_declare (word, option)
9448 w = make_word (word);
9450 t = assignment (w->word, 0);
9453 wl = make_word_list (w, (WORD_LIST *)NULL);
9454 wl = make_word_list (make_word (option), wl);
9456 return (declare_builtin (wl));
9461 shell_expand_word_list (tlist, eflags)
9465 WORD_LIST *expanded, *orig_list, *new_list, *next, *temp_list;
9466 int expanded_something, has_dollar_at;
9469 /* We do tilde expansion all the time. This is what 1003.2 says. */
9470 new_list = (WORD_LIST *)NULL;
9471 for (orig_list = tlist; tlist; tlist = next)
9473 temp_string = tlist->word->word;
9477 #if defined (ARRAY_VARS)
9478 /* If this is a compound array assignment to a builtin that accepts
9479 such assignments (e.g., `declare'), take the assignment and perform
9480 it separately, handling the semantics of declarations inside shell
9481 functions. This avoids the double-evaluation of such arguments,
9482 because `declare' does some evaluation of compound assignments on
9484 if ((tlist->word->flags & (W_COMPASSIGN|W_ASSIGNARG)) == (W_COMPASSIGN|W_ASSIGNARG))
9490 if (tlist->word->flags & (W_ASSIGNASSOC|W_ASSNGLOBAL|W_ASSIGNARRAY))
9493 if ((tlist->word->flags & (W_ASSIGNASSOC|W_ASSNGLOBAL)) == (W_ASSIGNASSOC|W_ASSNGLOBAL))
9498 else if (tlist->word->flags & W_ASSIGNASSOC)
9500 else if ((tlist->word->flags & (W_ASSIGNARRAY|W_ASSNGLOBAL)) == (W_ASSIGNARRAY|W_ASSNGLOBAL))
9505 else if (tlist->word->flags & W_ASSIGNARRAY)
9507 else if (tlist->word->flags & W_ASSNGLOBAL)
9511 /* If we have special handling note the integer attribute */
9512 if (opti > 0 && (tlist->word->flags & W_ASSIGNINT))
9518 make_internal_declare (tlist->word->word, opts);
9520 t = do_word_assignment (tlist->word, 0);
9523 last_command_exit_value = EXECUTION_FAILURE;
9524 exp_jump_to_top_level (DISCARD);
9527 /* Now transform the word as ksh93 appears to do and go on */
9528 t = assignment (tlist->word->word, 0);
9529 tlist->word->word[t] = '\0';
9530 tlist->word->flags &= ~(W_ASSIGNMENT|W_NOSPLIT|W_COMPASSIGN|W_ASSIGNARG|W_ASSIGNASSOC|W_ASSIGNARRAY);
9534 expanded_something = 0;
9535 expanded = expand_word_internal
9536 (tlist->word, 0, 0, &has_dollar_at, &expanded_something);
9538 if (expanded == &expand_word_error || expanded == &expand_word_fatal)
9540 /* By convention, each time this error is returned,
9541 tlist->word->word has already been freed. */
9542 tlist->word->word = (char *)NULL;
9544 /* Dispose our copy of the original list. */
9545 dispose_words (orig_list);
9546 /* Dispose the new list we're building. */
9547 dispose_words (new_list);
9549 last_command_exit_value = EXECUTION_FAILURE;
9550 if (expanded == &expand_word_error)
9551 exp_jump_to_top_level (DISCARD);
9553 exp_jump_to_top_level (FORCE_EOF);
9556 /* Don't split words marked W_NOSPLIT. */
9557 if (expanded_something && (tlist->word->flags & W_NOSPLIT) == 0)
9559 temp_list = word_list_split (expanded);
9560 dispose_words (expanded);
9564 /* If no parameter expansion, command substitution, process
9565 substitution, or arithmetic substitution took place, then
9566 do not do word splitting. We still have to remove quoted
9567 null characters from the result. */
9568 word_list_remove_quoted_nulls (expanded);
9569 temp_list = expanded;
9572 expanded = REVERSE_LIST (temp_list, WORD_LIST *);
9573 new_list = (WORD_LIST *)list_append (expanded, new_list);
9577 dispose_words (orig_list);
9580 new_list = REVERSE_LIST (new_list, WORD_LIST *);
9585 /* The workhorse for expand_words () and expand_words_no_vars ().
9586 First arg is LIST, a WORD_LIST of words.
9587 Second arg EFLAGS is a flags word controlling which expansions are
9590 This does all of the substitutions: brace expansion, tilde expansion,
9591 parameter expansion, command substitution, arithmetic expansion,
9592 process substitution, word splitting, and pathname expansion, according
9593 to the bits set in EFLAGS. Words with the W_QUOTED or W_NOSPLIT bits
9594 set, or for which no expansion is done, do not undergo word splitting.
9595 Words with the W_NOGLOB bit set do not undergo pathname expansion; words
9596 with W_NOBRACE set do not undergo brace expansion (see
9597 brace_expand_word_list above). */
9599 expand_word_list_internal (list, eflags)
9603 WORD_LIST *new_list, *temp_list;
9606 tempenv_assign_error = 0;
9608 return ((WORD_LIST *)NULL);
9610 garglist = new_list = copy_word_list (list);
9611 if (eflags & WEXP_VARASSIGN)
9613 garglist = new_list = separate_out_assignments (new_list);
9616 if (subst_assign_varlist)
9618 /* All the words were variable assignments, so they are placed
9619 into the shell's environment. */
9620 for (temp_list = subst_assign_varlist; temp_list; temp_list = temp_list->next)
9622 this_command_name = (char *)NULL; /* no arithmetic errors */
9623 tint = do_word_assignment (temp_list->word, 0);
9624 /* Variable assignment errors in non-interactive shells
9625 running in Posix.2 mode cause the shell to exit. */
9628 last_command_exit_value = EXECUTION_FAILURE;
9629 if (interactive_shell == 0 && posixly_correct)
9630 exp_jump_to_top_level (FORCE_EOF);
9632 exp_jump_to_top_level (DISCARD);
9635 dispose_words (subst_assign_varlist);
9636 subst_assign_varlist = (WORD_LIST *)NULL;
9638 return ((WORD_LIST *)NULL);
9642 /* Begin expanding the words that remain. The expansions take place on
9643 things that aren't really variable assignments. */
9645 #if defined (BRACE_EXPANSION)
9646 /* Do brace expansion on this word if there are any brace characters
9648 if ((eflags & WEXP_BRACEEXP) && brace_expansion && new_list)
9649 new_list = brace_expand_word_list (new_list, eflags);
9650 #endif /* BRACE_EXPANSION */
9652 /* Perform the `normal' shell expansions: tilde expansion, parameter and
9653 variable substitution, command substitution, arithmetic expansion,
9654 and word splitting. */
9655 new_list = shell_expand_word_list (new_list, eflags);
9657 /* Okay, we're almost done. Now let's just do some filename
9661 if ((eflags & WEXP_PATHEXP) && disallow_filename_globbing == 0)
9662 /* Glob expand the word list unless globbing has been disabled. */
9663 new_list = glob_expand_word_list (new_list, eflags);
9665 /* Dequote the words, because we're not performing globbing. */
9666 new_list = dequote_list (new_list);
9669 if ((eflags & WEXP_VARASSIGN) && subst_assign_varlist)
9671 sh_wassign_func_t *assign_func;
9672 int is_special_builtin, is_builtin_or_func;
9674 /* If the remainder of the words expand to nothing, Posix.2 requires
9675 that the variable and environment assignments affect the shell's
9677 assign_func = new_list ? assign_in_env : do_word_assignment;
9678 tempenv_assign_error = 0;
9680 is_builtin_or_func = (new_list && new_list->word && (find_shell_builtin (new_list->word->word) || find_function (new_list->word->word)));
9681 /* Posix says that special builtins exit if a variable assignment error
9682 occurs in an assignment preceding it. */
9683 is_special_builtin = (posixly_correct && new_list && new_list->word && find_special_builtin (new_list->word->word));
9685 for (temp_list = subst_assign_varlist; temp_list; temp_list = temp_list->next)
9687 this_command_name = (char *)NULL;
9688 assigning_in_environment = (assign_func == assign_in_env);
9689 tint = (*assign_func) (temp_list->word, is_builtin_or_func);
9690 assigning_in_environment = 0;
9691 /* Variable assignment errors in non-interactive shells running
9692 in Posix.2 mode cause the shell to exit. */
9695 if (assign_func == do_word_assignment)
9697 last_command_exit_value = EXECUTION_FAILURE;
9698 if (interactive_shell == 0 && posixly_correct && is_special_builtin)
9699 exp_jump_to_top_level (FORCE_EOF);
9701 exp_jump_to_top_level (DISCARD);
9704 tempenv_assign_error++;
9708 dispose_words (subst_assign_varlist);
9709 subst_assign_varlist = (WORD_LIST *)NULL;